fix

.vscode/settings.json

@@ -1,10 +1,14 @@
 {
-    "rust-analyzer.showUnlinkedFileNotification": false,
-    "cSpell.words": [
-        "bitflags",
-        "hasher",
-        "Kadex",
-        "omni",
-        "Upnp"
-    ]
+  "rust-analyzer.showUnlinkedFileNotification": false,
+  "cSpell.words": [
+    "addrs",
+    "bitflags",
+    "Cbor",
+    "hasher",
+    "Kadex",
+    "kadx",
+    "omni",
+    "reqwest",
+    "Upnp"
+  ]
 }

modules/engine/Cargo.toml

@@ -44,6 +44,7 @@ sha3 = { workspace = true }
 ciborium = { workspace = true }
 bitflags = { workspace = true }
 tempfile = { workspace = true }
+reqwest = { workspace = true }
 
 [dev-dependencies]
 testcontainers = { workspace = true }

modules/engine/src/model.rs

@@ -1,5 +1,7 @@
+mod node_profile;
 mod omni_address;
 mod omni_signature;
 
+pub use node_profile::*;
 pub use omni_address::*;
 pub use omni_signature::*;

modules/engine/src/model/node_profile.rs

@@ -0,0 +1,10 @@
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct NodeProfile {
+    addrs: Vec<String>,
+}
+
+impl fmt::Display for NodeProfile {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.addrs.join(", "))
+    }
+}

modules/engine/src/service.rs

@@ -1,4 +1,5 @@
 pub mod connection;
-pub mod dht;
+pub mod exchange;
 pub mod session;
 pub mod storage;
+pub mod util;

modules/engine/src/service/connection/stream.rs

@@ -1,13 +1,15 @@
 use async_trait::async_trait;
 use futures_util::SinkExt;
-use serde::{Deserialize, Serialize};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio_stream::StreamExt;
 use tokio_util::{
     bytes::{Buf, BufMut, Bytes, BytesMut},
     codec::{Framed, LengthDelimitedCodec},
 };
 
+use crate::service::util::Cbor;
+
 #[async_trait]
 pub trait AsyncSendRecv {
     async fn send(&mut self, buffer: Bytes) -> anyhow::Result<()>;
@@ -59,18 +61,14 @@ where
     T: ?Sized + Send + Sync + Unpin,
 {
     async fn send_message<TItem: Serialize + Send>(&mut self, item: TItem) -> anyhow::Result<()> {
-        let buffer = BytesMut::new();
-        let mut writer = buffer.writer();
-        ciborium::ser::into_writer(&item, &mut writer)?;
-        let buffer = writer.into_inner().freeze();
-        self.send(buffer).await?;
+        let b = Cbor::serialize(item)?;
+        self.send(b).await?;
         Ok(())
     }
 
-    async fn recv_message<TItem: for<'a> Deserialize<'a>>(&mut self) -> anyhow::Result<TItem> {
-        let buffer = self.recv().await?;
-        let mut reader = buffer.reader();
-        let item: TItem = ciborium::de::from_reader(&mut reader)?;
+    async fn recv_message<TItem: DeserializeOwned>(&mut self) -> anyhow::Result<TItem> {
+        let b = self.recv().await?;
+        let item = Cbor::deserialize(b)?;
         Ok(item)
     }
 }

modules/engine/src/service/connection/tcp.rs

@@ -8,9 +8,7 @@ pub use upnp_client::*;
 
 #[cfg(test)]
 mod tests {
-    use crate::service::connection::{AsyncSendRecv, AsyncSendRecvExt};
-
-    use super::*;
+    use crate::service::connection::{AsyncSendRecv, AsyncSendRecvExt, ConnectionTcpAccepter, ConnectionTcpConnector, TcpProxyOption};
 
     #[tokio::test]
     #[ignore]

modules/engine/src/service/exchange.rs

@@ -0,0 +1,7 @@
+mod file;
+mod message;
+mod node;
+
+pub use file::*;
+pub use message::*;
+pub use node::*;

modules/engine/src/service/exchange/node.rs

@@ -0,0 +1,5 @@
+mod initial_node_fetcher;
+mod node_exchanger;
+
+pub use initial_node_fetcher::*;
+pub use node_exchanger::*;

modules/engine/src/service/exchange/node/initial_node_fetcher.rs

@@ -0,0 +1,23 @@
+use crate::model::NodeProfile;
+use reqwest;
+
+pub struct InitialNodeFetcher {
+    urls: Vec<String>,
+}
+
+impl InitialNodeFetcher {
+    pub fn new(urls: [&str]) {
+        Self { urls: urls.to_vec() }
+    }
+
+    pub async fn fetch(&self) -> Vec<NodeProfile> {
+        let client = reqwest::Client::new();
+
+        for u in self.urls {
+            let res = client.get(u).send().await?;
+            let res = res.text().await?;
+
+            for line in res.split_whitespace() {}
+        }
+    }
+}

modules/engine/src/service/exchange/node/node_exchanger.rs

@@ -0,0 +1,7 @@
+pub struct NodeExchanger;
+
+impl NodeExchanger {
+    pub async fn new() -> Self {
+        Self {}
+    }
+}

modules/engine/src/service/session.rs

@@ -15,11 +15,12 @@ mod tests {
 
     use crate::{
         model::{OmniAddress, OmniSignType, OmniSigner},
-        service::connection::{AsyncSendRecvExt, ConnectionTcpAccepter, ConnectionTcpConnector, TcpProxyOption, TcpProxyType},
+        service::{
+            connection::{AsyncSendRecvExt, ConnectionTcpAccepter, ConnectionTcpConnector, TcpProxyOption, TcpProxyType},
+            session::{SessionAccepter, SessionConnector},
+        },
     };
 
-    use super::*;
-
     #[tokio::test]
     #[ignore]
     async fn simple_test() {

modules/engine/src/service/util.rs

@@ -0,0 +1,5 @@
+mod cbor;
+mod kadx;
+
+pub use cbor::*;
+pub use kadx::*;

modules/engine/src/service/util/cbor.rs

@@ -0,0 +1,20 @@
+use serde::{de::DeserializeOwned, Serialize};
+use tokio_util::bytes::{Buf, BufMut, Bytes, BytesMut};
+
+pub struct Cbor;
+
+impl Cbor {
+    pub fn serialize<T: Serialize>(item: T) -> anyhow::Result<Bytes> {
+        let buffer = BytesMut::new();
+        let mut writer = buffer.writer();
+        ciborium::ser::into_writer(&item, &mut writer)?;
+        let buffer = writer.into_inner().freeze();
+        Ok(buffer)
+    }
+
+    pub fn deserialize<T: DeserializeOwned>(b: Bytes) -> anyhow::Result<T> {
+        let mut reader = b.reader();
+        let item = ciborium::de::from_reader(&mut reader)?;
+        Ok(item)
+    }
+}