refactor and make tcp work

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

@@ -65,6 +65,8 @@ impl Network {
         }
         
         // Handle connection-oriented protocols
+
+        // Try to send to the exact existing connection if one exists
         if let Some(conn) = self.connection_manager().get_connection(descriptor).await {
             // connection exists, send over it
             conn.send(data).await.map_err(logthru_net!())?;

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

@@ -46,20 +46,20 @@ impl ProtocolNetworkConnection {
             }
         }
     }
-    pub async fn close(&mut self) -> Result<(), String> {
+    pub async fn close(&self) -> Result<(), String> {
         match self {
             Self::Dummy(d) => d.close(),
             Self::Ws(w) => w.close().await,
         }
     }
-    pub async fn send(&mut self, message: Vec<u8>) -> Result<(), String> {
+    pub async fn send(&self, message: Vec<u8>) -> Result<(), String> {
         match self {
             Self::Dummy(d) => d.send(message),
             Self::Ws(w) => w.send(message).await,
         }
     }
 
-    pub async fn recv(&mut self) -> Result<Vec<u8>, String> {
+    pub async fn recv(&self) -> Result<Vec<u8>, String> {
         match self {
             Self::Dummy(d) => d.recv(),
             Self::Ws(w) => w.recv().await,

veilid-core/src/intf/wasm/utils/channel.rs

@@ -1,154 +0,0 @@
-use crate::xx::*;
-use alloc::collections::VecDeque;
-use core::fmt;
-
-#[derive(Debug)]
-pub struct Channel<T> {
-    items: VecDeque<T>,
-    cap: usize,
-    eventual: Eventual,
-}
-
-#[derive(Debug)]
-pub struct Sender<T> {
-    imp: Arc<Mutex<Channel<T>>>,
-}
-
-impl<T> Clone for Sender<T> {
-    fn clone(&self) -> Self {
-        Self {
-            imp: self.imp.clone(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Receiver<T> {
-    imp: Arc<Mutex<Channel<T>>>,
-}
-
-impl<T> Clone for Receiver<T> {
-    fn clone(&self) -> Self {
-        Self {
-            imp: self.imp.clone(),
-        }
-    }
-}
-
-pub fn channel<T>(cap: usize) -> (Sender<T>, Receiver<T>) {
-    let imp = Channel {
-        items: VecDeque::with_capacity(cap),
-        cap,
-        eventual: Eventual::new(),
-    };
-
-    let imparc = Arc::new(Mutex::new(imp));
-    (
-        Sender {
-            imp: imparc.clone(),
-        },
-        Receiver {
-            imp: imparc.clone(),
-        },
-    )
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum TrySendError<T> {
-    Full(T),
-    Disconnected(T),
-}
-
-impl<T> fmt::Display for TrySendError<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            TrySendError::Full(_) => {
-                write!(f, "Full")
-            }
-            TrySendError::Disconnected(_) => {
-                write!(f, "Disconnected")
-            }
-        }
-    }
-}
-
-impl<T> Sender<T> {
-    // NOTE: This needs a timeout or you could block a very long time
-    // pub async fn send(&self, msg: T) -> Result<(), SendError<T>> {
-    //     xxx
-    // }
-
-    pub async fn try_send(&self, msg: T) -> Result<(), TrySendError<T>> {
-        let eventual = {
-            let mut inner = self.imp.lock();
-            if inner.items.len() == inner.cap {
-                return Err(TrySendError::Full(msg));
-            }
-            let empty = inner.items.is_empty();
-            inner.items.push_back(msg);
-            if empty {
-                Some(inner.eventual.clone())
-            } else {
-                None
-            }
-        };
-        if let Some(e) = eventual {
-            e.resolve().await;
-        }
-        Ok(())
-    }
-    pub fn capacity(&self) -> usize {
-        self.imp.lock().cap
-    }
-    pub fn is_empty(&self) -> bool {
-        self.imp.lock().items.is_empty()
-    }
-    pub fn is_full(&self) -> bool {
-        let inner = self.imp.lock();
-        inner.items.len() == inner.cap
-    }
-    pub fn len(&self) -> usize {
-        self.imp.lock().items.len()
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct RecvError;
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum TryRecvError {
-    Empty,
-    Disconnected,
-}
-
-impl<T> Receiver<T> {
-    pub async fn recv(&self) -> Result<T, RecvError> {
-        let eventual = {
-            let inner = self.imp.lock();
-            inner.eventual.clone()
-        };
-        while self.is_empty() {
-            eventual.instance_clone(true).await;
-        }
-        Ok(self.imp.lock().items.pop_front().unwrap())
-    }
-    pub async fn try_recv(&self) -> Result<T, TryRecvError> {
-        if self.is_empty() {
-            return Err(TryRecvError::Empty);
-        }
-        Ok(self.imp.lock().items.pop_front().unwrap())
-    }
-    pub fn capacity(&self) -> usize {
-        self.imp.lock().cap
-    }
-    pub fn is_empty(&self) -> bool {
-        self.imp.lock().items.is_empty()
-    }
-    pub fn is_full(&self) -> bool {
-        let inner = self.imp.lock();
-        inner.items.len() == inner.cap
-    }
-    pub fn len(&self) -> usize {
-        self.imp.lock().items.len()
-    }
-}

veilid-core/src/intf/wasm/utils/mod.rs

@@ -1,7 +1,5 @@
 #![cfg(target_arch = "wasm32")]
 
-pub mod channel;
-
 use crate::xx::*;
 use core::sync::atomic::{AtomicI8, Ordering};
 use js_sys::{global, Reflect};