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

bonknet_server/Cargo.toml

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

bonknet_server/src/bin/server.rs

@@ -1,14 +1,91 @@
+use std::io::{Error, ErrorKind};
 use std::sync::Arc;
 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::TlsConnector;
+use tokio_util::bytes::BytesMut;
 use tokio_util::codec::{Framed, LengthDelimitedCodec};
 use libbonknet::*;
+use uuid::Uuid;
 use tracing::{info, error};
+use libbonknet::ToPeerDataStream::{OkDataStreamOpen, OkDataStreamRequestAccepted, Refused, Revoked};
 
 
+async fn datastream(tlsconfig: Arc<ClientConfig>, conn_id: Uuid) -> std::io::Result<()> {
+    let connector = TlsConnector::from(tlsconfig);
+    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 = FromServerConnTypeMessage::OpenDataStream(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());
+    match tokio::io::copy(&mut rx, &mut tx).await {
+        Ok(bytes_copied) => info!("{bytes_copied}"),
+        Err(e) => error!("Error during copy: {e}"),
+    }
+    Ok(())
+}
+
 #[tokio::main]
 async fn main() -> std::io::Result<()> {
     // Tracing Subscriber
@@ -96,12 +173,12 @@ async fn main() -> std::io::Result<()> {
                         OkSendCommand => {
                             info!("Stream set in SendCommand mode");
                         }
-                        OkSubscribe => {
-                            panic!("Unexpected OkSubscribe");
-                        }
                         GenericFailure => {
                             panic!("Generic Failure during SendCommand");
                         }
+                        others => {
+                            panic!("Unexpected Message type: {:?}", others);
+                        }
                     }
                 }
                 Err(e) => {
@@ -161,12 +238,12 @@ async fn main() -> std::io::Result<()> {
                         OkSubscribe => {
                             info!("Stream set in Subscribe mode");
                         }
-                        OkSendCommand => {
-                            panic!("Unexpected OkSendCommand");
-                        }
                         GenericFailure => {
                             panic!("Generic Failure during SendCommand");
                         }
+                        others => {
+                            panic!("Unexpected Message type: {:?}", others);
+                        }
                     }
                 }
                 Err(e) => {
@@ -195,7 +272,9 @@ async fn main() -> std::io::Result<()> {
                                             out = Some(FromServerReply::Msg {
                                                 reply_id,
                                                 body: FromServerReplyBody::RequestAccepted,
-                                            })
+                                            });
+                                            // TODO: SPAWN DATASTREAM
+                                            tokio::spawn(datastream(tlsconfig.clone(), conn_id));
                                         }
                                     }
                                 }