working version

Author: e-max

Cargo.lock

@@ -13,3 +13,5 @@ env_logger = "0.6.2"
 log = "0.4.7"
 chrono = "0.4.7"
 crossbeam-channel = "0.3.8"
+crossbeam-queue = "0.1.2"
+crossbeam-utils = "0.6.5"

Cargo.toml

@@ -2,26 +2,22 @@ use env_logger;
 use grin_core::core::hash::Hashed;
 use grin_core::pow::Difficulty;
 use grin_p2p::handshake::Handshake;
-use std::net::{IpAddr, Shutdown, SocketAddr, TcpListener, TcpStream};
-use std::sync::Arc;
+use std::net::{SocketAddr, TcpStream};
+use std::sync::{Arc, Mutex, RwLock};
 use std::thread;
 use std::time::Duration;
 
-use grin_core::core;
-use grin_core::core::hash::Hash;
 use grin_core::genesis::genesis_floo;
 use grin_core::global::{set_mining_mode, ChainTypes};
-use grin_p2p::types::{
-    Capabilities, ChainAdapter, Error, NetAdapter, P2PConfig, PeerAddr, PeerInfo, ReasonForBan,
-    TxHashSetRead,
-};
+use grin_p2p::types::{Capabilities, P2PConfig, PeerAddr};
 use grin_p2p::Peer;
-use grin_p2p::Server;
 use log::*;
+use std::collections::{HashMap, VecDeque};
 
 mod adapter;
 use crate::adapter::FakeAdapter;
-use grin_util::StopState;
+use crossbeam_queue::SegQueue;
+use crossbeam_utils::sync::ShardedLock;
 
 fn main() {
     env_logger::init();
@@ -33,16 +29,61 @@ fn main() {
 
     let handshake = Arc::new(Handshake::new(genesis_floo().hash(), cfg.clone()));
 
-    thread::spawn({
+    let queue = Arc::new(SegQueue::new());
+    let hm: HashMap<PeerAddr, Option<Vec<PeerAddr>>> = HashMap::new();
+    let storage = Arc::new(ShardedLock::new(hm));
+    //let peer_addr = PeerAddr(SocketAddr::new("127.0.0.1".parse().unwrap(), 13414));
+    let peer_addr = PeerAddr(SocketAddr::new("35.157.247.209".parse().unwrap(), 13414));
+
+    queue.push(peer_addr);
+
+    let t = thread::spawn({
         let handshake = handshake.clone();
         let local_addr = PeerAddr(SocketAddr::new(cfg.host, cfg.port));
-        move || {
-            let peer_addr = PeerAddr(SocketAddr::new("127.0.0.1".parse().unwrap(), 13414));
-            let res = connect(peer_addr, local_addr, &handshake);
-            println!("\x1B[35;1m res\x1B[0m = {:?}", res);
+        let queue = queue.clone();
+        let storage = storage.clone();
+        move || loop {
+            info!("New iterations");
+            let peer_addr = match queue.pop() {
+                Ok(addr) => addr,
+                Err(e) => {
+                    warn!("Queue is emtpy. Quit.");
+                    break;
+                }
+            };
+            println!("\x1B[33;1m peer_addr\x1B[0m = {:?}", peer_addr);
+            match connect(peer_addr, local_addr, &handshake) {
+                Ok(addrs) => {
+                    println!("\x1B[32;1m addrs\x1B[0m = {:?}", addrs);
+                    for a in &addrs {
+                        queue.push(a.clone());
+                    }
+                    let mut hm = storage.write().unwrap();
+                    hm.insert(peer_addr, Some(addrs));
+                }
+                Err(e) => {
+                    println!("\x1B[31;1m e\x1B[0m = {:?}", e);
+                    let mut hm = storage.write().unwrap();
+                    hm.insert(peer_addr, None);
+                }
+            }
+            //info!("Now sleep for 1 sec");
+            //thread::sleep(Duration::from_secs(1));
         }
     });
-    thread::sleep(Duration::from_secs(30));
+    t.join();
+
+    let mut public = 0;
+    for (k, v) in &(*storage.read().unwrap()) {
+        if v.is_some() {
+            public += 1;
+        }
+    }
+    println!(
+        "Result: total {}, public: {}",
+        storage.read().unwrap().len(),
+        public
+    );
 }
 
 fn connect(