Merge pull request #33 from Ekleog/no-linker-shenanigans

do not rely on linker shenanigans to work with a single binary

Author: rkuhn

Cargo.lock

@@ -1,5 +1,5 @@
 [workspace]
-members = ["cli", "core", "machine", "nat", "router", "."]
+members = ["cli", "core", "machine", "macros", "nat", "router", "."]
 
 [package]
 name = "netsim-embed"
@@ -11,7 +11,7 @@ license = "MIT"
 repository = "https://github.com/ipfs-rust/netsim-embed"
 
 [features]
-ipc = ["dep:libtest-mimic", "dep:anyhow", "dep:ipc-channel", "dep:dlopen"]
+ipc = ["dep:libtest-mimic", "dep:anyhow", "dep:ipc-channel", "dep:netsim-embed-macros", "dep:serde"]
 
 [dependencies]
 anyhow = { version = "1.0.40", optional = true }
@@ -25,8 +25,10 @@ libtest-mimic = { version = "0.6.0", optional = true }
 log = "0.4.14"
 netsim-embed-core = { version = "0.4.2", path = "core" }
 netsim-embed-machine = { version = "0.6.3", path = "machine" }
+netsim-embed-macros = { version = "0.1.0", path = "macros", optional = true }
 netsim-embed-nat = { version = "0.4.1", path = "nat" }
 netsim-embed-router = { version = "0.4.5", path = "router" }
+serde = { version = "1.0", optional = true }
 
 [dev-dependencies]
 anyhow = "1.0.40"

Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "netsim-embed-macros"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "1.0"
+rand = "0.8.5"
+syn = "1.0"

build.rs

@@ -0,0 +1,74 @@
+use proc_macro::TokenStream;
+
+#[proc_macro_attribute]
+pub fn machine(_attrs: TokenStream, fun: TokenStream) -> TokenStream {
+    let f = syn::parse_macro_input!(fun as syn::ItemFn);
+
+    assert!(
+        f.attrs.is_empty(),
+        "netsim_embed::machine cannot have any attribute"
+    );
+    assert!(
+        f.sig.constness.is_none(),
+        "netsim_embed::machine cannot be const"
+    );
+    assert!(
+        f.sig.asyncness.is_none(),
+        "netsim_embed::machine cannot be async"
+    );
+    assert!(
+        f.sig.unsafety.is_none(),
+        "netsim_embed::machine cannot be unsafe"
+    );
+    assert!(
+        f.sig.abi.is_none(),
+        "netsim_embed::machine cannot have an abi defined"
+    );
+    assert!(
+        f.sig.generics.params.is_empty(),
+        "netsim_embed::machine cannot be generic"
+    );
+    assert!(
+        f.sig.inputs.len() == 1,
+        "netsim_embed::machine must take exactly one argument"
+    );
+    assert!(
+        f.sig.variadic.is_none(),
+        "netsim_embed::machine cannot be variadic"
+    );
+    assert!(
+        matches!(f.sig.output, syn::ReturnType::Default),
+        "netsim_embed::machine must not declare a return type"
+    );
+
+    let input = match &f.sig.inputs.first().unwrap() {
+        syn::FnArg::Typed(input) => input,
+        _ => panic!("netsim_embed::machine must be a freestanding function"),
+    };
+    assert!(
+        input.attrs.is_empty(),
+        "netsim_embed::machine's only argument must not have any attributes attached"
+    );
+
+    let f_vis = f.vis;
+    let f_ident = f.sig.ident;
+    let input_ty = &input.ty;
+    let id: u128 = rand::random();
+    let input_pat = &input.pat;
+    let f_block = f.block;
+
+    TokenStream::from(quote::quote! {
+        #[allow(non_camel_case_types)]
+        #f_vis struct #f_ident ;
+
+        impl netsim_embed::MachineFn for #f_ident {
+            type Arg = #input_ty ;
+
+            fn id() -> u128 {
+                #id
+            }
+
+            fn call(#input_pat: #input_ty) #f_block
+        }
+    })
+}

macros/Cargo.toml

@@ -72,19 +72,23 @@ where
     }
 
     #[cfg(feature = "ipc")]
-    pub async fn spawn<T: 'static + Send>(
-        &mut self,
-        function: fn(ipc_channel::ipc::IpcReceiver<T>),
-    ) -> (MachineId, ipc_channel::ipc::IpcSender<T>) {
-        let name = get_fn_name(function);
-        let (server, server_name) = ipc_channel::ipc::IpcOneShotServer::new().unwrap();
+    pub async fn spawn<M: MachineFn>(&mut self, _machine: M, arg: M::Arg) -> MachineId {
+        use ipc_channel::ipc;
+        let id = M::id();
+        let (server, server_name) = ipc::IpcOneShotServer::<ipc::IpcSender<M::Arg>>::new().unwrap();
         let mut command = Command::new(std::env::current_exe().unwrap());
-        command.args(["--netsim-embed-internal-call", &name, &server_name]);
+        command.args([
+            "--netsim-embed-internal-call",
+            &format!("{}", id),
+            &server_name,
+        ]);
         let machine = self.spawn_machine(command, None).await;
         let (_, ipc) = async_global_executor::spawn_blocking(|| server.accept())
             .await
             .unwrap();
-        (machine, ipc)
+        ipc.send(arg)
+            .expect("Failed sending argument to child process");
+        machine
     }
 
     pub async fn spawn_machine(
@@ -204,16 +208,6 @@ where
     }
 }
 
