net: renamed SeedSession to SeedSyncSession

src/net/p2p.rs

@@ -15,7 +15,7 @@ use crate::{
 use super::{
     message::Message,
     protocol::{register_default_protocols, ProtocolRegistry},
-    session::{InboundSession, ManualSession, OutboundSession, SeedSession, Session},
+    session::{InboundSession, ManualSession, OutboundSession, SeedSyncSession, Session},
     Channel, ChannelPtr, Hosts, HostsPtr, Settings, SettingsPtr,
 };
 
@@ -132,7 +132,7 @@ impl P2p {
         *self.state.lock().await = P2pState::Start;
 
         // Start seed session
-        let seed = SeedSession::new(Arc::downgrade(&self));
+        let seed = SeedSyncSession::new(Arc::downgrade(&self));
         // This will block until all seed queries have finished
         seed.start(executor.clone()).await?;
 

src/net/session/mod.rs

@@ -8,10 +8,10 @@ use crate::Result;
 
 use super::{p2p::P2pPtr, protocol::ProtocolVersion, ChannelPtr};
 
-/// Seed session creates a connection to the seed nodes specified in settings.
-/// A new seed session is created every time we call p2p::start(). The seed
-/// session loops through all the configured seeds and tries to connect to
-/// them using a Connector. The seed session either connects successfully,
+/// Seed sync session creates a connection to the seed nodes specified in settings.
+/// A new seed sync session is created every time we call p2p::start(). The seed
+/// sync session loops through all the configured seeds and tries to connect to
+/// them using a Connector. Seed sync either connects successfully,
 /// fails with an error or times out.
 ///
 /// If a seed node connects successfully, it runs a version exchange protocol,
@@ -28,7 +28,7 @@ use super::{p2p::P2pPtr, protocol::ProtocolVersion, ChannelPtr};
 /// perform_handshake_protocols(). This runs the version exchange protocol,
 /// stores the channel in the p2p list of channels, and subscribes to a stop
 /// signal.
-pub mod seed_session;
+pub mod seedsync_session;
 
 pub mod manual_session;
 
@@ -61,7 +61,7 @@ pub const SESSION_ALL: SessionBitflag = 0b1111;
 pub use inbound_session::InboundSession;
 pub use manual_session::ManualSession;
 pub use outbound_session::OutboundSession;
-pub use seed_session::SeedSession;
+pub use seedsync_session::SeedSyncSession;
 
 pub type SessionWeakPtr = Arc<Weak<dyn Session + Send + Sync + 'static>>;
 

src/net/session/seed_session.rs → src/net/session/seedsync_session.rs

@@ -19,20 +19,20 @@ use super::{
 };
 
 /// Defines seed connections session.
-pub struct SeedSession {
+pub struct SeedSyncSession {
     p2p: Weak<P2p>,
 }
 
-impl SeedSession {
-    /// Create a new seed session instance.
+impl SeedSyncSession {
+    /// Create a new seed sync session instance.
     pub fn new(p2p: Weak<P2p>) -> Arc<Self> {
         Arc::new(Self { p2p })
     }
 
-    /// Start the seed session. Creates a new task for every seed connection and
+    /// Start the seed sync session. Creates a new task for every seed connection and
     /// starts the seed on each task.
     pub async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-        debug!(target: "net", "SeedSession::start() [START]");
+        debug!(target: "net", "SeedSyncSession::start() [START]");
         let settings = self.p2p().settings();
 
         if settings.seeds.is_empty() {
@@ -85,7 +85,7 @@ impl SeedSession {
             return Err(Error::NetworkOperationFailed)
         }
 
-        debug!(target: "net", "SeedSession::start() [END]");
+        debug!(target: "net", "SeedSyncSession::start() [END]");
         Ok(())
     }
 
@@ -96,7 +96,7 @@ impl SeedSession {
         seed: Url,
         executor: Arc<Executor<'_>>,
     ) -> Result<()> {
-        debug!(target: "net", "SeedSession::start_seed(i={}) [START]", seed_index);
+        debug!(target: "net", "SeedSyncSession::start_seed(i={}) [START]", seed_index);
         let (_hosts, settings) = {
             let p2p = self.p2p.upgrade().unwrap();
             (p2p.hosts(), p2p.settings())
@@ -113,13 +113,13 @@ impl SeedSession {
                 if let Err(err) =
                     self.clone().register_channel(channel.clone(), executor.clone()).await
                 {
-                    warn!("Failure during seed session #{} [{}]: {}", seed_index, seed, err);
+                    warn!("Failure during seed sync session #{} [{}]: {}", seed_index, seed, err);
                 }
 
                 info!("Disconnecting from seed #{} [{}]", seed_index, seed);
                 channel.stop().await;
 
-                debug!(target: "net", "SeedSession::start_seed(i={}) [END]", seed_index);
+                debug!(target: "net", "SeedSyncSession::start_seed(i={}) [END]", seed_index);
                 Ok(())
             }
             Err(err) => {
@@ -151,7 +151,7 @@ impl SeedSession {
 }
 
 #[async_trait]
-impl Session for SeedSession {
+impl Session for SeedSyncSession {
     async fn get_info(&self) -> serde_json::Value {
         json!({
             "key": 110