Implement opening of the DataStream. Just the broker copy task/manager is missing

bonknet_client/Cargo.toml

@@ -16,3 +16,4 @@ rustls-pemfile = "2.0.0"
 rmp-serde = "1.1.2"
 tracing = "0.1"
 tracing-subscriber = "0.3"
+uuid = { version = "1.7.0", features = ["serde"] }

bonknet_client/src/bin/client.rs

@@ -1,17 +1,102 @@
-use std::io::Error;
+use std::io::{Error, ErrorKind};
 use std::sync::Arc;
 use std::time::Duration;
 use futures::{StreamExt, SinkExt};
 use tokio::net::TcpStream;
 use tokio_rustls::rustls::{ClientConfig, RootCertStore};
-use tokio_rustls::rustls::pki_types::{ServerName, CertificateDer, PrivatePkcs8KeyDer};
+use tokio_rustls::rustls::pki_types::{ServerName};
 use tokio_rustls::TlsConnector;
-use tokio_util::bytes::BytesMut;
 use tokio_util::codec::{Framed, LengthDelimitedCodec};
 use libbonknet::*;
+use uuid::Uuid;
 use tracing::{info, error};
 
 
+async fn datastream(tlsconfig: ClientConfig, conn_id: Uuid) -> std::io::Result<()> {
+    let connector = TlsConnector::from(Arc::new(tlsconfig.clone()));
+    let dnsname = ServerName::try_from("localhost").unwrap();
+    let stream = TcpStream::connect("localhost:2541").await?;
+    let stream = connector.connect(dnsname, stream).await?;
+    let mut transport = Framed::new(stream, LengthDelimitedCodec::new());
+
+    let msg = FromClientCommand::UpgradeToDataStream(conn_id);
+    transport.send(rmp_serde::to_vec(&msg).unwrap().into()).await.unwrap();
+    match transport.next().await {
+        None => panic!("None in the transport"),
+        Some(item) => match item {
+            Ok(buf) => {
+                use ToPeerDataStream::*;
+                let msg: ToPeerDataStream = rmp_serde::from_slice(&buf).unwrap();
+                match msg {
+                    OkDataStreamRequestAccepted => {
+                        info!("Data Stream Accepted. Waiting for Open...");
+                    }
+                    Refused => {
+                        error!("Refused");
+                        return Err(Error::new(ErrorKind::ConnectionRefused, "Refused"));
+                    }
+                    other => {
+                        error!("Unexpected response: {:?}", other);
+                        return Err(Error::new(ErrorKind::ConnectionRefused, "Unexpected response"));
+                    }
+                }
+            }
+            Err(e) => {
+                error!("Error: {:?}", e);
+                return Err(e);
+            }
+        }
+    }
+    match transport.next().await {
+        None => panic!("None in the transport"),
+        Some(item) => match item {
+            Ok(buf) => {
+                use ToPeerDataStream::*;
+                let msg: ToPeerDataStream = rmp_serde::from_slice(&buf).unwrap();
+                match msg {
+                    OkDataStreamOpen => {
+                        info!("Data Stream Open!. Connecting Streams.");
+                    }
+                    Revoked => {
+                        error!("Data Stream Revoked!");
+                        return Err(Error::new(ErrorKind::ConnectionAborted, "Revoked"));
+                    }
+                    Refused => {
+                        error!("Refused");
+                        return Err(Error::new(ErrorKind::ConnectionRefused, "Refused"));
+                    }
+                    other => {
+                        error!("Unexpected response: {:?}", other);
+                        return Err(Error::new(ErrorKind::ConnectionRefused, "Unexpected response"));
+                    }
+                }
+            }
+            Err(e) => {
+                error!("Error: {:?}", e);
+                return Err(e);
+            }
+        }
+    }
+    let (mut rx, mut tx) = tokio::io::split(transport.into_inner());
+    let mut stdout = tokio::io::stdout();
+    let mut stdin = tokio::io::stdin();
+    let stdout_task = async move {
+        match tokio::io::copy(&mut rx, &mut stdout).await {
+            Ok(bytes_copied) => info!("{bytes_copied}"),
+            Err(e) => error!("Error during copy: {e}"),
+        }
+    };
+    let stdin_task = async move {
+        match tokio::io::copy(&mut stdin, &mut tx).await {
+            Ok(bytes_copied) => info!("{bytes_copied}"),
+            Err(e) => error!("Error during copy: {e}"),
+        }
+    };
+    tokio::join!(stdout_task, stdin_task);
+    Ok(())
+}
+
+
 #[tokio::main]
 async fn main() -> std::io::Result<()> {
     // Tracing Subscriber
@@ -31,7 +116,7 @@ async fn main() -> std::io::Result<()> {
         .with_root_certificates(broker_root_cert_store.clone())
         .with_client_auth_cert(vec![client_cert, root_client_cert], client_cert_prkey.into())
         .unwrap();
-    let connector = TlsConnector::from(Arc::new(tlsconfig));
+    let connector = TlsConnector::from(Arc::new(tlsconfig.clone()));
     let dnsname = ServerName::try_from("localhost").unwrap();
 
     let stream = TcpStream::connect("localhost:2541").await?;
@@ -47,9 +132,11 @@ async fn main() -> std::io::Result<()> {
                 use ToClientResponse::*;
                 let msg: ToClientResponse = rmp_serde::from_slice(&buf).unwrap();
                 match msg {
-                    OkRequest { .. } => error!("Wrong reply!"),
                     OkServerList { data } => info!("{}", data.join("\n")),
                     GenericError => error!("Generic Error during remote command execution"),
+                    others => {
+                        panic!("Unexpected Message type: {:?}", others);
+                    }
                 }
             }
             Err(e) => {
@@ -69,9 +156,12 @@ async fn main() -> std::io::Result<()> {
                 match msg {
                     OkRequest { conn_id } => {
                         info!("Received Client Connection ID: {:?}", conn_id);
+                        datastream(tlsconfig, conn_id).await.unwrap();
                     }
-                    OkServerList { .. } => error!("Wrong reply!"),
                     GenericError => error!("Generic Error during remote command execution"),
+                    others => {
+                        panic!("Unexpected Message type: {:?}", others);
+                    }
                 }
             }
             Err(e) => {