feat(wireguard-broker): merge from dev/broker-architecture, fixes, test

* wireguard-broker: merge from dev/broker-architecture
* use zerocopy instead of lenses
* Require use_broker feature flag to comile broker binaries
* Remove PhantomData from BrokerServer & BrokerClient
* Modify mio client rx to be non-recursive, add integration test

Co-authored-by: Karolin Varner <karo@cupdev.net>
Co-authored-by: Prabhpreet Dua <615318+prabhpreet@users.noreply.github.com>

wireguard-broker/tests/integration.rs

@@ -0,0 +1,126 @@
+#[cfg(feature = "enable_broker")]
+#[cfg(test)]
+mod integration_tests {
+
+    use rand::Rng;
+    use rosenpass_wireguard_broker::api::mio_client::MioBrokerClient;
+    use rosenpass_wireguard_broker::api::msgs::{
+        SetPskError, REQUEST_MSG_BUFFER_SIZE, RESPONSE_MSG_BUFFER_SIZE,
+    };
+    use rosenpass_wireguard_broker::api::server::{BrokerServer, BrokerServerError};
+    use rosenpass_wireguard_broker::WireGuardBroker;
+    use std::io::Read;
+    use std::sync::{Arc, Mutex};
+
+    #[derive(Default)]
+    struct MockServerBrokerInner {
+        psk: Option<[u8; 32]>,
+        peer_id: Option<[u8; 32]>,
+        interface: Option<String>,
+    }
+
+    struct MockServerBroker {
+        inner: Arc<Mutex<MockServerBrokerInner>>,
+    }
+
+    impl MockServerBroker {
+        fn new(inner: Arc<Mutex<MockServerBrokerInner>>) -> Self {
+            Self { inner }
+        }
+    }
+
+    impl WireGuardBroker for MockServerBroker {
+        type Error = SetPskError;
+
+        fn set_psk(
+            &mut self,
+            interface: &str,
+            peer_id: [u8; 32],
+            psk: [u8; 32],
+        ) -> Result<(), Self::Error> {
+            loop {
+                let mut lock = self.inner.try_lock();
+
+                if let Ok(ref mut mutex) = lock {
+                    **mutex = MockServerBrokerInner {
+                        psk: Some(psk),
+                        peer_id: Some(peer_id),
+                        interface: Some(interface.to_string()),
+                    };
+                    break;
+                }
+            }
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn test_psk_exchanges() {
+        const TEST_RUNS: usize = 100;
+
+        let server_broker_inner = Arc::new(Mutex::new(MockServerBrokerInner::default()));
+        // Create a mock BrokerServer
+        let server_broker = MockServerBroker::new(server_broker_inner.clone());
+
+        let mut server = BrokerServer::<SetPskError, MockServerBroker>::new(server_broker);
+
+        let (client_socket, mut server_socket) = mio::net::UnixStream::pair().unwrap();
+
+        // Spawn a new thread to connect to the unix socket
+        let handle = std::thread::spawn(move || {
+            for _ in 0..TEST_RUNS {
+                // Wait for 8 bytes of length to come in
+                let mut length_buffer = [0; 8];
+
+                while let Err(_err) = server_socket.read_exact(&mut length_buffer) {}
+
+                let length = u64::from_le_bytes(length_buffer) as usize;
+
+                // Read the amount of length bytes into a buffer
+                let mut data_buffer = [0; REQUEST_MSG_BUFFER_SIZE];
+                while let Err(_err) = server_socket.read_exact(&mut data_buffer[0..length]) {}
+
+                let mut response = [0; RESPONSE_MSG_BUFFER_SIZE];
+                server.handle_message(&data_buffer[0..length], &mut response)?;
+            }
+            Ok::<(), BrokerServerError>(())
+        });
+
+        // Create a MioBrokerClient and send a psk
+        let mut client = MioBrokerClient::new(client_socket);
+
+        for _ in 0..TEST_RUNS {
+            //Create psk of random 32 bytes
+            let mut psk: [u8; 32] = [0; 32];
+            rand::thread_rng().fill(&mut psk);
+            let mut peer_id: [u8; 32] = [0; 32];
+            rand::thread_rng().fill(&mut peer_id);
+            let interface = "test";
+            client.set_psk(&interface, peer_id, psk).unwrap();
+
+            //Sleep for a while to allow the server to process the message
+            std::thread::sleep(std::time::Duration::from_millis(
+                rand::thread_rng().gen_range(100..500),
+            ));
+
+            loop {
+                let mut lock = server_broker_inner.try_lock();
+
+                if let Ok(ref mut inner) = lock {
+                    // Check if the psk is received by the server
+                    let received_psk = inner.psk;
+                    assert_eq!(received_psk, Some(psk));
+
+                    let recieved_peer_id = inner.peer_id;
+                    assert_eq!(recieved_peer_id, Some(peer_id));
+
+                    let target_interface = &inner.interface;
+                    assert_eq!(target_interface.as_deref(), Some(interface));
+
+                    break;
+                }
+            }
+        }
+        handle.join().unwrap().unwrap();
+    }
+}