refactor and make tcp work

veilid-core/src/xx/async_peek_stream.rs

@@ -0,0 +1,174 @@
+use crate::xx::*;
+use core::pin::Pin;
+use core::task::{Context, Poll};
+use futures_util::AsyncRead as Read;
+use futures_util::AsyncReadExt;
+use futures_util::AsyncWrite as Write;
+use std::io::Result;
+
+////////
+///
+trait SendStream: Read + Write + Send + Unpin {
+    fn clone_stream(&self) -> Box<dyn SendStream>;
+}
+impl<S> SendStream for S
+where
+    S: Read + Write + Send + Clone + Unpin + 'static,
+{
+    fn clone_stream(&self) -> Box<dyn SendStream> {
+        Box::new(self.clone())
+    }
+}
+
+/////////
+///
+struct AsyncPeekStreamInner {
+    stream: Box<dyn SendStream>,
+    peekbuf: Vec<u8>,
+    peekbuf_len: usize,
+}
+
+#[derive(Clone)]
+pub struct AsyncPeekStream
+where
+    Self: Read + Write + Send + Unpin,
+{
+    inner: Arc<Mutex<AsyncPeekStreamInner>>,
+}
+
+impl AsyncPeekStream {
+    pub fn new<S>(stream: S) -> Self
+    where
+        S: Read + Write + Send + Clone + Unpin + 'static,
+    {
+        Self {
+            inner: Arc::new(Mutex::new(AsyncPeekStreamInner {
+                stream: Box::new(stream),
+                peekbuf: Vec::new(),
+                peekbuf_len: 0,
+            })),
+        }
+    }
+
+    pub async fn peek(&'_ self, buf: &'_ mut [u8]) -> Result<usize> {
+        let (mut stream, mut peekbuf, mut peekbuf_len) = {
+            let inner = self.inner.lock();
+            (
+                inner.stream.clone_stream(),
+                inner.peekbuf.clone(),
+                inner.peekbuf_len,
+            )
+        };
+        //
+        let buf_len = buf.len();
+        let mut copy_len = buf_len;
+        if buf_len > peekbuf_len {
+            //
+            peekbuf.resize(buf_len, 0u8);
+            let read_len = stream
+                .read(&mut peekbuf.as_mut_slice()[peekbuf_len..buf_len])
+                .await?;
+            peekbuf_len += read_len;
+            copy_len = peekbuf_len;
+        }
+        buf[..copy_len].copy_from_slice(&peekbuf[..copy_len]);
+
+        let mut inner = self.inner.lock();
+        inner.peekbuf = peekbuf;
+        inner.peekbuf_len = peekbuf_len;
+        Ok(copy_len)
+    }
+
+    pub async fn peek_exact(&'_ self, buf: &'_ mut [u8]) -> Result<()> {
+        let (mut stream, mut peekbuf, mut peekbuf_len) = {
+            let inner = self.inner.lock();
+            (
+                inner.stream.clone_stream(),
+                inner.peekbuf.clone(),
+                inner.peekbuf_len,
+            )
+        };
+        //
+        let buf_len = buf.len();
+        if buf_len > peekbuf_len {
+            //
+            peekbuf.resize(buf_len, 0u8);
+            stream
+                .read_exact(&mut peekbuf.as_mut_slice()[peekbuf_len..buf_len])
+                .await?;
+            peekbuf_len = buf_len;
+        }
+        buf.copy_from_slice(&peekbuf[..buf_len]);
+
+        let mut inner = self.inner.lock();
+        inner.peekbuf = peekbuf;
+        inner.peekbuf_len = peekbuf_len;
+        Ok(())
+    }
+}
+
+impl Read for AsyncPeekStream {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut [u8],
+    ) -> Poll<Result<usize>> {
+        let mut inner = self.inner.lock();
+        //
+        let buflen = buf.len();
+        let bufcopylen = cmp::min(buflen, inner.peekbuf_len);
+        let bufreadlen = if buflen > inner.peekbuf_len {
+            buflen - inner.peekbuf_len
+        } else {
+            0
+        };
+
+        if bufreadlen > 0 {
+            match Pin::new(&mut inner.stream).poll_read(cx, &mut buf[bufcopylen..buflen]) {
+                Poll::Ready(res) => {
+                    let readlen = res?;
+                    buf[0..bufcopylen].copy_from_slice(&inner.peekbuf[0..bufcopylen]);
+                    inner.peekbuf_len = 0;
+                    Poll::Ready(Ok(bufcopylen + readlen))
+                }
+                Poll::Pending => {
+                    if bufcopylen > 0 {
+                        buf[0..bufcopylen].copy_from_slice(&inner.peekbuf[0..bufcopylen]);
+                        inner.peekbuf_len = 0;
+                        Poll::Ready(Ok(bufcopylen))
+                    } else {
+                        Poll::Pending
+                    }
+                }
+            }
+        } else {
+            buf[0..bufcopylen].copy_from_slice(&inner.peekbuf[0..bufcopylen]);
+            if bufcopylen == inner.peekbuf_len {
+                inner.peekbuf_len = 0;
+            } else if bufcopylen != 0 {
+                // slide buffer over by bufcopylen
+                let tail = inner.peekbuf.split_off(bufcopylen);
+                inner.peekbuf = tail;
+                inner.peekbuf_len -= bufcopylen;
+            }
+            Poll::Ready(Ok(bufcopylen))
+        }
+    }
+}
+
+impl Write for AsyncPeekStream {
+    fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<Result<usize>> {
+        let mut inner = self.inner.lock();
+        Pin::new(&mut inner.stream).poll_write(cx, buf)
+    }
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
+        let mut inner = self.inner.lock();
+        Pin::new(&mut inner.stream).poll_flush(cx)
+    }
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
+        let mut inner = self.inner.lock();
+        Pin::new(&mut inner.stream).poll_close(cx)
+    }
+}
+
+impl core::marker::Unpin for AsyncPeekStream {}

