use customized rpc implementation, remove Tarpc & Tonic (#348)

This patch removes Tarpc & Tonic GRPC and implements a customized rpc framework, which can be used by peer rpc and cli interface.

web config server can also use this rpc framework.

moreover, rewrite the public server logic, use ospf route to implement public server based networking. this make public server mesh possible.

easytier/src/tunnel/common.rs

@@ -16,10 +16,9 @@ use tokio_stream::StreamExt;
 use tokio_util::io::poll_write_buf;
 use zerocopy::FromBytes as _;
 
-use crate::{
-    rpc::TunnelInfo,
-    tunnel::packet_def::{ZCPacket, PEER_MANAGER_HEADER_SIZE},
-};
+use super::TunnelInfo;
+
+use crate::tunnel::packet_def::{ZCPacket, PEER_MANAGER_HEADER_SIZE};
 
 use super::{
     buf::BufList,
@@ -505,8 +504,8 @@ pub mod tests {
             let ret = listener.accept().await.unwrap();
             println!("accept: {:?}", ret.info());
             assert_eq!(
-                ret.info().unwrap().local_addr,
-                listener.local_url().to_string()
+                url::Url::from(ret.info().unwrap().local_addr.unwrap()),
+                listener.local_url()
             );
             _tunnel_echo_server(ret, false).await
         });
@@ -515,8 +514,8 @@ pub mod tests {
         println!("connect: {:?}", tunnel.info());
 
         assert_eq!(
-            tunnel.info().unwrap().remote_addr,
-            connector.remote_url().to_string()
+            url::Url::from(tunnel.info().unwrap().remote_addr.unwrap()),
+            connector.remote_url(),
         );
 
         let (mut recv, mut send) = tunnel.split();

easytier/src/tunnel/filter.rs

@@ -3,10 +3,11 @@ use std::{
     task::{Context, Poll},
 };
 
-use crate::rpc::TunnelInfo;
 use auto_impl::auto_impl;
 use futures::{Sink, SinkExt, Stream, StreamExt};
 
+use crate::proto::common::TunnelInfo;
+
 use self::stats::Throughput;
 
 use super::*;

easytier/src/tunnel/mod.rs

@@ -8,7 +8,7 @@ use std::fmt::Debug;
 
 use tokio::time::error::Elapsed;
 
-use crate::rpc::TunnelInfo;
+use crate::proto::common::TunnelInfo;
 
 use self::packet_def::ZCPacket;
 

easytier/src/tunnel/mpsc.rs

@@ -3,9 +3,13 @@
 use std::{pin::Pin, time::Duration};
 
 use anyhow::Context;
-use tokio::{task::JoinHandle, time::timeout};
+use tokio::time::timeout;
 
-use super::{packet_def::ZCPacket, Tunnel, TunnelError, ZCPacketSink, ZCPacketStream};
+use crate::common::scoped_task::ScopedTask;
+
+use super::{
+    packet_def::ZCPacket, Tunnel, TunnelError, ZCPacketSink, ZCPacketStream,
+};
 
 use tachyonix::{channel, Receiver, Sender};
 
@@ -29,12 +33,12 @@ impl MpscTunnelSender {
 }
 
 pub struct MpscTunnel<T> {
-    tx: Sender<ZCPacket>,
+    tx: Option<Sender<ZCPacket>>,
 
     tunnel: T,
     stream: Option<Pin<Box<dyn ZCPacketStream>>>,
 
-    task: Option<JoinHandle<()>>,
+    task: ScopedTask<()>,
 }
 
 impl<T: Tunnel> MpscTunnel<T> {
@@ -54,10 +58,10 @@ impl<T: Tunnel> MpscTunnel<T> {
         });
 
         Self {
-            tx,
+            tx: Some(tx),
             tunnel,
             stream: Some(stream),
-            task: Some(task),
+            task: task.into(),
         }
     }
 
@@ -81,7 +85,12 @@ impl<T: Tunnel> MpscTunnel<T> {
     }
 
     pub fn get_sink(&self) -> MpscTunnelSender {
-        MpscTunnelSender(self.tx.clone())
+        MpscTunnelSender(self.tx.as_ref().unwrap().clone())
+    }
+
+    pub fn close(&mut self) {
+        self.tx.take();
+        self.task.abort();
     }
 }
 

easytier/src/tunnel/packet_def.rs