-#[cfg(feature = "ipc")]
-pub fn get_fn_name<T>(function: fn(ipc_channel::ipc::IpcReceiver<T>)) -> String {
-    let info = dlopen::raw::AddressInfoObtainer::new()
-        .obtain(function as *const ())
-        .expect("look up existing function pointer");
-    info.overlapping_symbol
-        .expect("cannot find function symbol: have you used #[no_mangle] for machine definitions and emitted `cargo:rustc-link-arg-tests=-rdynamic` from build.rs?")
-        .name
-}
-
 #[derive(Debug)]
 pub struct Network {
     id: NetworkId,
@@ -257,6 +251,16 @@ pub struct NatConfig {
     pub forward_ports: Vec<(Protocol, u16, SocketAddrV4)>,
 }
 
+#[cfg(feature = "ipc")]
+pub trait MachineFn {
+    type Arg: 'static + Send + serde::Serialize;
+    fn id() -> u128;
+    fn call(arg: Self::Arg);
+}
+
+#[cfg(feature = "ipc")]
+pub use netsim_embed_macros::machine;
+
 #[allow(clippy::needless_doctest_main)]
 /// Dispatch spawned machine invocations to their declared functions.
 ///
@@ -272,18 +276,19 @@ pub struct NatConfig {
 #[cfg(feature = "ipc")]
 #[macro_export]
 macro_rules! declare_machines {
-    ( $($fn:path),* ) => {{
+    ( $($machine:path),* ) => {{
         let mut args = std::env::args();
         args.next();
         if args.next().map(|v| v == "--netsim-embed-internal-call").unwrap_or(false) {
             let function = args.next().unwrap();
             let server_name = args.next().unwrap();
+            let function: u128 = function.parse().expect("Got a non-integer function to call");
             $(
-                if function == $crate::get_fn_name($fn) {
+                if function == <$machine as $crate::MachineFn>::id() {
                     let (sender, receiver) = $crate::test_util::ipc::channel().unwrap();
                     let server_sender = $crate::test_util::ipc::IpcSender::connect(server_name).unwrap();
                     server_sender.send(sender).unwrap();
-                    $fn(receiver);
+                    <$machine as $crate::MachineFn>::call(receiver.recv().expect("Failed receiving argument from main process"));
                     std::process::exit(0);
                 }
             )*

macros/src/lib.rs

@@ -1,14 +1,12 @@
 use ipc_channel::ipc::{IpcReceiver, IpcSender};
 
-#[no_mangle]
-pub fn send_one(r: IpcReceiver<IpcSender<usize>>) {
-    let sender = r.recv().unwrap();
+#[netsim_embed::machine]
+fn send_one(sender: IpcSender<usize>) {
     sender.send(1).unwrap();
 }
 
-#[no_mangle]
-pub fn add(r: IpcReceiver<(IpcReceiver<usize>, IpcReceiver<usize>, IpcSender<usize>)>) {
-    let (left, right, sender) = r.recv().unwrap();
+#[netsim_embed::machine]
+fn add((left, right, sender): (IpcReceiver<usize>, IpcReceiver<usize>, IpcSender<usize>)) {
     sender
         .send(left.recv().unwrap() + right.recv().unwrap())
         .unwrap();
@@ -17,8 +15,7 @@ pub fn add(r: IpcReceiver<(IpcReceiver<usize>, IpcReceiver<usize>, IpcSender<usi
 fn can_send_one() {
     let mut s = netsim_embed::Netsim::<String, String>::new();
     let (sender, receiver) = ipc_channel::ipc::channel().unwrap();
-    let (_, mach_sender) = async_std::task::block_on(s.spawn(send_one));
-    mach_sender.send(sender).unwrap();
+    let _ = async_std::task::block_on(s.spawn(send_one, sender));
     assert_eq!(1, receiver.recv().unwrap());
 }
 
@@ -27,16 +24,13 @@ fn one_plus_one_makes_two() {
         let mut s = netsim_embed::Netsim::<String, String>::new();
 
         let (sender1, receiver1) = ipc_channel::ipc::channel::<usize>().unwrap();
-        let (_, mach_sender1) = s.spawn(send_one).await;
-        mach_sender1.send(sender1).unwrap();
+        let _ = s.spawn(send_one, sender1).await;
 
         let (sender2, receiver2) = ipc_channel::ipc::channel::<usize>().unwrap();
-        let (_, mach_sender2) = s.spawn(send_one).await;
-        mach_sender2.send(sender2).unwrap();
+        let _ = s.spawn(send_one, sender2).await;
 
         let (sender3, receiver3) = ipc_channel::ipc::channel::<usize>().unwrap();
-        let (_, mach_sender3) = s.spawn(add).await;
-        mach_sender3.send((receiver1, receiver2, sender3)).unwrap();
+        let _ = s.spawn(add, (receiver1, receiver2, sender3)).await;
 
         assert_eq!(2, receiver3.recv().unwrap());
     })