veilid-core/src/xx/clone_stream.rs

@@ -0,0 +1,111 @@
+use crate::xx::*;
+use core::pin::Pin;
+use core::task::{Context, Poll};
+use futures_util::AsyncRead as Read;
+use futures_util::AsyncWrite as Write;
+use futures_util::Sink;
+use futures_util::Stream;
+use std::io;
+
+pub struct CloneStream<T>
+where
+    T: Unpin,
+{
+    inner: Arc<Mutex<T>>,
+}
+
+impl<T> Clone for CloneStream<T>
+where
+    T: Unpin,
+{
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl<T> CloneStream<T>
+where
+    T: Unpin,
+{
+    pub fn new(t: T) -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(t)),
+        }
+    }
+}
+
+impl<T> Read for CloneStream<T>
+where
+    T: Read + Unpin,
+{
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut [u8],
+    ) -> Poll<io::Result<usize>> {
+        let mut inner = self.inner.lock();
+        Pin::new(&mut *inner).poll_read(cx, buf)
+    }
+}
+
+impl<T> Write for CloneStream<T>
+where
+    T: Write + Unpin,
+{
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let mut inner = self.inner.lock();
+        Pin::new(&mut *inner).poll_write(cx, buf)
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut inner = self.inner.lock();
+        Pin::new(&mut *inner).poll_flush(cx)
+    }
+
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut inner = self.inner.lock();
+        Pin::new(&mut *inner).poll_close(cx)
+    }
+}
+
+impl<T> Stream for CloneStream<T>
+where
+    T: Stream + Unpin,
+{
+    type Item = T::Item;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let mut inner = self.inner.lock();
+        Pin::new(&mut *inner).poll_next(cx)
+    }
+}
+
+impl<T, Item> Sink<Item> for CloneStream<T>
+where
+    T: Sink<Item> + Unpin,
+{
+    type Error = T::Error;
+
+    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        let mut inner = self.inner.lock();
+        Pin::new(&mut *inner).poll_ready(cx)
+    }
+    fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::Error> {
+        let mut inner = self.inner.lock();
+        Pin::new(&mut *inner).start_send(item)
+    }
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        let mut inner = self.inner.lock();
+        Pin::new(&mut *inner).poll_flush(cx)
+    }
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        let mut inner = self.inner.lock();
+        Pin::new(&mut *inner).poll_close(cx)
+    }
+}

