manual+seedsync_session: unregister() when version exchange fails

src/net/session/manual_session.rs

@@ -175,22 +175,27 @@ impl Slot {
                 return Ok(())
             }
 
-            match self.p2p().hosts().try_register(self.addr.clone(), HostState::Connect) {
-                Ok(_) => {
-                    match self.connector.connect(&self.addr).await {
-                        Ok((url, channel)) => {
-                            info!(
-                                target: "net::manual_session",
-                                "[P2P] Manual outbound connected [{}]", url,
-                            );
+            if let Err(e) = self.p2p().hosts().try_register(self.addr.clone(), HostState::Connect) {
+                debug!(target: "net::manual_session",
+                    "Cannot connect to manual={}, err={}", &self.addr, e);
 
-                            let stop_sub = channel.subscribe_stop().await?;
+                continue
+            }
 
-                            // Channel is now connected but not yet setup
+            match self.connector.connect(&self.addr).await {
+                Ok((url, channel)) => {
+                    info!(
+                        target: "net::manual_session",
+                        "[P2P] Manual outbound connected [{}]", url,
+                    );
 
-                            // Register the new channel
-                            self.session().register_channel(channel.clone(), ex.clone()).await?;
+                    let stop_sub = channel.subscribe_stop().await?;
 
+                    // Channel is now connected but not yet setup
+
+                    // Register the new channel
+                    match self.session().register_channel(channel.clone(), ex.clone()).await {
+                        Ok(()) => {
                             // Wait for channel to close
                             stop_sub.receive().await;
 
@@ -200,21 +205,18 @@ impl Slot {
                             );
                         }
                         Err(e) => {
-                            warn!(
-                                target: "net::manual_session",
-                                "[P2P] Unable to connect to manual outbound [{}]: {}",
-                                self.addr, e,
-                            );
-
-                            // Free up this addr for future operations.
-                            self.p2p().hosts().unregister(&self.addr);
+                            self.handle_failure(e, &url);
                         }
                     }
                 }
-                // This address is currently unavailable.
                 Err(e) => {
-                    debug!(target: "net::manual_session", "[P2P] Unable to connect to manual
-                           outbound [{}]: {}", self.addr.clone(), e);
+                    warn!(
+                        target: "net::manual_session",
+                        "[P2P] Unable to connect to manual outbound [{}]: {}",
+                        self.addr, e,
+                    );
+
+                    self.handle_failure(e, &self.addr);
                 }
             }
 
@@ -227,6 +229,17 @@ impl Slot {
         }
     }
 
+    fn handle_failure(&self, error: Error, addr: &Url) {
+        warn!(
+            target: "net::manual_session",
+            "[P2P] Unable to connect to manual outbound [{}]: {}",
+            self.addr, error,
+        );
+
+        // Free up this addr for future operations.
+        self.p2p().hosts().unregister(addr);
+    }
+
     fn session(&self) -> ManualSessionPtr {
         self.session.upgrade().unwrap()
     }

src/net/session/seedsync_session.rs

@@ -220,54 +220,38 @@ impl Slot {
                     match self.session().register_channel(ch.clone(), ex.clone()).await {
                         Ok(()) => {
                             self.failed.store(false, SeqCst);
-                        }
 
-                        Err(e) => {
-                            warn!(
+                            info!(
                                 target: "net::session::seedsync_session",
-                                "[P2P] Failure during sync seed session [{}]: {}",
-                                url, e,
+                                "[P2P] Disconnecting from seed [{}]",
+                                url,
                             );
-                            self.failed.store(true, SeqCst);
-                        }
-                    }
+                            ch.stop().await;
 
-                    info!(
-                        target: "net::session::seedsync_session",
-                        "[P2P] Disconnecting from seed [{}]",
-                        url,
-                    );
-                    ch.stop().await;
-                }
+                            // Seed process complete
+                            if hosts.container.is_empty(HostColor::Grey) {
+                                warn!(target: "net::session::seedsync_session()",
+                                "[P2P] Greylist empty after seeding");
+                            }
 
-                Err(e) => {
-                    warn!(
-                        target: "net::session:seedsync_session",
-                        "[P2P] Failure contacting seed [{}]: {}",
-                        self.addr, e
-                    );
+                            // Reset the CondVar for future use.
+                            self.reset();
+                        }
 
-                    self.failed.store(true, SeqCst);
+                        Err(e) => {
+                            self.handle_failure(e, &url);
 
-                    // Free up this addr for future operations.
-                    self.p2p().hosts().unregister(&self.addr);
+                            continue
+                        }
+                    }
+                }
 
-                    // Reset the CondVar for future use.
-                    self.reset();
+                Err(e) => {
+                    self.handle_failure(e, &self.addr);
 
                     continue
                 }
             }
-
-            // Seed process complete
-            if hosts.container.is_empty(HostColor::Grey) {
-                warn!(target: "net::session::seedsync_session()",
-                "[P2P] Greylist empty after seeding");
-            }
-
-            // Reset the CondVar for future use.
-            self.reset();
-
             debug!(
                 target: "net::session::seedsync_session",
                 "SeedSyncSession::start_seed() [END]",
@@ -275,6 +259,22 @@ impl Slot {
         }
     }
 
+    fn handle_failure(&self, error: Error, addr: &Url) {
+        warn!(
+            target: "net::session::seedsync_session",
+            "[P2P] Unable to connect to manual outbound [{}]: {}",
+            self.addr, error,
+        );
+
+        self.failed.store(true, SeqCst);
+
+        // Free up this addr for future operations.
+        self.p2p().hosts().unregister(addr);
+
+        // Reset the CondVar for future use.
+        self.reset();
+    }
+
     pub fn failed(&self) -> bool {
         self.failed.load(SeqCst)
     }