Hide the SwarmTransport in the Swarm of rings-core

crates/core/src/dht/stabilization.rs

@@ -19,7 +19,7 @@ use crate::message::MessagePayload;
 use crate::message::NotifyPredecessorSend;
 use crate::message::PayloadSender;
 use crate::message::QueryForTopoInfoSend;
-use crate::transport::SwarmTransport;
+use crate::swarm::transport::SwarmTransport;
 
 /// The stabilization runner.
 #[derive(Clone)]

crates/core/src/inspect.rs

@@ -9,7 +9,7 @@ use crate::swarm::Swarm;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SwarmInspect {
-    pub connections: Vec<ConnectionInspect>,
+    pub peers: Vec<ConnectionInspect>,
     pub dht: DHTInspect,
     pub persistence_storage: StorageInspect,
     pub cache_storage: StorageInspect,
@@ -38,22 +38,12 @@ pub struct StorageInspect {
 impl SwarmInspect {
     pub async fn inspect(swarm: &Swarm) -> Self {
         let dht = DHTInspect::inspect(&swarm.dht());
-        let connections = {
-            let connections = swarm.transport.get_connections();
-
-            connections
-                .iter()
-                .map(|(did, c)| ConnectionInspect {
-                    did: did.to_string(),
-                    state: format!("{:?}", c.webrtc_connection_state()),
-                })
-                .collect()
-        };
+        let peers = swarm.peers();
         let persistence_storage = StorageInspect::inspect_kv_storage(&swarm.dht().storage).await;
         let cache_storage = StorageInspect::inspect_kv_storage(&swarm.dht().cache).await;
 
         Self {
-            connections,
+            peers,
             dht,
             persistence_storage,
             cache_storage,

crates/core/src/lib.rs

@@ -78,4 +78,3 @@ pub mod chunk;
 pub mod consts;
 pub mod inspect;
 pub mod measure;
-pub mod transport;

crates/core/src/measure.rs

@@ -5,6 +5,14 @@ use async_trait::async_trait;
 
 use crate::dht::Did;
 
+/// Type of Measure, see [Measure].
+#[cfg(not(feature = "wasm"))]
+pub type MeasureImpl = Box<dyn BehaviourJudgement + Send + Sync>;
+
+/// Type of Measure, see [crate::measure::Measure].
+#[cfg(feature = "wasm")]
+pub type MeasureImpl = Box<dyn BehaviourJudgement>;
+
 /// The tag of counters in measure.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum MeasureCounter {

crates/core/src/message/handlers/mod.rs

@@ -24,7 +24,7 @@ use crate::message::NotifyPredecessorSend;
 use crate::message::PayloadSender;
 use crate::swarm::callback::InnerSwarmCallback;
 use crate::swarm::callback::SharedSwarmCallback;
-use crate::transport::SwarmTransport;
+use crate::swarm::transport::SwarmTransport;
 
 /// Operator and Handler for Connection
 pub mod connection;

crates/core/src/message/handlers/storage.rs

@@ -24,8 +24,8 @@ use crate::message::MessageHandler;
 use crate::message::MessagePayload;
 use crate::message::PayloadSender;
 use crate::prelude::vnode::VNodeOperation;
+use crate::swarm::transport::SwarmTransport;
 use crate::swarm::Swarm;
-use crate::transport::SwarmTransport;
 
 /// ChordStorageInterface should imply necessary method for DHT storage
 #[cfg_attr(feature = "wasm", async_trait(?Send))]

crates/core/src/swarm/builder.rs

@@ -7,12 +7,12 @@ use std::sync::RwLock;
 
 use crate::dht::PeerRing;
 use crate::dht::VNodeStorage;
+use crate::measure::MeasureImpl;
 use crate::session::SessionSk;
 use crate::swarm::callback::SharedSwarmCallback;
 use crate::swarm::callback::SwarmCallback;
+use crate::swarm::transport::SwarmTransport;
 use crate::swarm::Swarm;
-use crate::transport::MeasureImpl;
-use crate::transport::SwarmTransport;
 
 struct DefaultCallback;
 impl SwarmCallback for DefaultCallback {}

crates/core/src/swarm/callback.rs

@@ -15,7 +15,7 @@ use crate::message::Message;
 use crate::message::MessageHandler;
 use crate::message::MessagePayload;
 use crate::message::MessageVerificationExt;
-use crate::transport::SwarmTransport;
+use crate::swarm::transport::SwarmTransport;
 
 type CallbackError = Box<dyn std::error::Error>;
 

crates/core/src/swarm/mod.rs

@@ -1,14 +1,15 @@
 #![warn(missing_docs)]
-//! Tranposrt management
+
+//! This mod is the main entrance of swarm.
 
 mod builder;
 /// Callback interface for swarm
 pub mod callback;
+pub(crate) mod transport;
 
 use std::sync::Arc;
 use std::sync::RwLock;
 
-use async_trait::async_trait;
 pub use builder::SwarmBuilder;
 
 use self::callback::InnerSwarmCallback;
@@ -17,20 +18,21 @@ use crate::dht::PeerRing;
 use crate::dht::Stabilizer;
 use crate::error::Error;
 use crate::error::Result;
+use crate::inspect::ConnectionInspect;
 use crate::inspect::SwarmInspect;
 use crate::message::Message;
 use crate::message::MessagePayload;
 use crate::message::MessageVerificationExt;
 use crate::message::PayloadSender;
 use crate::swarm::callback::SharedSwarmCallback;
-use crate::transport::SwarmTransport;
+use crate::swarm::transport::SwarmTransport;
 
 /// The transport and dht management.
 pub struct Swarm {
     /// Reference of DHT.
     pub(crate) dht: Arc<PeerRing>,
     /// Swarm tansport.
-    pub transport: Arc<SwarmTransport>,
+    pub(crate) transport: Arc<SwarmTransport>,
     callback: RwLock<SharedSwarmCallback>,
 }
 
@@ -101,33 +103,28 @@ impl Swarm {
         self.transport.send_message(msg, destination).await
     }
 
+    /// List peers and their connection status.
+    pub fn peers(&self) -> Vec<ConnectionInspect> {
+        self.transport
+            .get_connections()
+            .iter()
+            .map(|(did, c)| ConnectionInspect {
+                did: did.to_string(),
+                state: format!("{:?}", c.webrtc_connection_state()),
+            })
+            .collect()
+    }
+
     /// Check the status of swarm
     pub async fn inspect(&self) -> SwarmInspect {
         SwarmInspect::inspect(self).await
     }
 }
 
-/// ConnectionHandshake defined how to connect two connections between two swarms.
-#[cfg_attr(feature = "wasm", async_trait(?Send))]
-#[cfg_attr(not(feature = "wasm"), async_trait)]
-pub trait ConnectionHandshake {
+impl Swarm {
     /// Creaet new connection and its answer. This function will wrap the offer inside a payload
     /// with verification.
-    async fn create_offer(&self, peer: Did) -> Result<MessagePayload>;
-
-    /// Answer the offer of remote connection. This function will verify the answer payload and
-    /// will wrap the answer inside a payload with verification.
-    async fn answer_offer(&self, offer_payload: MessagePayload) -> Result<MessagePayload>;
-
-    /// Accept the answer of remote connection. This function will verify the answer payload and
-    /// will return its did with the connection.
-    async fn accept_answer(&self, answer_payload: MessagePayload) -> Result<()>;
-}
-
-#[cfg_attr(feature = "wasm", async_trait(?Send))]
-#[cfg_attr(not(feature = "wasm"), async_trait)]
-impl ConnectionHandshake for Swarm {
-    async fn create_offer(&self, peer: Did) -> Result<MessagePayload> {
+    pub async fn create_offer(&self, peer: Did) -> Result<MessagePayload> {
         let offer_msg = self
             .transport
             .prepare_connection_offer(peer, self.inner_callback()?)
@@ -145,7 +142,9 @@ impl ConnectionHandshake for Swarm {
         Ok(payload)
     }
 
-    async fn answer_offer(&self, offer_payload: MessagePayload) -> Result<MessagePayload> {
+    /// Answer the offer of remote connection. This function will verify the answer payload and
+    /// will wrap the answer inside a payload with verification.
+    pub async fn answer_offer(&self, offer_payload: MessagePayload) -> Result<MessagePayload> {
         if !offer_payload.verify() {
             return Err(Error::VerifySignatureFailed);
         }
@@ -174,7 +173,9 @@ impl ConnectionHandshake for Swarm {
         Ok(answer_payload)
     }
 
-    async fn accept_answer(&self, answer_payload: MessagePayload) -> Result<()> {
+    /// Accept the answer of remote connection. This function will verify the answer payload and
+    /// will return its did with the connection.
+    pub async fn accept_answer(&self, answer_payload: MessagePayload) -> Result<()> {
         if !answer_payload.verify() {
             return Err(Error::VerifySignatureFailed);
         }

crates/core/src/transport.rs → crates/core/src/swarm/transport.rs

@@ -29,7 +29,7 @@ use crate::dht::LiveDid;
 use crate::dht::PeerRing;
 use crate::error::Error;
 use crate::error::Result;
-use crate::measure::BehaviourJudgement;
+use crate::measure::MeasureImpl;
 use crate::message::ConnectNodeReport;
 use crate::message::ConnectNodeSend;
 use crate::message::Message;
@@ -38,14 +38,6 @@ use crate::message::PayloadSender;
 use crate::session::SessionSk;
 use crate::swarm::callback::InnerSwarmCallback;
 
-/// Type of Measure, see [crate::measure::Measure].
-#[cfg(not(feature = "wasm"))]
-pub type MeasureImpl = Box<dyn BehaviourJudgement + Send + Sync>;
-
-/// Type of Measure, see [crate::measure::Measure].
-#[cfg(feature = "wasm")]
-pub type MeasureImpl = Box<dyn BehaviourJudgement>;
-
 pub struct SwarmTransport {
     transport: Transport,
     session_sk: SessionSk,

crates/core/src/tests/default/test_stabilization.rs

@@ -140,15 +140,12 @@ async fn test_stabilization_final_dht() -> Result<()> {
     for swarm in swarms.iter() {
         println!(
             "Connected peers: {:?}",
-            SwarmInspect::inspect(swarm).await.connections
+            SwarmInspect::inspect(swarm).await.peers
         );
         current_dhts.push(DHTInspect::inspect(&swarm.dht()));
     }
 
-    for (i, (cur, exp)) in std::iter::zip(current_dhts, expected_dhts)
-        .enumerate()
-        .skip(2)
-    {
+    for (i, (cur, exp)) in std::iter::zip(current_dhts, expected_dhts).enumerate() {
         println!("Check node{}", i);
         pretty_assertions::assert_eq!(cur, exp);
     }

crates/core/src/tests/mod.rs

@@ -1,4 +1,3 @@
-use crate::swarm::ConnectionHandshake;
 use crate::swarm::Swarm;
 
 #[cfg(feature = "wasm")]

crates/core/src/tests/wasm/test_wasm_transport.rs

@@ -8,8 +8,8 @@ use wasm_bindgen_test::*;
 
 use super::prepare_node;
 use crate::ecc::SecretKey;
+use crate::swarm::transport::Transport;
 use crate::tests::manually_establish_connection;
-use crate::transport::Transport;
 
 struct DefaultCallback;
 impl TransportCallback for DefaultCallback {}

crates/node/src/native/cli.rs

@@ -71,8 +71,6 @@ impl Client {
             })
             .await
             .map_err(|e| anyhow::anyhow!("{}", e))?
-            .peer
-            .ok_or_else(|| anyhow::anyhow!("peer did not return"))?
             .did;
 
         ClientOutput::ok(format!("Remote did: {}", peer_did), peer_did)

crates/node/src/processor.rs

@@ -8,14 +8,14 @@ use std::time::Duration;
 
 use rings_core::dht::Did;
 use rings_core::dht::VNodeStorage;
+use rings_core::measure::MeasureImpl;
 use rings_core::message::Encoded;
 use rings_core::message::Encoder;
 use rings_core::message::Message;
 use rings_core::prelude::uuid;
 use rings_core::storage::MemStorage;
 use rings_core::swarm::Swarm;
 use rings_core::swarm::SwarmBuilder;
-use rings_core::transport::MeasureImpl;
 use rings_rpc::protos::rings_node::*;
 use serde::Deserialize;
 use serde::Serialize;
@@ -374,8 +374,6 @@ impl Processor {
 mod test {
     use futures::lock::Mutex;
     use rings_core::swarm::callback::SwarmCallback;
-    use rings_core::swarm::ConnectionHandshake;
-    use rings_transport::core::transport::WebrtcConnectionState;
 
     use super::*;
     use crate::prelude::*;
@@ -386,9 +384,9 @@ mod test {
         let peer_did = SecretKey::random().address().into();
         let processor = prepare_processor().await;
         processor.swarm.create_offer(peer_did).await.unwrap();
-        let conn_dids = processor.swarm.transport.get_connection_ids();
+        let conn_dids = processor.swarm.peers();
         assert_eq!(conn_dids.len(), 1);
-        assert_eq!(conn_dids.first().unwrap(), &peer_did);
+        assert_eq!(conn_dids.first().unwrap().did, peer_did.to_string());
     }
 
     struct SwarmCallbackInstance {
@@ -437,11 +435,12 @@ mod test {
         let offer = p1.swarm.create_offer(p2.did()).await.unwrap();
         assert_eq!(
             p1.swarm
-                .transport
-                .get_connection(p2.did())
+                .peers()
+                .into_iter()
+                .find(|peer| peer.did == p2.did().to_string())
                 .unwrap()
-                .webrtc_connection_state(),
-            WebrtcConnectionState::New,
+                .state,
+            "New"
         );
 
         let answer = p2.swarm.answer_offer(offer).await.unwrap();
@@ -452,20 +451,22 @@ mod test {
 
         assert_eq!(
             p1.swarm
-                .transport
-                .get_connection(p2.did())
+                .peers()
+                .into_iter()
+                .find(|peer| peer.did == p2.did().to_string())
                 .unwrap()
-                .webrtc_connection_state(),
-            WebrtcConnectionState::Connected,
+                .state,
+            "Connected",
             "p1 connection not connected"
         );
         assert_eq!(
             p2.swarm
-                .transport
-                .get_connection(p1.did())
+                .peers()
+                .into_iter()
+                .find(|peer| peer.did == p1.did().to_string())
                 .unwrap()
-                .webrtc_connection_state(),
-            WebrtcConnectionState::Connected,
+                .state,
+            "Connected",
             "p2 connection not connected"
         );