veilid-core/src/xx/log_thru.rs

@@ -36,6 +36,14 @@ macro_rules! log_net {
     (error $fmt:literal, $($arg:expr),+) => {
         error!(target:"net", $fmt, $($arg),+);
     };
+    (warn $text:expr) => {warn!(
+        target: "net",
+        "{}",
+        $text,
+    )};
+    (warn $fmt:literal, $($arg:expr),+) => {
+        warn!(target:"net", $fmt, $($arg),+);
+    };
     ($text:expr) => {trace!(
         target: "net",
         "{}",
@@ -56,6 +64,14 @@ macro_rules! log_rpc {
     (error $fmt:literal, $($arg:expr),+) => {
         error!(target:"rpc", $fmt, $($arg),+);
     };
+    (warn $text:expr) => { warn!(
+        target: "rpc",
+        "{}",
+        $text,
+    )};
+    (warn $fmt:literal, $($arg:expr),+) => {
+        warn!(target:"rpc", $fmt, $($arg),+);
+    };
     ($text:expr) => {trace!(
         target: "rpc",
         "{}",
@@ -76,6 +92,14 @@ macro_rules! log_rtab {
     (error $fmt:literal, $($arg:expr),+) => {
         error!(target:"rtab", $fmt, $($arg),+);
     };
+    (warn $text:expr) => { warn!(
+        target: "rtab",
+        "{}",
+        $text,
+    )};
+    (warn $fmt:literal, $($arg:expr),+) => {
+        warn!(target:"rtab", $fmt, $($arg),+);
+    };
     ($text:expr) => {trace!(
         target: "rtab",
         "{}",
@@ -153,6 +177,33 @@ macro_rules! logthru {
         );
         e__
     });
+    // warn
+    (warn $target:literal) => (|e__| {
+        warn!(
+            target: $target,
+            "[{}]",
+            e__,
+        );
+        e__
+    });
+    (warn $target:literal, $text:literal) => (|e__| {
+        warn!(
+            target: $target,
+            "[{}] {}",
+            e__,
+            $text
+        );
+        e__
+    });
+    (warn $target:literal, $fmt:literal, $($arg:expr),+) => (|e__| {
+        warn!(
+            target: $target,
+            concat!("[{}] ", $fmt),
+            e__,
+            $($arg),+
+        );
+        e__
+    });
     // debug
     (debug $target:literal) => (|e__| {
         debug!(

veilid-core/src/xx/mod.rs

@@ -1,4 +1,6 @@
 // mod bump_port;
+mod async_peek_stream;
+mod clone_stream;
 mod eventual;
 mod eventual_base;
 mod eventual_value;
@@ -68,6 +70,7 @@ cfg_if! {
         pub use async_std::pin::Pin;
         pub use async_std::sync::Mutex as AsyncMutex;
         pub use async_std::sync::MutexGuard as AsyncMutexGuard;
+        pub use async_std::channel as async_channel;
         pub use std::net::{ SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs, IpAddr, Ipv4Addr, Ipv6Addr };
         pub type SystemPinBoxFuture<T> = PinBox<dyn Future<Output = T> + Send + 'static>;
         pub type SystemPinBoxFutureLifetime<'a, T> = PinBox<dyn Future<Output = T> + Send + 'a>;
@@ -75,6 +78,8 @@ cfg_if! {
 }
 
 // pub use bump_port::*;
+pub use async_peek_stream::*;
+pub use clone_stream::*;
 pub use eventual::*;
 pub use eventual_base::{EventualCommon, EventualResolvedFuture};
 pub use eventual_value::*;