Feat/web (PatchSet 1) (#436)

* move rpc-build out of easytier dir and make it a independant project
* easytier core use launcher
* fix flags not print on launch
* allow launcher not fetch node info
* abstract out peer rpc impl
* fix arm gui ci. see https://github.com/actions/runner-images/pull/10807
* add easytier-web crate
* fix manual_connector test case

easytier/src/proto/rpc_impl/bidirect.rs

@@ -0,0 +1,164 @@
+use std::sync::{Arc, Mutex};
+
+use futures::{SinkExt as _, StreamExt};
+use tokio::{task::JoinSet, time::timeout};
+
+use crate::{
+    proto::rpc_types::error::Error,
+    tunnel::{packet_def::PacketType, ring::create_ring_tunnel_pair, Tunnel},
+};
+
+use super::{client::Client, server::Server};
+
+pub struct BidirectRpcManager {
+    rpc_client: Client,
+    rpc_server: Server,
+
+    rx_timeout: Option<std::time::Duration>,
+    error: Arc<Mutex<Option<Error>>>,
+    tunnel: Mutex<Option<Box<dyn Tunnel>>>,
+
+    tasks: Mutex<Option<JoinSet<()>>>,
+}
+
+impl BidirectRpcManager {
+    pub fn new() -> Self {
+        Self {
+            rpc_client: Client::new(),
+            rpc_server: Server::new(),
+
+            rx_timeout: None,
+            error: Arc::new(Mutex::new(None)),
+            tunnel: Mutex::new(None),
+
+            tasks: Mutex::new(None),
+        }
+    }
+
+    pub fn set_rx_timeout(mut self, timeout: Option<std::time::Duration>) -> Self {
+        self.rx_timeout = timeout;
+        self
+    }
+
+    pub fn run_and_create_tunnel(&self) -> Box<dyn Tunnel> {
+        let (ret, inner) = create_ring_tunnel_pair();
+        self.run_with_tunnel(inner);
+        ret
+    }
+
+    pub fn run_with_tunnel(&self, inner: Box<dyn Tunnel>) {
+        let mut tasks = JoinSet::new();
+        self.rpc_client.run();
+        self.rpc_server.run();
+
+        let (server_tx, mut server_rx) = (
+            self.rpc_server.get_transport_sink(),
+            self.rpc_server.get_transport_stream(),
+        );
+        let (client_tx, mut client_rx) = (
+            self.rpc_client.get_transport_sink(),
+            self.rpc_client.get_transport_stream(),
+        );
+
+        let (mut inner_rx, mut inner_tx) = inner.split();
+        self.tunnel.lock().unwrap().replace(inner);
+
+        let e_clone = self.error.clone();
+        tasks.spawn(async move {
+            loop {
+                let packet = tokio::select! {
+                    Some(Ok(packet)) = server_rx.next() => {
+                        tracing::trace!(?packet, "recv rpc packet from server");
+                        packet
+                    }
+                    Some(Ok(packet)) = client_rx.next() => {
+                        tracing::trace!(?packet, "recv rpc packet from client");
+                        packet
+                    }
+                    else => {
+                        tracing::warn!("rpc transport read aborted, exiting");
+                        break;
+                    }
+                };
+
+                if let Err(e) = inner_tx.send(packet).await {
+                    tracing::error!(error = ?e, "send to peer failed");
+                    e_clone.lock().unwrap().replace(Error::from(e));
+                }
+            }
+        });
+
+        let recv_timeout = self.rx_timeout;
+        let e_clone = self.error.clone();
+        tasks.spawn(async move {
+            loop {
+                let ret = if let Some(recv_timeout) = recv_timeout {
+                    match timeout(recv_timeout, inner_rx.next()).await {
+                        Ok(ret) => ret,
+                        Err(e) => {
+                            e_clone.lock().unwrap().replace(e.into());
+                            break;
+                        }
+                    }
+                } else {
+                    inner_rx.next().await
+                };
+
+                let o = match ret {
+                    Some(Ok(o)) => o,
+                    Some(Err(e)) => {
+                        tracing::error!(error = ?e, "recv from peer failed");
+                        e_clone.lock().unwrap().replace(Error::from(e));
+                        break;
+                    }
+                    None => {
+                        tracing::warn!("peer rpc transport read aborted, exiting");
+                        e_clone.lock().unwrap().replace(Error::Shutdown);
+                        break;
+                    }
+                };
+
+                if o.peer_manager_header().unwrap().packet_type == PacketType::RpcReq as u8 {
+                    server_tx.send(o).await.unwrap();
+                    continue;
+                } else if o.peer_manager_header().unwrap().packet_type == PacketType::RpcResp as u8
+                {
+                    client_tx.send(o).await.unwrap();
+                    continue;
+                }
+            }
+        });
+
+        self.tasks.lock().unwrap().replace(tasks);
+    }
+
+    pub fn rpc_client(&self) -> &Client {
+        &self.rpc_client
+    }
+
+    pub fn rpc_server(&self) -> &Server {
+        &self.rpc_server
+    }
+
+    pub async fn stop(&self) {
+        let Some(mut tasks) = self.tasks.lock().unwrap().take() else {
+            return;
+        };
+        tasks.abort_all();
+        while let Some(_) = tasks.join_next().await {}
+    }
+
+    pub fn take_error(&self) -> Option<Error> {
+        self.error.lock().unwrap().take()
+    }
+
+    pub async fn wait(&self) {
+        let Some(mut tasks) = self.tasks.lock().unwrap().take() else {
+            return;
+        };
+        while let Some(_) = tasks.join_next().await {
+            // when any task is done, abort all tasks
+            tasks.abort_all();
+        }
+    }
+}

easytier/src/proto/rpc_impl/mod.rs

@@ -2,6 +2,7 @@ use crate::tunnel::{mpsc::MpscTunnel, Tunnel};
 
 pub type RpcController = super::rpc_types::controller::BaseController;
 
+pub mod bidirect;
 pub mod client;
 pub mod packet;
 pub mod server;

easytier/src/proto/rpc_impl/service_registry.rs

@@ -59,6 +59,14 @@ impl ServiceRegistry {
         }
     }
 
