Sped up P2P reconnections after sleep. Ensured successfull peer resolution. Updated dependencies.

src/commons/constants.rs

@@ -40,6 +40,7 @@ pub const UI_REFRESH_DELAY_MS: u128 = 500;
 pub const LOG_REFRESH_DELAY_SEC: u64 = 60;
 
 pub const POLL_TIMEOUT: Option<Duration> = Some(Duration::from_millis(500));
+pub const WAIT_FOR_INTERNET: Duration = Duration::from_secs(10);
 /// We start syncing blocks only when we got 4 and more connected nodes
 pub const MIN_CONNECTED_NODES_START_SYNC: usize = 4;
 pub const MAX_READ_BLOCK_TIME: u128 = 100;

src/p2p/network.rs

@@ -4,7 +4,7 @@ extern crate serde_json;
 use std::cmp::max;
 use std::collections::{HashMap, HashSet};
 use std::io::{Error, ErrorKind, Read, Write};
-use std::net::{IpAddr, Shutdown, SocketAddr, SocketAddrV4};
+use std::net::{IpAddr, Shutdown, SocketAddr, SocketAddrV4, ToSocketAddrs};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
@@ -69,6 +69,7 @@ impl Network {
         poll.registry().register(&mut server, SERVER, Interest::READABLE).expect("Error registering poll");
 
         // Starting peer connections to bootstrap nodes
+        wait_for_internet(WAIT_FOR_INTERNET);
         self.peers.connect_peers(&peers_addrs, poll.registry(), &mut self.token, yggdrasil_only);
 
         let mut ui_timer = Instant::now();
@@ -82,6 +83,7 @@ impl Network {
         loop {
             if self.peers.get_peers_count() == 0 && bootstrap_timer.elapsed().as_secs() > 60 {
                 warn!("Restarting swarm connections...");
+                wait_for_internet(WAIT_FOR_INTERNET);
                 // Starting peer connections to bootstrap nodes
                 self.peers.connect_peers(&peers_addrs, poll.registry(), &mut self.token, yggdrasil_only);
                 bootstrap_timer = Instant::now();
@@ -146,9 +148,7 @@ impl Network {
                     }
                 }
             }
-            if !events.is_empty() {
-                last_events_time = Instant::now();
-            } else if last_events_time.elapsed().as_secs() > MAX_IDLE_SECONDS {
+            if last_events_time.elapsed().as_secs() > MAX_IDLE_SECONDS {
                 if self.peers.get_peers_count() > 0 {
                     warn!("Something is wrong with swarm connections, closing all.");
                     self.peers.close_all_peers(poll.registry());
@@ -156,6 +156,8 @@ impl Network {
                 } else {
                     thread::sleep(POLL_TIMEOUT.unwrap());
                 }
+            } else if !events.is_empty() {
+                last_events_time = Instant::now();
             }
 
             if ui_timer.elapsed().as_millis() > UI_REFRESH_DELAY_MS {
@@ -843,6 +845,27 @@ fn send_message(connection: &mut TcpStream, data: &[u8]) -> io::Result<()> {
     connection.flush()
 }
 
+fn wait_for_internet(timeout: Duration) {
+    let addr = "alfis.name:443";
+    let start = Instant::now();
+    let delay = Duration::from_millis(200);
+
+    trace!("Waiting for internet connection...");
+    while start.elapsed() < timeout {
+        match addr.to_socket_addrs() {
+            Ok(_) => {
+                trace!("We got internet connection!");
+                return;
+            },
+            Err(_) => {
+                thread::sleep(delay);
+                continue;
+            }
+        };
+    }
+    trace!("Waiting for internet connection has timed out.")
+}
+
 fn would_block(err: &io::Error) -> bool {
     err.kind() == io::ErrorKind::WouldBlock
 }

src/p2p/peers.rs

@@ -1,8 +1,8 @@
 use std::cmp::min;
 use std::collections::{HashMap, HashSet};
-use std::io;
+use std::{io, thread};
 use std::net::{IpAddr, Shutdown, SocketAddr, ToSocketAddrs};
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 use chrono::Utc;
 #[allow(unused_imports)]
@@ -382,18 +382,12 @@ impl Peers {
     pub fn connect_peers(&mut self, peers_addrs: &[String], registry: &Registry, unique_token: &mut Token, yggdrasil_only: bool) {
         let mut set = HashSet::new();
         for peer in peers_addrs.iter() {
-            info!("Resolving address {}", peer);
-            let mut addresses: Vec<SocketAddr> = match peer.to_socket_addrs() {
-                Ok(peers) => peers.collect(),
-                Err(_) => { error!("Can't resolve address {}", &peer); continue; }
-            };
-            info!("Got addresses: {:?}", &addresses);
-
-            // At first we connect to 5 peer addresses
+            // At first we connect to 10 peer addresses
             if set.len() >= 10 {
                 break;
             }
 
+            let mut addresses = Self::resolve(peer);
             while !addresses.is_empty() {
                 let addr = addresses.remove(0);
                 if !set.contains(&addr) {
@@ -415,6 +409,29 @@ impl Peers {
         }
     }
 
+    /// Tries to resolve some address several times with timeout
+    fn resolve(peer: &str) -> Vec<SocketAddr> {
+        info!("Resolving address {}", peer);
+        let start = Instant::now();
+        let delay = Duration::from_millis(20);
+        let timeout = Duration::from_millis(200);
+        while start.elapsed() < timeout {
+            let addresses: Vec<SocketAddr> = match peer.to_socket_addrs() {
+                Ok(peers) => peers.collect(),
+                Err(e) => {
+                    trace!("Can't resolve address {}: {}", &peer, e);
+                    thread::sleep(delay);
+                    continue;
+                }
+            };
+            if !addresses.is_empty() {
+                info!("Got addresses: {:?}", &addresses);
+                return addresses;
+            }
+        }
+        vec![]
+    }
+
     fn connect_peer(&mut self, addr: &SocketAddr, registry: &Registry, unique_token: &mut Token, yggdrasil_only: bool) -> io::Result<()> {
         if self.ignored.contains(&addr.ip()) {
             return Err(io::Error::from(io::ErrorKind::ConnectionAborted));