aquatic_udp: glommio: start executors in mod.rs, update TODO

aquatic_udp/src/lib/glommio/handlers.rs

@@ -3,7 +3,6 @@ use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
 use futures_lite::stream::empty;
 use futures_lite::StreamExt;
 use glommio::channels::channel_mesh::{MeshBuilder, Partial, Role};
-use glommio::prelude::*;
 use rand::prelude::SmallRng;
 use rand::SeedableRng;
 
@@ -11,15 +10,12 @@ use crate::common::announce::handle_announce_request;
 use crate::common::*;
 use crate::config::Config;
 
-pub fn run_request_worker(
+pub async fn run_request_worker(
     config: Config,
     request_mesh_builder: MeshBuilder<(usize, AnnounceRequest, SocketAddr), Partial>,
     response_mesh_builder: MeshBuilder<(AnnounceResponse, SocketAddr), Partial>,
 ) {
-    LocalExecutorBuilder::default()
+    let (_, mut request_receivers) = request_mesh_builder.join(Role::Consumer).await.unwrap();
-        .spawn(|| async move {
-            let (_, mut request_receivers) =
-                request_mesh_builder.join(Role::Consumer).await.unwrap();
     let (response_senders, _) = response_mesh_builder.join(Role::Producer).await.unwrap();
 
     let mut rng = SmallRng::from_entropy();
@@ -61,8 +57,4 @@ pub fn run_request_worker(
             ::log::warn!("response_sender.try_send: {:?}", err);
         }
     }
-        })
-        .expect("failed to spawn local executor")
-        .join()
-        .unwrap();
 }

aquatic_udp/src/lib/glommio/mod.rs

@@ -1,6 +1,7 @@
 use std::sync::{atomic::AtomicUsize, Arc};
 
 use glommio::channels::channel_mesh::MeshBuilder;
+use glommio::prelude::*;
 
 use crate::config::Config;
 
@@ -15,21 +16,44 @@ pub fn run(config: Config) -> anyhow::Result<()> {
 
     let num_bound_sockets = Arc::new(AtomicUsize::new(0));
 
+    let mut executors = Vec::new();
+
     for _ in 0..(config.socket_workers) {
+        let config = config.clone();
+        let request_mesh_builder = request_mesh_builder.clone();
+        let response_mesh_builder = response_mesh_builder.clone();
+        let num_bound_sockets = num_bound_sockets.clone();
+
+        let executor = LocalExecutorBuilder::default().spawn(|| async move {
             network::run_socket_worker(
-            config.clone(),
+                config,
-            request_mesh_builder.clone(),
+                request_mesh_builder,
-            response_mesh_builder.clone(),
+                response_mesh_builder,
-            num_bound_sockets.clone(),
+                num_bound_sockets,
-        );
+            )
+            .await
+        });
+
+        executors.push(executor);
     }
 
     for _ in 0..(config.request_workers) {
-        handlers::run_request_worker(
+        let config = config.clone();
-            config.clone(),
+        let request_mesh_builder = request_mesh_builder.clone();
-            request_mesh_builder.clone(),
+        let response_mesh_builder = response_mesh_builder.clone();
-            response_mesh_builder.clone(),
+
-        );
+        let executor = LocalExecutorBuilder::default().spawn(|| async move {
+            handlers::run_request_worker(config, request_mesh_builder, response_mesh_builder).await
+        });
+
+        executors.push(executor);
+    }
+
+    for executor in executors {
+        executor
+            .expect("failed to spawn local executor")
+            .join()
+            .unwrap();
     }
 
     Ok(())

aquatic_udp/src/lib/glommio/network.rs

@@ -1,5 +1,3 @@
-/// TODO
-/// - Don't use race, use other means to receive from multiple channels
 use std::io::Cursor;
 use std::net::{IpAddr, SocketAddr};
 use std::rc::Rc;
@@ -20,14 +18,12 @@ use aquatic_udp_protocol::{IpVersion, Request, Response};
 use crate::common::*;
 use crate::config::Config;
 
-pub fn run_socket_worker(
+pub async fn run_socket_worker(
     config: Config,
     request_mesh_builder: MeshBuilder<(usize, AnnounceRequest, SocketAddr), Partial>,
     response_mesh_builder: MeshBuilder<(AnnounceResponse, SocketAddr), Partial>,
     num_bound_sockets: Arc<AtomicUsize>,
 ) {
-    LocalExecutorBuilder::default()
-        .spawn(|| async move {
     let (local_sender, local_receiver) = new_unbounded();
 
     let mut socket = UdpSocket::bind(config.network.address).unwrap();
@@ -56,11 +52,8 @@ pub fn run_socket_worker(
         socket.clone(),
     ))
     .await;
+
     spawn_local(send_responses(response_receivers, local_receiver, socket)).await;
-        })
-        .expect("failed to spawn local executor")
-        .join()
-        .unwrap();
 }
 
 async fn read_requests(