feat(example,data): pass data marshallers to outbound connection & add dummy pass in client ex

Author: LizAinslie

Cargo.lock

@@ -1,6 +1,7 @@
 use tokio::io;
 
 use std::net::{IpAddr, SocketAddr};
+use std::sync::{Arc, Mutex};
 
 use log::{error, info};
 
@@ -9,13 +10,15 @@ use openssl::rsa::{Padding, Rsa};
 
 use trust_dns_resolver::{TokioAsyncResolver};
 use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
+use osp_data::registry::DataTypeRegistry;
 
 use osp_protocol::{ConnectionType, OSPUrl, Protocol};
 use osp_protocol::packet::handshake::{HandshakePacketGuestToHost, HandshakePacketHostToGuest};
 
 pub struct OutboundConnection<TState> {
     private_key: Rsa<Private>,
     hostname: String,
+    data_marshallers: Arc<Mutex<DataTypeRegistry>>,
     addr: SocketAddr,
     state: TState
 }
@@ -27,7 +30,7 @@ pub struct HandshakeState {
 }
 
 impl OutboundConnection<WaitingState> {
-    pub async fn create(url: OSPUrl, private_key: Rsa<Private>, hostname: String) -> io::Result<Self> {
+    pub async fn create(url: OSPUrl, private_key: Rsa<Private>, hostname: String, data_marshallers: Arc<Mutex<DataTypeRegistry>>) -> io::Result<Self> {
         info!("Resolving osp connection to {url}");
         let resolver = TokioAsyncResolver::tokio(ResolverConfig::default(), ResolverOpts::default());
 
@@ -37,20 +40,22 @@ impl OutboundConnection<WaitingState> {
             Self::create_with_socket_addr(
                 SocketAddr::new(IpAddr::from(ip.0), url.port),
                 private_key,
-                hostname
+                hostname,
+                data_marshallers,
             )
         } else {
             error!("Lookup failed");
             Err(io::Error::new(io::ErrorKind::NotConnected, format!("Failed to resolve address {}", url.domain)))
         }
     }
 
-    pub fn create_with_socket_addr(addr: SocketAddr, private_key: Rsa<Private>, hostname: String) -> io::Result<Self> {
+    pub fn create_with_socket_addr(addr: SocketAddr, private_key: Rsa<Private>, hostname: String, data_marshallers: Arc<Mutex<DataTypeRegistry>>) -> io::Result<Self> {
         info!("Opening connection to {addr}");
 
         Ok(Self {
             private_key,
             hostname,
+            data_marshallers,
             addr,
             state: WaitingState {}
         })
@@ -61,6 +66,7 @@ impl OutboundConnection<WaitingState> {
         Ok(OutboundConnection {
             private_key: self.private_key.clone(),
             hostname: self.hostname.clone(),
+            data_marshallers: self.data_marshallers.clone(),
             addr: self.addr.clone(),
             state: HandshakeState {
                 protocol: Protocol::connect(self.addr).await?,

crates/server/src/connection/outbound.rs

@@ -134,7 +134,8 @@ impl OSProtocolNode<ConnectionState> {
         let mut conn = OutboundConnection::create(
             url,
             self.state.lock().unwrap().private_key.clone(),
-            self.hostname.clone()
+            self.hostname.clone(),
+            self.data_marshallers.clone(),
         ).await?;
         let mut conn_in_handshake = conn.begin().await?;
         conn_in_handshake.handshake().await

crates/server/src/node.rs

@@ -7,6 +7,7 @@ edition = "2021"
 
 [dependencies]
 # Internal Crates
+osp_data = { workspace = true }
 osp_protocol = { workspace = true }
 osp_server_sdk = { workspace = true }
 

examples/test_server_implementation/Cargo.toml

@@ -1,4 +1,5 @@
 use std::fs;
+use std::sync::{Arc, Mutex};
 
 use clap::Parser;
 
@@ -9,6 +10,7 @@ use openssl::rsa::Rsa;
 use tokio::io;
 
 use url::Url;
+use osp_data::registry::DataTypeRegistry;
 
 use osp_protocol::OSPUrl;
 use osp_server_sdk::connection::outbound::OutboundConnection;
@@ -44,7 +46,12 @@ async fn main() -> io::Result<()> {
     let url = OSPUrl::from(reg_url);
 
     info!("Starting outbound thread");
-    let mut conn = OutboundConnection::create(url, key, args.hostname).await?;
+    let mut conn = OutboundConnection::create(
+        url,
+        key,
+        args.hostname,
+        Arc::new(Mutex::new(DataTypeRegistry::new())) // standalone for testing TODO REPLACE THIS WITH SOMETHING PROPER DAMMIT
+    ).await?;
     let mut conn_in_handshake = conn.begin().await?;
     conn_in_handshake.handshake().await
 }