@@ -54,6 +54,8 @@ pub enum PacketType {
     Pong = 5,
     TaRpc = 6,
     Route = 7,
+    RpcReq = 8,
+    RpcResp = 9,
 }
 
 bitflags::bitflags! {

easytier/src/tunnel/quic.rs

@@ -4,12 +4,10 @@
 
 use std::{error::Error, net::SocketAddr, sync::Arc};
 
-use crate::{
-    rpc::TunnelInfo,
-    tunnel::{
-        check_scheme_and_get_socket_addr_ext,
-        common::{FramedReader, FramedWriter, TunnelWrapper},
-    },
+use crate::tunnel::{
+    check_scheme_and_get_socket_addr_ext,
+    common::{FramedReader, FramedWriter, TunnelWrapper},
+    TunnelInfo,
 };
 use anyhow::Context;
 use quinn::{crypto::rustls::QuicClientConfig, ClientConfig, Connection, Endpoint, ServerConfig};
@@ -113,8 +111,10 @@ impl TunnelListener for QUICTunnelListener {
 
         let info = TunnelInfo {
             tunnel_type: "quic".to_owned(),
-            local_addr: self.local_url().into(),
-            remote_addr: super::build_url_from_socket_addr(&remote_addr.to_string(), "quic").into(),
+            local_addr: Some(self.local_url().into()),
+            remote_addr: Some(
+                super::build_url_from_socket_addr(&remote_addr.to_string(), "quic").into(),
+            ),
         };
 
         Ok(Box::new(TunnelWrapper::new(
@@ -177,8 +177,10 @@ impl TunnelConnector for QUICTunnelConnector {
 
         let info = TunnelInfo {
             tunnel_type: "quic".to_owned(),
-            local_addr: super::build_url_from_socket_addr(&local_addr.to_string(), "quic").into(),
-            remote_addr: self.addr.to_string(),
+            local_addr: Some(
+                super::build_url_from_socket_addr(&local_addr.to_string(), "quic").into(),
+            ),
+            remote_addr: Some(self.addr.clone().into()),
         };
 
         let arc_conn = Arc::new(ConnWrapper { conn: connection });

easytier/src/tunnel/ring.rs

@@ -261,8 +261,8 @@ fn get_tunnel_for_client(conn: Arc<Connection>) -> impl Tunnel {
         RingSink::new(conn.server.clone()),
         Some(TunnelInfo {
             tunnel_type: "ring".to_owned(),
-            local_addr: build_url_from_socket_addr(&conn.client.id.into(), "ring").into(),
-            remote_addr: build_url_from_socket_addr(&conn.server.id.into(), "ring").into(),
+            local_addr: Some(build_url_from_socket_addr(&conn.client.id.into(), "ring").into()),
+            remote_addr: Some(build_url_from_socket_addr(&conn.server.id.into(), "ring").into()),
         }),
     )
 }
@@ -273,8 +273,8 @@ fn get_tunnel_for_server(conn: Arc<Connection>) -> impl Tunnel {
         RingSink::new(conn.client.clone()),
         Some(TunnelInfo {
             tunnel_type: "ring".to_owned(),
-            local_addr: build_url_from_socket_addr(&conn.server.id.into(), "ring").into(),
-            remote_addr: build_url_from_socket_addr(&conn.client.id.into(), "ring").into(),
+            local_addr: Some(build_url_from_socket_addr(&conn.server.id.into(), "ring").into()),
+            remote_addr: Some(build_url_from_socket_addr(&conn.client.id.into(), "ring").into()),
         }),
     )
 }

easytier/src/tunnel/tcp.rs

@@ -4,7 +4,8 @@ use async_trait::async_trait;
 use futures::stream::FuturesUnordered;
 use tokio::net::{TcpListener, TcpSocket, TcpStream};
 
-use crate::{rpc::TunnelInfo, tunnel::common::setup_sokcet2};
+use super::TunnelInfo;
+use crate::tunnel::common::setup_sokcet2;
 
 use super::{
     check_scheme_and_get_socket_addr, check_scheme_and_get_socket_addr_ext,
@@ -56,9 +57,10 @@ impl TunnelListener for TcpTunnelListener {
         stream.set_nodelay(true).unwrap();
         let info = TunnelInfo {
             tunnel_type: "tcp".to_owned(),
-            local_addr: self.local_url().into(),
-            remote_addr: super::build_url_from_socket_addr(&stream.peer_addr()?.to_string(), "tcp")
-                .into(),
+            local_addr: Some(self.local_url().into()),
+            remote_addr: Some(
+                super::build_url_from_socket_addr(&stream.peer_addr()?.to_string(), "tcp").into(),
+            ),
         };
 
         let (r, w) = stream.into_split();
@@ -82,9 +84,10 @@ fn get_tunnel_with_tcp_stream(
 
     let info = TunnelInfo {
         tunnel_type: "tcp".to_owned(),
-        local_addr: super::build_url_from_socket_addr(&stream.local_addr()?.to_string(), "tcp")
-            .into(),
-        remote_addr: remote_url.into(),
+        local_addr: Some(
+            super::build_url_from_socket_addr(&stream.local_addr()?.to_string(), "tcp").into(),
+        ),
+        remote_addr: Some(remote_url.into()),
     };
 
     let (r, w) = stream.into_split();

easytier/src/tunnel/udp.rs

@@ -15,9 +15,9 @@ use tokio::{
 
 use tracing::{instrument, Instrument};
 
+use super::TunnelInfo;
 use crate::{
     common::join_joinset_background,
-    rpc::TunnelInfo,
     tunnel::{
         build_url_from_socket_addr,
         common::{reserve_buf, TunnelWrapper},
@@ -317,8 +317,10 @@ impl UdpTunnelListenerData {
             Box::new(RingSink::new(ring_for_send_udp)),
             Some(TunnelInfo {
                 tunnel_type: "udp".to_owned(),
-                local_addr: self.local_url.clone().into(),
-                remote_addr: build_url_from_socket_addr(&remote_addr.to_string(), "udp").into(),
+                local_addr: Some(self.local_url.clone().into()),
+                remote_addr: Some(
+                    build_url_from_socket_addr(&remote_addr.to_string(), "udp").into(),
+                ),
             }),
         ));
 
@@ -607,9 +609,10 @@ impl UdpTunnelConnector {
             Box::new(RingSink::new(ring_for_send_udp)),
             Some(TunnelInfo {
                 tunnel_type: "udp".to_owned(),
-                local_addr: build_url_from_socket_addr(&socket.local_addr()?.to_string(), "udp")
-                    .into(),
-                remote_addr: self.addr.clone().into(),
+                local_addr: Some(
+                    build_url_from_socket_addr(&socket.local_addr()?.to_string(), "udp").into(),
+                ),
+                remote_addr: Some(self.addr.clone().into()),
             }),
         )))
     }
@@ -708,7 +711,7 @@ impl super::TunnelConnector for UdpTunnelConnector {
 
 #[cfg(test)]
 mod tests {
-    use std::time::Duration;
+    use std::{net::IpAddr, time::Duration};
 
     use futures::SinkExt;
     use tokio::time::timeout;
@@ -786,7 +789,11 @@ mod tests {
             loop {
                 let ret = listener.accept().await.unwrap();
                 assert_eq!(
-                    ret.info().unwrap().local_addr,
+                    ret.info()
+                        .unwrap()
+                        .local_addr
+                        .unwrap_or_default()
+                        .to_string(),
                     listener.local_url().to_string()
                 );
                 tokio::spawn(async move { _tunnel_echo_server(ret, false).await });
@@ -801,15 +808,15 @@ mod tests {
 
         tokio::spawn(timeout(
             Duration::from_secs(2),
-            send_random_data_to_socket(t1.info().unwrap().local_addr.parse().unwrap()),
+            send_random_data_to_socket(t1.info().unwrap().local_addr.unwrap().into()),
         ));
         tokio::spawn(timeout(
             Duration::from_secs(2),
-            send_random_data_to_socket(t1.info().unwrap().remote_addr.parse().unwrap()),
+            send_random_data_to_socket(t1.info().unwrap().remote_addr.unwrap().into()),
         ));
         tokio::spawn(timeout(
             Duration::from_secs(2),
-            send_random_data_to_socket(t2.info().unwrap().remote_addr.parse().unwrap()),
+            send_random_data_to_socket(t2.info().unwrap().remote_addr.unwrap().into()),
         ));
 
         let sender1 = tokio::spawn(async move {
@@ -854,12 +861,12 @@ mod tests {
         if ips.is_empty() {
             return;
         }
-        let bind_dev = get_interface_name_by_ip(&ips[0].parse().unwrap());
+        let bind_dev = get_interface_name_by_ip(&IpAddr::V4(ips[0].into()));
 
         for ip in ips {
             println!("bind to ip: {:?}, {:?}", ip, bind_dev);
             let addr = check_scheme_and_get_socket_addr::<SocketAddr>(
-                &format!("udp://{}:11111", ip).parse().unwrap(),
+                &format!("udp://{}:11111", ip.to_string()).parse().unwrap(),
                 "udp",
             )
             .unwrap();

easytier/src/tunnel/websocket.rs

@@ -8,7 +8,8 @@ use tokio_rustls::TlsAcceptor;
 use tokio_websockets::{ClientBuilder, Limits, MaybeTlsStream, Message};
 use zerocopy::AsBytes;
 
-use crate::{rpc::TunnelInfo, tunnel::insecure_tls::get_insecure_tls_client_config};
+use super::TunnelInfo;
+use crate::tunnel::insecure_tls::get_insecure_tls_client_config;
 
 use super::{
     common::{setup_sokcet2, wait_for_connect_futures, TunnelWrapper},
@@ -72,12 +73,14 @@ impl WSTunnelListener {
     async fn try_accept(&mut self, stream: TcpStream) -> Result<Box<dyn Tunnel>, TunnelError> {
         let info = TunnelInfo {
             tunnel_type: self.addr.scheme().to_owned(),
-            local_addr: self.local_url().into(),
-            remote_addr: super::build_url_from_socket_addr(
-                &stream.peer_addr()?.to_string(),
-                self.addr.scheme().to_string().as_str(),
-            )
-            .into(),
+            local_addr: Some(self.local_url().into()),
+            remote_addr: Some(
+                super::build_url_from_socket_addr(
+                    &stream.peer_addr()?.to_string(),
+                    self.addr.scheme().to_string().as_str(),
+                )
+                .into(),
+            ),
         };
 
         let server_bulder = tokio_websockets::ServerBuilder::new().limits(Limits::unlimited());
@@ -182,12 +185,14 @@ impl WSTunnelConnector {
 
         let info = TunnelInfo {
             tunnel_type: addr.scheme().to_owned(),
-            local_addr: super::build_url_from_socket_addr(
-                &stream.local_addr()?.to_string(),
-                addr.scheme().to_string().as_str(),
-            )
-            .into(),
-            remote_addr: addr.to_string(),
+            local_addr: Some(
+                super::build_url_from_socket_addr(
+                    &stream.local_addr()?.to_string(),
+                    addr.scheme().to_string().as_str(),
+                )
+                .into(),
+            ),
+            remote_addr: Some(addr.clone().into()),
         };
 
         let c = ClientBuilder::from_uri(http::Uri::try_from(addr.to_string()).unwrap());

easytier/src/tunnel/wireguard.rs

@@ -20,13 +20,11 @@ use futures::{stream::FuturesUnordered, SinkExt, StreamExt};
 use rand::RngCore;
 use tokio::{net::UdpSocket, sync::Mutex, task::JoinSet};
 
-use crate::{
-    rpc::TunnelInfo,
-    tunnel::{
-        build_url_from_socket_addr,
-        common::TunnelWrapper,
-        packet_def::{ZCPacket, WG_TUNNEL_HEADER_SIZE},
-    },
+use super::TunnelInfo;
+use crate::tunnel::{
+    build_url_from_socket_addr,
+    common::TunnelWrapper,
+    packet_def::{ZCPacket, WG_TUNNEL_HEADER_SIZE},
 };
 
 use super::{
@@ -522,12 +520,16 @@ impl WgTunnelListener {
                     sink,
                     Some(TunnelInfo {
                         tunnel_type: "wg".to_owned(),
-                        local_addr: build_url_from_socket_addr(
-                            &socket.local_addr().unwrap().to_string(),
-                            "wg",
-                        )
-                        .into(),
-                        remote_addr: build_url_from_socket_addr(&addr.to_string(), "wg").into(),
+                        local_addr: Some(
+                            build_url_from_socket_addr(
+                                &socket.local_addr().unwrap().to_string(),
+                                "wg",
+                            )
+                            .into(),
+                        ),
+                        remote_addr: Some(
+                            build_url_from_socket_addr(&addr.to_string(), "wg").into(),
+                        ),
                     }),
                 ));
                 if let Err(e) = conn_sender.send(tunnel) {
@@ -670,8 +672,8 @@ impl WgTunnelConnector {
             sink,
             Some(TunnelInfo {
                 tunnel_type: "wg".to_owned(),
-                local_addr: super::build_url_from_socket_addr(&local_addr, "wg").into(),
-                remote_addr: addr_url.to_string(),
+                local_addr: Some(super::build_url_from_socket_addr(&local_addr, "wg").into()),
+                remote_addr: Some(addr_url.into()),
             }),
             Some(Box::new(wg_peer)),
         ));