bin/ircd2: cleanup comments and unused code

bin/ircd2/src/irc/client.rs

@@ -80,26 +80,8 @@ impl<C: AsyncRead + AsyncWrite + Send + Unpin + 'static> IrcClient<C> {
         loop {
             let mut line = String::new();
 
-            // TODO fix this lock
-            // let mut view = view.lock().await;
             futures::select! {
-                // Process msg from View
-                // evnt = view.process().fuse() => {
-                //     if let Err(e) = evnt {
-                //         error!("[CLIENT {}] Read line error: {}", self.address, e);
-                //         break
-                //     }
-                //     let event = evnt.unwrap();
-                //     match event.action {
-                //         EventAction::PrivMsg(mut m) => {
-                //             if let Err(e) = self.process_msg(&mut m).await {
-                //                 error!("[CLIENT {}] Process msg: {}",  self.address, e);
-                //                 break
-                //             }
-                //         }
-                //     }
-                // }
-                // Process msgs from other client connnected to the same irc server
+                // Process msg from View or other client connnected to the same irc server
                 msg = self.subscription.receive().fuse() => {
                     match msg {
                         ClientSubMsg::Privmsg(mut m) => {
@@ -576,6 +558,7 @@ impl<C: AsyncRead + AsyncWrite + Send + Unpin + 'static> IrcClient<C> {
                 self.reply(&t).await?;
             }
 
+            // Process missed messages if any (sorted by event's timestamp)
             let unread_events = self.unread_events.lock().await.events.clone();
 
             let chan_info = self.irc_config.channels.get_mut(chan).unwrap();

bin/ircd2/src/irc/mod.rs

@@ -134,7 +134,6 @@ impl IrcServer {
                 self.p2p.clone(),
                 self.model.clone(),
                 self.seen.clone(),
-                self.unread_events.clone(),
                 msg_recv,
                 self.clients_subscriptions.clone(),
             ))
@@ -177,7 +176,6 @@ impl IrcServer {
         p2p: P2pPtr,
         model: ModelPtr,
         seen: SeenPtr<EventId>,
-        unread_events: UnreadEventsPtr,
         recv: smol::channel::Receiver<(NotifierMsg, u64)>,
         clients_subscriptions: SubscriberPtr<ClientSubMsg>,
     ) -> Result<()> {
@@ -202,7 +200,6 @@ impl IrcServer {
                     if !seen.push(&event.hash()).await {
                         continue
                     }
-                    // view.lock().await.seen.insert(event.hash(), event.clone());
                     // unread_events.lock().await.insert(&event);
 
                     p2p.broadcast(event).await?;

bin/ircd2/src/model.rs

@@ -20,7 +20,7 @@ use std::{cmp::Ordering, collections::HashMap, fmt};
 
 use async_std::sync::{Arc, Mutex};
 use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable};
-use log::info;
+use log::error;
 use ripemd::{Digest, Ripemd256};
 
 use crate::{
@@ -101,8 +101,6 @@ impl Model {
             children: Vec::new(),
         };
 
-        // info!("time: {}", get_current_time());
-
         let root_node_id = root_node.event.hash();
 
         let mut event_map = HashMap::new();
@@ -154,7 +152,6 @@ impl Model {
     }
 
     async fn reorganize(&mut self) {
-        info!("Reorganize");
         for (_, orphan) in std::mem::take(&mut self.orphans) {
             if self.is_orphan(&orphan) {
                 // TODO should we remove orphan if it's too old
@@ -170,7 +167,7 @@ impl Model {
             let parent = match self.event_map.get_mut(&prev_event) {
                 Some(parent) => parent,
                 None => {
-                    info!("no parent");
+                    error!("No parent found, Orphan is not relinked");
                     continue
                 }
             };
@@ -178,9 +175,6 @@ impl Model {
 
             self.event_map.insert(node_hash, node.clone());
 
-            // TODO dispatch to events_queue
-            // to use events_queue here the add() and reorganize() functions should change to async
-
             self.events_queue.dispatch(&node.event).await.expect("error dispatching the event");
 
             // clean up the tree from old eventnodes

bin/ircd2/src/protocol_event.rs

@@ -21,7 +21,7 @@ use std::collections::{HashMap, VecDeque};
 use async_std::sync::{Arc, Mutex};
 use async_trait::async_trait;
 use darkfi_serial::{SerialDecodable, SerialEncodable};
-use log::{debug, info};
+use log::debug;
 use rand::{rngs::OsRng, RngCore};
 
 use darkfi::{net, util::async_util::sleep, Result};
@@ -130,7 +130,6 @@ impl UnreadEvents {
         if let Some(event) = self.events.get_mut(key) {
             event.read_confirms += 1;
             if event.read_confirms >= MAX_CONFIRM {
-                info!("max confirm reached");
                 result = Some(event.clone())
             }
         }
@@ -234,7 +233,6 @@ impl ProtocolEvent {
             // if event.read_confirms >= MAX_CONFIRM {
             //     self.new_event(&event).await?;
             // } else {
-            info!("add to unread_events: {:?}", event);
             self.unread_events.lock().await.insert(&event);
             self.send_inv(&event).await?;
             // }
@@ -250,29 +248,23 @@ impl ProtocolEvent {
         loop {
             let inv = self.inv_sub.receive().await?;
             let inv = (*inv).to_owned();
-            // info!("invs: {}", inv.invs.iter().len());
-            let the_inv = inv.invs[0].clone();
+            let inv_item = inv.invs[0].clone();
 
             // for inv in inv.invs.iter() {
-            if !self.seen_inv.push(&the_inv.id).await {
+            if !self.seen_inv.push(&inv_item.id).await {
                 continue
             }
 
-            info!("received inv: id: {}", the_inv.id);
-
             {
                 let mut unread_events = self.unread_events.lock().await;
 
-                if !unread_events.contains(&the_inv.hash) &&
-                    self.model.lock().await.get_event(&the_inv.hash).is_none()
+                if !unread_events.contains(&inv_item.hash) &&
+                    self.model.lock().await.get_event(&inv_item.hash).is_none()
                 {
-                    info!("send_getdata");
-                    self.send_getdata(vec![the_inv.hash]).await?;
-                } else if let Some(event) = unread_events.inc_read_confirms(&the_inv.hash) {
-                    info!("new_event() in handle_receive_inv");
+                    self.send_getdata(vec![inv_item.hash]).await?;
+                } else if let Some(event) = unread_events.inc_read_confirms(&inv_item.hash) {
                     self.new_event(&event).await?;
                 }
-                info!("unread events: {:?}", unread_events);
             }
             // }
 
@@ -286,21 +278,15 @@ impl ProtocolEvent {
             let getdata = self.getdata_sub.receive().await?;
             let events = (*getdata).to_owned().events;
 
-            // info!("received getdata()");
-
             for event_id in events {
-                // info!("requesting event with id: {:?}", event_id);
-
                 let unread_event = self.unread_events.lock().await.get(&event_id);
                 if let Some(event) = unread_event {
                     self.channel.send(event).await?;
-                    // info!("[unread_events] send event");
                     continue
                 }
 
                 let model_event = self.model.lock().await.get_event(&event_id);
                 if let Some(event) = model_event {
-                    // info!("[model] send event");
                     self.channel.send(event).await?;
                 }
             }
@@ -345,10 +331,8 @@ impl ProtocolEvent {
     async fn new_event(&self, event: &Event) -> Result<()> {
         let mut model = self.model.lock().await;
         if model.is_orphan(event) {
-            info!("orphan -> send_getdata()");
             self.send_getdata(vec![event.hash()]).await?;
         } else {
-            info!("not orphan -> add()");
             model.add(event.clone()).await;
         }
 
@@ -357,16 +341,8 @@ impl ProtocolEvent {
 
     async fn send_inv(&self, event: &Event) -> Result<()> {
         let id = OsRng.next_u64();
-        info!("send_inv() with id: {id}");
-        // let exclude_list = vec![self.channel.address()];
         self.p2p.broadcast(Inv { invs: vec![InvItem { id, hash: event.hash() }] }).await?;
 
-        // self.p2p
-        //     .broadcast_with_exclude(
-        //         Inv { invs: vec![InvItem { id, hash: event.hash() }] },
-        //         &exclude_list,
-        //     )
-        //     .await?;
         Ok(())
     }
 

bin/ircd2/src/view.rs

@@ -19,12 +19,10 @@
 use async_std::sync::{Arc, Mutex};
 use std::collections::HashMap;
 
-use darkfi::{Error, Result};
+use darkfi::Result;
 
 pub type ViewPtr = Arc<Mutex<View>>;
 
-use log::info;
-
 use crate::{
     events_queue::EventsQueuePtr,
     model::{Event, EventId},
@@ -43,15 +41,7 @@ impl View {
     pub async fn process(&mut self) -> Result<Event> {
         // loop {
         let new_event = self.events_queue.fetch().await?;
-        info!("fetched event from events queue: {:?}", new_event);
-        // TODO sort the events
         Ok(new_event)
-        // if !self.seen.contains_key(&new_event.hash()) {
-        //     self.seen.insert(new_event.hash(), new_event.clone());
-
-        // } else {
-        //     Err(Error::MalformedPacket)
-        // }
         // }
     }
 }