use hyper client

wisp/src/lib.rs

@@ -35,6 +35,9 @@ pub enum WispError {
     InvalidPacketType,
     InvalidStreamType,
     InvalidStreamId,
+    InvalidUri,
+    UriHasNoHost,
+    UriHasNoPort,
     MaxStreamCountReached,
     StreamAlreadyClosed,
     WsFrameInvalidType,
@@ -60,6 +63,9 @@ impl std::fmt::Display for WispError {
             InvalidPacketType => write!(f, "Invalid packet type"),
             InvalidStreamType => write!(f, "Invalid stream type"),
             InvalidStreamId => write!(f, "Invalid stream id"),
+            InvalidUri => write!(f, "Invalid URI"),
+            UriHasNoHost => write!(f, "URI has no host"),
+            UriHasNoPort => write!(f, "URI has no port"),
             MaxStreamCountReached => write!(f, "Maximum stream count reached"),
             StreamAlreadyClosed => write!(f, "Stream already closed"),
             WsFrameInvalidType => write!(f, "Invalid websocket frame type"),
@@ -329,7 +335,7 @@ impl<W: ws::WebSocketWrite + Send + 'static> ClientMux<W> {
         stream_type: StreamType,
         host: String,
         port: u16,
-    ) -> Result<MuxStream<impl ws::WebSocketWrite>, WispError> {
+    ) -> Result<MuxStream<W>, WispError> {
         let (ch_tx, ch_rx) = mpsc::unbounded();
         let stream_id = self.next_free_stream_id.load(Ordering::Acquire);
         self.tx

wisp/src/tokioio.rs

@@ -1,7 +1,6 @@
 #![allow(dead_code)]
 // Taken from https://github.com/hyperium/hyper-util/blob/master/src/rt/tokio.rs
-// hyper-util fails to compile on WASM as it has a dependency on socket2, but I only need
-// hyper-util for TokioIo.
+// hyper-util fails to compile on WASM as it has a dependency on socket2
 
 use std::{
     pin::Pin,
@@ -169,3 +168,9 @@ where
         hyper::rt::Write::poll_write_vectored(self.project().inner, cx, bufs)
     }
 }
+
+impl<T> hyper_util::client::legacy::connect::Connection for TokioIo<T> {
+    fn connected(&self) -> hyper_util::client::legacy::connect::Connected {
+        hyper_util::client::legacy::connect::Connected::new()
+    }
+}

wisp/src/tower.rs

@@ -1,13 +1,41 @@
-use futures::{Future, task::{Poll, Context}};
+use crate::{tokioio::TokioIo, ws::WebSocketWrite, ClientMux, MuxStreamIo, StreamType, WispError};
+use async_io_stream::IoStream;
+use futures::{
+    task::{Context, Poll},
+    Future,
+};
+use std::sync::Arc;
 
-impl<W: crate::ws::WebSocketWrite> tower::Service<hyper::Uri> for crate::ClientMux<W> {
-    type Response = crate::tokioio::TokioIo<crate::MuxStream<W>>;
-    type Error = crate::WispError;
+pub struct ServiceWrapper<W: WebSocketWrite + Send + 'static>(pub Arc<ClientMux<W>>);
+
+impl<W: WebSocketWrite + Send + 'static> tower_service::Service<hyper::Uri> for ServiceWrapper<W> {
+    type Response = TokioIo<IoStream<MuxStreamIo, Vec<u8>>>;
+    type Error = WispError;
     type Future = impl Future<Output = Result<Self::Response, Self::Error>>;
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
-    fn call(&mut self, req: hyper::Uri) -> Self::Future {
 
+    fn call(&mut self, req: hyper::Uri) -> Self::Future {
+        let mux = self.0.clone();
+        async move {
+            Ok(TokioIo::new(
+                mux.client_new_stream(
+                    StreamType::Tcp,
+                    req.host().ok_or(WispError::UriHasNoHost)?.to_string(),
+                    req.port().ok_or(WispError::UriHasNoPort)?.into(),
+                )
+                .await?
+                .into_io()
+                .into_asyncrw(),
+            ))
+        }
+    }
+}
+
+impl<W: WebSocketWrite + Send + 'static> Clone for ServiceWrapper<W> { 
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
     }
 }