Some more RPC client code.

src/network/client.rs

-use futures::Future;
-//use futures::task::{Context, Poll};
-//use core::pin::Pin;
+use std::time::Duration;
+
+use async_tungstenite::{tokio::connect_async, tungstenite::Message, WebSocketStream};
+use core::pin::Pin;
+use futures::future::{self, Either, Future};
+use futures::task::{Context, Poll};
 use tokio::stream::Stream;
-//use async_tungstenite::{tokio::connect_async, tungstenite::Message, WebSocketStream};
-//use url::Url;
+use tokio::stream::StreamExt;
+use tokio::sync::{mpsc, oneshot};
+use tokio::time::{delay_for, Delay};
+use url::Url;
 
 use super::packet::IncomingPacket;
 
-use std::time::Duration;
-
-pub trait RPCInterface {
-    type PacketType;
-    type NetworkError;
-    type Call: RPC<Output = Result<IncomingPacket<Self::PacketType>, Self::NetworkError>>;
-
-    fn call(call: &Self::PacketType) -> Self::Call;
+pub fn create<StreamType, ErrorType, PacketType>(
+    stream: StreamType,
+) -> (
+    RPCInterface<StreamType, PacketType>,
+    ServerEventStream<PacketType>,
+)
+where
+    StreamType: Stream<Item = Result<Vec<u8>, ErrorType>> + Unpin + Send + 'static,
+{
+    let (cmd_send, cmd_receive) = mpsc::channel(1);
+    tokio::spawn(async move {
+        // TODO: Remove type annotations.
+        client_connection_task::<StreamType, ErrorType, PacketType>(stream, cmd_receive).await;
+    });
+    // TODO
+    panic!("Not yet implemented.");
 }
 
-pub trait RPC: Future {
-    fn with_timeout(self, timeout: Duration) -> Self;
+enum ClientTaskCommand {
+    Close,
+    SendPackets,
 }
 
-pub trait ServerEventStream<PacketType>: Stream<Item = PacketType> {}
-
-/*pub struct WSRPCInterface<PacketType, Stream> {
+struct OutgoingCallMap {
     // TODO
-    _unused: PacketType,
-    stream: WebSocketStream<Stream>,
 }
 
-impl<P, S> WSRPCInterface<P, S> {
-    fn create<P2, S2>(_ws_stream: WebSocketStream<S2>) -> (Self, WSServerEventStream<P2>) {
+async fn client_connection_task<StreamType, ErrorType, PacketType>(
+    mut stream: StreamType,
+    mut cmd_receive: mpsc::Receiver<ClientTaskCommand>,
+) where
+    StreamType: Stream<Item = Result<Vec<u8>, ErrorType>> + Unpin,
+{
+    let mut connection_closed = false;
+    loop {
+        match future::select(Box::pin(stream.next()), Box::pin(cmd_receive.recv())).await {
+            Either::Left((packet, _cmd_future)) => {
+                match packet {
+                    Some(data) => {
+                        // TODO
+                    }
+                    None => {
+                        // Stream closed. We still need to return errors for any
+                        // packet sent by the client, so do not exit the loop
+                        // immediately but rather return an error for any
+                        // incoming packet.
+                        connection_closed = true;
+                        break;
+                    }
+                }
+            }
+            Either::Right((cmd, _stream_future)) => {
+                match cmd {
+                    Some(ClientTaskCommand::Close) => {
+                        // The RPC interface for this connection was dropped, so
+                        // we just exit the loop and close the connection.
+
+                        // We need to return errors for all pending packets
+                        // first, though.
+                        // TODO
+                        break;
+                    }
+                    Some(ClientTaskCommand::SendPackets) => {
+                        // TODO
+                    }
+                    None => {
+                        // This should never happen.
+                        break;
+                    }
+                }
+            }
+        };
+    }
+
+    if connection_closed {
+        // The stream was closed, but the command channel was not. We still need
+        // to return errors for any packet sent by the client, so do not exit
+        // the loop immediately but rather return an error for any incoming
+        // packet.
+        client_connection_closed(cmd_receive).await;
+    } else {
+        // The command channel was closed, but the stream was not. Gracefully
+        // close the stream.
         // TODO
-        panic!("Not yet implemented.");
     }
 }
 
-impl<P, S> RPCInterface for WSRPCInterface<P, S> {
-    type PacketType = P;
-    type NetworkError = String; // TODO
+async fn client_connection_closed(mut cmd_receive: mpsc::Receiver<ClientTaskCommand>) {
+    loop {
+        match cmd_receive.recv().await {
+            Some(ClientTaskCommand::Close) => {
+                // The connection was already closed.
+                break;
+            }
+            Some(ClientTaskCommand::SendPackets) => {
+                // The connection was closed, so return an error for any
+                // packet sent.
+                // TODO
+            }
+            None => {
+                // This should never happen.
+                break;
+            }
+        }
+    }
+}
 
-    type Call = WSRPC<Self::PacketType>;
+pub struct RPCInterface<StreamType, PacketType> {
+    stream: StreamType,
+    _packet: Option<PacketType>, // TODO: Remove.
+}
 
-    fn call(call: &Self::PacketType) -> Self::Call {
+impl<StreamType, PacketType> RPCInterface<StreamType, PacketType> {
+    fn call(_call: &PacketType) -> RPC<StreamType, PacketType> {
         // TODO
         panic!("Not yet implemented.");
     }
 }
 
-pub struct WSRPC<PacketType> {
-    // TODO
-    _unused: PacketType,
+pub struct RPC<PacketType, ErrorType> {
+    result: Pin<Box<oneshot::Receiver<Result<IncomingPacket<PacketType>, ErrorType>>>>,
+    timeout: Option<Pin<Box<Delay>>>,
 }
-
-impl<P> Future for WSRPC<P> {
-    type Output = Result<IncomingPacket<P>, String>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-        // TODO
-        panic!("Not yet implemented.");
+impl<PacketType, ErrorType> RPC<PacketType, ErrorType> {
+    pub fn with_timeout(mut self, timeout: Duration) -> Self {
+        self.timeout = Some(Box::pin(delay_for(timeout)));
+        self
     }
 }
 
-impl<P> RPC for WSRPC<P> {
-    fn with_timeout(self, timeout: Duration) -> Self {
-        // TODO
-        panic!("Not yet implemented.");
+impl<PacketType, ErrorType> Future for RPC<PacketType, ErrorType> {
+    type Output = Result<IncomingPacket<PacketType>, RPCError<ErrorType>>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+        // Safe, as we will not move self_.
+        let self_ = unsafe { self.get_unchecked_mut() };
+
+        // Try receiving from the receiver.
+        match Pin::as_mut(&mut self_.result).poll(cx) {
+            Poll::Ready(Ok(result)) => return Poll::Ready(result.map_err(|x| RPCError::Stream(x))),
+            Poll::Ready(Err(_)) => {
+                // The channel was closed.
+                return Poll::Ready(Err(RPCError::Closed));
+            }
+            Poll::Pending => (),
+        }
+
+        // Nothing received, check the timeout instead.
+        if self_.timeout.is_some() {
+            match Pin::as_mut(&mut self_.timeout.as_mut().unwrap()).poll(cx) {
+                Poll::Ready(()) => return Poll::Ready(Err(RPCError::Timeout)),
+                Poll::Pending => (),
+            }
+        }
+
+        Poll::Pending
     }
 }
 
-struct WSServerEventStream<PacketType> {
-    _unused: PacketType,
+// TODO: Do we even need this type?
+pub struct ServerEventStream<PacketType> {
+    packets: Pin<Box<mpsc::Receiver<IncomingPacket<PacketType>>>>,
 }
 
-impl<P> Stream for WSServerEventStream<P> {
-    type Item = P;
+impl<PacketType> Stream for ServerEventStream<PacketType> {
+    type Item = IncomingPacket<PacketType>;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
-        // TODO
-        panic!("Not yet implemented.");
+        // Safe, as we will not move self_.
+        let self_ = unsafe { self.get_unchecked_mut() };
+
+        Pin::as_mut(&mut self_.packets).poll_next(cx)
     }
-}*/
+}
+
+pub enum RPCError<StreamError> {
+    Closed,
+    Timeout,
+    Stream(StreamError)
+}
+
+pub async fn low_level_integration_test_client(address: String) {
+    use super::websocket::WebSocketConnection;
 
-pub async fn low_level_integration_test_client(_address: String) {
-    //let url = Url::parse(&address).unwrap();
-    //let (mut ws_stream, _) = connect_async(url).await.unwrap();
+    let url = Url::parse(&address).unwrap();
+    let (mut ws_stream, _) = connect_async(url).await.unwrap();
+    let mut conn = WebSocketConnection::new(ws_stream);
+    let (rpc_interface, server_events) = create::<_, _, u32>(conn);
     // TODO
     panic!("Not yet implemented.");
 }

src/network/websocket.rs

     stream: Pin<Box<WebSocketStream<S>>>,
 }
 
+impl<S> WebSocketConnection<S> {
+    pub fn new(s: WebSocketStream<S>) -> Self {
+        Self {
+            stream: Box::pin(s),
+        }
+    }
+}
+
 impl<S> Sink<Vec<u8>> for WebSocketConnection<S>
 where
     S: AsyncRead + AsyncWrite + Unpin,