network refactor for connection manager

veilid-core/src/intf/wasm/network/protocol/mod.rs

@@ -8,14 +8,17 @@ use crate::xx::*;
 pub struct DummyNetworkConnection {}
 
 impl DummyNetworkConnection {
-    pub fn protocol_type(&self) -> ProtocolType {
-        ProtocolType::UDP
+    pub fn connection_descriptor(&self) -> ConnectionDescriptor {
+        ConnectionDescriptor::new_no_local(PeerAddress::new(
+            SocketAddress::default(),
+            ProtocolType::UDP,
+        ))
     }
-    pub fn send(&self, _message: Vec<u8>) -> SystemPinBoxFuture<Result<(), String>> {
-        Box::pin(async { Ok(()) })
+    pub async fn send(&self, _message: Vec<u8>) -> Result<(), String> {
+        Ok(())
     }
-    pub fn recv(&self) -> SystemPinBoxFuture<Result<Vec<u8>, String>> {
-        Box::pin(async { Ok(Vec::new()) })
+    pub async fn recv(&self) -> Result<Vec<u8>, String> {
+        Ok(Vec::new())
     }
 }
 
@@ -27,16 +30,33 @@ pub enum NetworkConnection {
 }
 
 impl NetworkConnection {
-    pub fn send(&self, message: Vec<u8>) -> SystemPinBoxFuture<Result<(), String>> {
-        match self {
-            Self::Dummy(d) => d.send(message),
-            Self::WS(w) => w.send(message),
+    pub async fn connect(
+        local_address: Option<SocketAddr>,
+        dial_info: DialInfo,
+    ) -> Result<NetworkConnection, String> {
+        match dial_info.protocol_type() {
+            ProtocolType::UDP => {
+                panic!("Should not connect to UDP dialinfo");
+            }
+            ProtocolType::TCP => {
+                panic!("TCP dial info is not support on WASM targets");
+            }
+            ProtocolType::WS | ProtocolType::WSS => {
+                ws::WebsocketProtocolHandler::connect(local_address, dial_info).await
+            }
         }
     }
-    pub fn recv(&self) -> SystemPinBoxFuture<Result<Vec<u8>, String>> {
+        
+    pub async fn send(&self, message: Vec<u8>) -> Result<(), String> {
         match self {
-            Self::Dummy(d) => d.recv(),
-            Self::WS(w) => w.recv(),
+            Self::Dummy(d) => d.send(message).await,
+            Self::WS(w) => w.send(message).await,
+        }
+    }
+    pub async fn recv(&self) -> Result<Vec<u8>, String> {
+        match self {
+            Self::Dummy(d) => d.recv().await,
+            Self::WS(w) => w.recv().await,
         }
     }
 }

veilid-core/src/intf/wasm/network/protocol/ws.rs

@@ -14,6 +14,7 @@ struct WebsocketNetworkConnectionInner {
 #[derive(Clone)]
 pub struct WebsocketNetworkConnection {
     tls: bool,
+    connection_descriptor: ConnectionDescriptor,
     inner: Arc<Mutex<WebsocketNetworkConnectionInner>>,
 }
 
@@ -32,52 +33,49 @@ impl PartialEq for WebsocketNetworkConnection {
 impl Eq for WebsocketNetworkConnection {}
 
 impl WebsocketNetworkConnection {
-    pub fn new(tls: bool, ws_meta: WsMeta, ws_stream: WsStream) -> Self {
+    pub fn new(tls: bool, connection_descriptor: ConnectionDescriptor, ws_stream: WsStream) -> Self {
         let ws = ws_stream.wrapped().clone();
         Self {
             tls,
+            connection_descriptor,
             inner: Arc::new(Mutex::new(WebsocketNetworkConnectionInner {
                 ws_stream,
                 ws,
             })),
         }
     }
-}
 
-impl WebsocketNetworkConnection {
-    pub fn send(&self, message: Vec<u8>) -> SystemPinBoxFuture<Result<(), String>> {
-        let inner = self.inner.clone();
-        Box::pin(async move {
-            if message.len() > MAX_MESSAGE_SIZE {
-                return Err("sending too large WS message".to_owned()).map_err(logthru_net!(error));
-            }
-            inner
-                .lock()
-                .ws
-                .send_with_u8_array(&message)
-                .map_err(|_| "failed to send to websocket".to_owned())
-                .map_err(logthru_net!(error))
-        })
+    pub fn connection_descriptor(&self) -> ConnectionDescriptor {
+        self.connection_descriptor.clone()
     }
-    pub fn recv(&self) -> SystemPinBoxFuture<Result<Vec<u8>, String>> {
-        let inner = self.inner.clone();
-        Box::pin(async move {
-            let out = match inner.lock().ws_stream.next().await {
-                Some(WsMessage::Binary(v)) => v,
-                Some(_) => {
-                    return Err("Unexpected WS message type".to_owned())
-                        .map_err(logthru_net!(error));
-                }
-                None => {
-                    return Err("WS stream closed".to_owned()).map_err(logthru_net!(error));
-                }
-            };
-            if out.len() > MAX_MESSAGE_SIZE {
-                Err("sending too large WS message".to_owned()).map_err(logthru_net!(error))
-            } else {
-                Ok(out)
+
+    pub async fn send(&self, message: Vec<u8>) -> Result<(), String> {
+        if message.len() > MAX_MESSAGE_SIZE {
+            return Err("sending too large WS message".to_owned()).map_err(logthru_net!(error));
+        }
+        self.inner
+            .lock()
+            .ws
+            .send_with_u8_array(&message)
+            .map_err(|_| "failed to send to websocket".to_owned())
+            .map_err(logthru_net!(error))
+    }
+    pub async fn recv(&self) -> Result<Vec<u8>, String> {
+        let out = match self.inner.lock().ws_stream.next().await {
+            Some(WsMessage::Binary(v)) => v,
+            Some(_) => {
+                return Err("Unexpected WS message type".to_owned())
+                    .map_err(logthru_net!(error));
             }
-        })
+            None => {
+                return Err("WS stream closed".to_owned()).map_err(logthru_net!(error));
+            }
+        };
+        if out.len() > MAX_MESSAGE_SIZE {
+            Err("sending too large WS message".to_owned()).map_err(logthru_net!(error))
+        } else {
+            Ok(out)
+        }
     }
 }
 
@@ -88,7 +86,7 @@ pub struct WebsocketProtocolHandler {}
 
 impl WebsocketProtocolHandler {
     pub async fn connect(
-        network_manager: NetworkManager,
+        local_address: Option<SocketAddr>,
         dial_info: &DialInfo,
     ) -> Result<NetworkConnection, String> {
         let url = dial_info
@@ -113,18 +111,18 @@ impl WebsocketProtocolHandler {
                     .map_err(logthru_net!(error))
             }
         };
-        let peer_addr = dial_info.to_peer_address();
 
-        let (ws, wsio) = WsMeta::connect(url, None)
+        let (_, wsio) = WsMeta::connect(url, None)
             .await
             .map_err(map_to_string)
             .map_err(logthru_net!(error))?;
 
-        let conn = NetworkConnection::WS(WebsocketNetworkConnection::new(tls, ws, wsio));
-        network_manager
-            .on_new_connection(ConnectionDescriptor::new_no_local(peer_addr), conn.clone())
-            .await?;
+        // Make our connection descriptor
+        let connection_descriptor = ConnectionDescriptor {
+            local: None,
+            remote: dial_info.to_peer_address(),
+        };
 
-        Ok(conn)
+        Ok(NetworkConnection::WS(WebsocketNetworkConnection::new(tls, connection_descriptor, wsio)))
     }
 }