[WIP] MTP migration

src/rho/server.rs

@@ -1,46 +1,81 @@
 use std::net::{IpAddr, Ipv4Addr};
 use std::time::Duration;
 
+use crate::load_keyring;
 use crate::{
     log,
     rho::connection::GeneralConnection,
     util::{file_util::load_file_vec, logger::PrintType},
 };
-use mtp::transport::{Host, Policy, SendMode, host};
+use mtp::crypto::PublicKeyBundle;
+use mtp::host::{AuthenticationPolicy, Host, HostConfig, Policy, SendMode};
+
+pub async fn get_by_connector_id(
+    _client_id: u64,
+    description: Option<String>,
+) -> Option<PublicKeyBundle> {
+    if let Some(description) = description {
+        if description == "iota" {
+            todo!()
+        } else if description == "client" {
+            todo!()
+        } else if description == "anonymous" {
+            todo!()
+        } else if description == "app" {
+            todo!()
+        }
+    }
+    None
+}
+pub async fn complete_register(_pub_key: PublicKeyBundle, description: Option<String>) -> u64 {
+    if let Some(description) = description {
+        if description == "iota" {
+            todo!()
+        }
+    }
+    0
+}
 
 pub async fn start(port: u16) -> Result<(), Box<dyn std::error::Error>> {
     let cert_pem = load_file_vec("certs", "cert.pem").expect("Error loading Pemfile");
 
     let key_pem = load_file_vec("certs", "key.pem").expect("Error loading Keyfile");
 
-    let mut host: Host = host(
-        IpAddr::V4(Ipv4Addr::UNSPECIFIED),
+    let host_config = HostConfig::new(
+        IpAddr::from(Ipv4Addr::new(0, 0, 0, 0)),
         port,
         cert_pem,
         key_pem,
-        Policy {
-            send_mode: SendMode::SingleStreamPerMessage,
-            max_message_size: 1_000_000_000,
-            close_frame_len: u32::MAX,
-            application_close_code: 0,
-            open_stream_timeout: Duration::from_millis(2_000),
-            write_timeout: Duration::from_millis(2_000),
-            accept_stream_timeout: Duration::from_millis(10_000),
-            read_timeout: Duration::from_millis(30_000),
-            keep_alive_interval: Some(Duration::from_secs(6)),
-            max_idle_timeout: Some(Duration::from_secs(30)),
-            force_close_delay: Duration::from_millis(300),
-            max_transient_recv_errors: 20,
-            transient_recv_backoff: Duration::from_millis(100),
-            receiver_queue_capacity: 1000,
-        },
     )
-    .await?;
+    .with_policy(Policy {
+        send_mode: SendMode::SingleStreamPerMessage,
+        max_message_size: 1_000_000_000,
+        close_frame_len: u32::MAX,
+        application_close_code: 0,
+        open_stream_timeout: Duration::from_millis(2_000),
+        write_timeout: Duration::from_millis(2_000),
+        accept_stream_timeout: Duration::from_millis(10_000),
+        read_timeout: Duration::from_millis(30_000),
+        keep_alive_interval: Some(Duration::from_secs(6)),
+        max_idle_timeout: Some(Duration::from_secs(30)),
+        force_close_delay: Duration::from_millis(300),
+        max_transient_recv_errors: 20,
+        transient_recv_backoff: Duration::from_millis(100),
+        receiver_queue_capacity: 1000,
+    })
+    .with_authentication(
+        load_keyring(),
+        Box::new(|user_id, description| Box::pin(get_by_connector_id(user_id, description))),
+        Box::new(|pub_key, description| Box::pin(complete_register(pub_key, description))),
+    )
+    .with_authentication_policy(AuthenticationPolicy::AllowAuthentication);
+
+    let mut host: Host = Host::new(host_config).await?;
     log!(0, PrintType::General, "Server listening on port {}", port);
 
-    while let Some((sender, receiver)) = host.next().await {
+    while let Ok(Some(conn)) = host.accept().await {
         tokio::spawn(async move {
-            let conn = GeneralConnection::new(sender, receiver);
+            let conn = GeneralConnection::new(conn.sender, conn.receiver);
             conn.handle().await;
         });
     }