2 files changed, 65 insertions, 45 deletions

diff --git a/src/main.rs b/src/main.rs
index 096b533..0c25725 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,4 @@
-use std::{sync::Arc, thread::sleep, time::Duration};
+use std::{sync::Arc, time::Duration};
 
 use bitcoin::{blocks::BlockChain, network::Network};
 use tokio::sync::Mutex;
@@ -10,7 +10,11 @@ async fn main() {
     network
         .lock()
         .await
+        .start();
+    network
+        .lock()
+        .await
         .broadcast(bitcoin::network::Request::Ibd(None))
         .await;
-    sleep(Duration::from_secs(100));
+    tokio::time::sleep(Duration::from_secs(100)).await;
 }
diff --git a/src/network.rs b/src/network.rs
index 82190a5..b198221 100644
--- a/src/network.rs
+++ b/src/network.rs
@@ -1,7 +1,4 @@
-use std::{
-    net::SocketAddr,
-    sync::{Arc, Weak},
-};
+use std::sync::{Arc, Weak};
 
 use serde::{Deserialize, Serialize};
 
@@ -29,19 +26,20 @@ pub enum Request {
 pub struct Network {
     this: Weak<Mutex<Self>>,
     me: Client,
-    listener: TcpListener,
+    listener: Arc<TcpListener>,
     peers: Vec<Arc<Mutex<Peer>>>,
     blockchain: Arc<Mutex<BlockChain>>,
 }
 
 impl Network {
     pub async fn new(blockchain: Arc<Mutex<BlockChain>>) -> Arc<Mutex<Self>> {
+        let listener = TcpListener::bind("0.0.0.0:6767")
+            .await
+            .unwrap();
         let this = Arc::new(Mutex::new(Self {
             me: Client::default(),
             this: Weak::new(),
-            listener: TcpListener::bind("0.0.0.0:6767")
-                .await
-                .unwrap(),
+            listener: Arc::new(listener),
             peers: Vec::default(),
             blockchain,
         }));
@@ -52,17 +50,59 @@ impl Network {
     }
 
     async fn try_peer(&mut self) {
+        let peer = Arc::new(Mutex::new(Peer::new(
+            self.this
+                .clone(),
+            TcpStream::connect("192.168.143.90:6767")
+                .await
+                .unwrap(),
+        )));
         self.peers
-            .push(Arc::new(Mutex::new(Peer::new(
-                self.this
-                    .clone(),
-                TcpStream::connect("192.168.1.100")
-                    .await
-                    .unwrap(),
-            ))))
+            .push(peer.clone());
+
+        spawn(async move {
+            peer.lock()
+                .await
+                .start()
+                .await;
+        });
     }
 
-    async fn start(&self) {
+    pub fn start(&self) {
+        let this = self
+            .this
+            .clone();
+        let listener = self
+            .listener
+            .clone();
+        spawn(async move {
+            loop {
+                let (stream, _addr) = listener
+                    .accept()
+                    .await
+                    .unwrap();
+
+                let peer = Arc::new(Mutex::new(Peer::new(this.clone(), stream)));
+
+                if let Some(parent) = this.upgrade() {
+                    let mut net = parent
+                        .lock()
+                        .await;
+                    net.peers
+                        .push(Arc::clone(&peer));
+                }
+
+                spawn({
+                    let peer = Arc::clone(&peer);
+                    async move {
+                        peer.lock()
+                            .await
+                            .start()
+                            .await;
+                    }
+                });
+            }
+        });
         let this = self
             .this
             .clone();
@@ -71,38 +111,12 @@ impl Network {
                 let mut net = parent
                     .lock()
                     .await;
-                net.listen()
+                net.try_peer()
                     .await;
             }
         });
     }
 
-    async fn listen(&mut self) -> ! {
-        loop {
-            let (stream, addr) = self
-                .listener
-                .accept()
-                .await
-                .unwrap();
-
-            let peer = Arc::new(Mutex::new(Peer::new(
-                self.this
-                    .clone(),
-                stream,
-            )));
-
-            self.peers
-                .push(Arc::clone(&peer));
-
-            spawn(async move {
-                peer.lock()
-                    .await
-                    .start()
-                    .await;
-            });
-        }
-    }
-
     pub async fn broadcast(&mut self, data: Request) {
         for p in &self.peers {
             p.lock()
@@ -122,6 +136,7 @@ struct Peer {
 
 impl Peer {
     fn new(parent: Weak<Mutex<Network>>, stream: TcpStream) -> Self {
+        eprintln!("a");
         Self {
             parent,
             framed: Framed::new(TokioFramed::new(stream, LengthDelimitedCodec::new()), Json::default()),
@@ -135,6 +150,7 @@ impl Peer {
                 .next()
                 .await
             {
+                eprintln!("a");
                 self.handle(req.unwrap())
                     .await;
             }