+    pub fn replace_registry(&self, registry: &ServiceRegistry) {
+        self.table.clear();
+        for item in registry.table.iter() {
+            let (k, v) = item.pair();
+            self.table.insert(k.clone(), v.clone());
+        }
+    }
+
     pub fn register<H: Handler<Controller = RpcController>>(&self, h: H, domain_name: &str) {
         let desc = h.service_descriptor();
         let key = ServiceKey {

easytier/src/proto/rpc_impl/standalone.rs

@@ -4,66 +4,18 @@ use std::{
 };
 
 use anyhow::Context as _;
-use futures::{SinkExt as _, StreamExt};
 use tokio::task::JoinSet;
 
 use crate::{
     common::join_joinset_background,
-    proto::rpc_types::{__rt::RpcClientFactory, error::Error},
+    proto::{
+        rpc_impl::bidirect::BidirectRpcManager,
+        rpc_types::{__rt::RpcClientFactory, error::Error},
+    },
     tunnel::{Tunnel, TunnelConnector, TunnelListener},
 };
 
-use super::{client::Client, server::Server, service_registry::ServiceRegistry};
-
-struct StandAloneServerOneTunnel {
-    tunnel: Box<dyn Tunnel>,
-    rpc_server: Server,
-}
-
-impl StandAloneServerOneTunnel {
-    pub fn new(tunnel: Box<dyn Tunnel>, registry: Arc<ServiceRegistry>) -> Self {
-        let rpc_server = Server::new_with_registry(registry);
-        StandAloneServerOneTunnel { tunnel, rpc_server }
-    }
-
-    pub async fn run(self) {
-        use tokio_stream::StreamExt as _;
-
-        let (tunnel_rx, tunnel_tx) = self.tunnel.split();
-        let (rpc_rx, rpc_tx) = (
-            self.rpc_server.get_transport_stream(),
-            self.rpc_server.get_transport_sink(),
-        );
-
-        let mut tasks = JoinSet::new();
-
-        tasks.spawn(async move {
-            let ret = tunnel_rx.timeout(Duration::from_secs(60));
-            tokio::pin!(ret);
-            while let Ok(Some(Ok(p))) = ret.try_next().await {
-                if let Err(e) = rpc_tx.send(p).await {
-                    tracing::error!("tunnel_rx send to rpc_tx error: {:?}", e);
-                    break;
-                }
-            }
-            tracing::info!("forward tunnel_rx to rpc_tx done");
-        });
-
-        tasks.spawn(async move {
-            let ret = rpc_rx.forward(tunnel_tx).await;
-            tracing::info!("rpc_rx forward tunnel_tx done: {:?}", ret);
-        });
-
-        self.rpc_server.run();
-
-        while let Some(ret) = tasks.join_next().await {
-            self.rpc_server.close();
-            tracing::info!("task done: {:?}", ret);
-        }
-
-        tracing::info!("all tasks done");
-    }
-}
+use super::service_registry::ServiceRegistry;
 
 pub struct StandAloneServer<L> {
     registry: Arc<ServiceRegistry>,
@@ -102,11 +54,15 @@ impl<L: TunnelListener + 'static> StandAloneServer<L> {
 
         self.tasks.lock().unwrap().spawn(async move {
             while let Ok(tunnel) = listener.accept().await {
-                let server = StandAloneServerOneTunnel::new(tunnel, registry.clone());
+                let registry = registry.clone();
                 let inflight_server = inflight_server.clone();
                 inflight_server.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
                 tasks.lock().unwrap().spawn(async move {
-                    server.run().await;
+                    let server =
+                        BidirectRpcManager::new().set_rx_timeout(Some(Duration::from_secs(60)));
+                    server.rpc_server().registry().replace_registry(&registry);
+                    server.run_with_tunnel(tunnel);
+                    server.wait().await;
                     inflight_server.fetch_sub(1, std::sync::atomic::Ordering::Relaxed);
                 });
             }
@@ -122,86 +78,9 @@ impl<L: TunnelListener + 'static> StandAloneServer<L> {
     }
 }
 
-struct StandAloneClientOneTunnel {
-    rpc_client: Client,
-    tasks: Arc<Mutex<JoinSet<()>>>,
-    error: Arc<Mutex<Option<Error>>>,
-}
-
-impl StandAloneClientOneTunnel {
-    pub fn new(tunnel: Box<dyn Tunnel>) -> Self {
-        let rpc_client = Client::new();
-        let (mut rpc_rx, rpc_tx) = (
-            rpc_client.get_transport_stream(),
-            rpc_client.get_transport_sink(),
-        );
-        let tasks = Arc::new(Mutex::new(JoinSet::new()));
-
-        let (mut tunnel_rx, mut tunnel_tx) = tunnel.split();
-
-        let error_store = Arc::new(Mutex::new(None));
-
-        let error = error_store.clone();
-        tasks.lock().unwrap().spawn(async move {
-            while let Some(p) = rpc_rx.next().await {
-                match p {
-                    Ok(p) => {
-                        if let Err(e) = tunnel_tx
-                            .send(p)
-                            .await
-                            .with_context(|| "failed to send packet")
-                        {
-                            *error.lock().unwrap() = Some(e.into());
-                        }
-                    }
-                    Err(e) => {
-                        *error.lock().unwrap() = Some(anyhow::Error::from(e).into());
-                    }
-                }
-            }
-
-            *error.lock().unwrap() = Some(anyhow::anyhow!("rpc_rx next exit").into());
-        });
-
-        let error = error_store.clone();
-        tasks.lock().unwrap().spawn(async move {
-            while let Some(p) = tunnel_rx.next().await {
-                match p {
-                    Ok(p) => {
-                        if let Err(e) = rpc_tx
-                            .send(p)
-                            .await
-                            .with_context(|| "failed to send packet")
-                        {
-                            *error.lock().unwrap() = Some(e.into());
-                        }
-                    }
-                    Err(e) => {
-                        *error.lock().unwrap() = Some(anyhow::Error::from(e).into());
-                    }
-                }
-            }
-
-            *error.lock().unwrap() = Some(anyhow::anyhow!("tunnel_rx next exit").into());
-        });
-
-        rpc_client.run();
-
-        StandAloneClientOneTunnel {
-            rpc_client,
-            tasks,
-            error: error_store,
-        }
-    }
-
-    pub fn take_error(&self) -> Option<Error> {
-        self.error.lock().unwrap().take()
-    }
-}
-
 pub struct StandAloneClient<C: TunnelConnector> {
     connector: C,
-    client: Option<StandAloneClientOneTunnel>,
+    client: Option<BidirectRpcManager>,
 }
 
 impl<C: TunnelConnector> StandAloneClient<C> {
@@ -230,7 +109,9 @@ impl<C: TunnelConnector> StandAloneClient<C> {
         if c.is_none() || error.is_some() {
             tracing::info!("reconnect due to error: {:?}", error);
             let tunnel = self.connect().await?;
-            c = Some(StandAloneClientOneTunnel::new(tunnel));
+            let mgr = BidirectRpcManager::new().set_rx_timeout(Some(Duration::from_secs(60)));
+            mgr.run_with_tunnel(tunnel);
+            c = Some(mgr);
         }
 
         self.client = c;
@@ -239,7 +120,7 @@ impl<C: TunnelConnector> StandAloneClient<C> {
             .client
             .as_ref()
             .unwrap()
-            .rpc_client
+            .rpc_client()
             .scoped_client::<F>(1, 1, domain_name))
     }
 }