dnetview/view: create active_ids that discards offline connections

bin/dnetview/src/main.rs

@@ -29,7 +29,7 @@ use dnetview::{
     config::{DnvConfig, CONFIG_FILE_CONTENTS},
     model::{ConnectInfo, Model, NodeInfo, SelectableObject, Session, SessionInfo},
     options::ProgramOptions,
-    util::{generate_id, make_connect_id, make_empty_id, make_node_id, make_session_id},
+    util::{is_empty_session, make_connect_id, make_empty_id, make_node_id, make_session_id},
     view::{IdListView, NodeInfoView, View},
 };
 
@@ -268,11 +268,14 @@ async fn parse_inbound(inbound: &Value, node_id: String) -> Result<SessionInfo>
                     }
                 }
             }
+            let is_empty = is_empty_session(connects.clone());
+
             let session_info = SessionInfo::new(
                 session_name,
                 session_id.clone(),
                 node_id.clone(),
                 connects.clone(),
+                is_empty,
             );
             Ok(session_info)
         }
@@ -299,7 +302,9 @@ async fn parse_manual(_manual: &Value, node_id: String) -> Result<SessionInfo> {
     let connect_info =
         ConnectInfo::new(connect_id, addr, is_empty, msg, status, state, msg_log, parent);
     connects.push(connect_info.clone());
-    let session_info = SessionInfo::new(session_name, session_id, node_id, connects.clone());
+    let is_empty = is_empty_session(connects.clone());
+    let session_info =
+        SessionInfo::new(session_name, session_id, node_id, connects.clone(), is_empty);
 
     Ok(session_info)
 }
@@ -369,8 +374,11 @@ async fn parse_outbound(outbound: &Value, node_id: String) -> Result<SessionInfo
                     }
                 }
             }
+
+            let is_empty = is_empty_session(connects.clone());
+
             let session_info =
-                SessionInfo::new(session_name, session_id, node_id, connects.clone());
+                SessionInfo::new(session_name, session_id, node_id, connects.clone(), is_empty);
             Ok(session_info)
         }
         None => Err(Error::ValueIsNotObject),
@@ -382,18 +390,19 @@ async fn render<B: Backend>(terminal: &mut Terminal<B>, model: Arc<Model>) -> Re
 
     terminal.clear()?;
 
-    let id_list = IdListView::new(FxHashSet::default());
+    let all_ids = IdListView::new(FxHashSet::default());
+    let active_ids = IdListView::new(FxHashSet::default());
     let info_list = NodeInfoView::new(FxHashMap::default());
     let selectable = FxHashMap::default();
 
-    let mut view = View::new(id_list.clone(), info_list.clone(), selectable);
-    view.id_list.state.select(Some(0));
+    let mut view = View::new(all_ids.clone(), active_ids.clone(), info_list.clone(), selectable);
+    view.all_ids.state.select(Some(0));
     view.info_list.index = 0;
 
     loop {
-        view.update_ids(model.ids.lock().await.clone());
-        view.update_node_info(model.node_info.lock().await.clone());
-        view.update_selectable(model.select_info.lock().await.clone());
+        view.init_ids(model.ids.lock().await.clone());
+        view.init_node_info(model.node_info.lock().await.clone());
+        view.init_selectable(model.select_info.lock().await.clone());
 
         terminal.draw(|f| {
             view.clone().render(f);
@@ -405,12 +414,12 @@ async fn render<B: Backend>(terminal: &mut Terminal<B>, model: Arc<Model>) -> Re
                     return Ok(())
                 }
                 Key::Char('j') => {
-                    view.id_list.next();
+                    view.active_ids.next();
                     //view.info_list.next();
-                    debug!("ID LIST STATE {:?}", view.id_list.state);
+                    //debug!("ID LIST STATE {:?}", view.all_ids.state);
                 }
                 Key::Char('k') => {
-                    view.id_list.previous();
+                    view.active_ids.previous();
                     //view.info_list.previous();
                     //debug!("ID LIST STATE {:?}", view.id_list.state);
                 }

bin/dnetview/src/model.rs

@@ -52,6 +52,7 @@ pub struct SessionInfo {
     pub session_id: String,
     pub parent: String,
     pub children: Vec<ConnectInfo>,
+    pub is_empty: bool,
 }
 
 impl SessionInfo {
@@ -60,8 +61,9 @@ impl SessionInfo {
         session_id: String,
         parent: String,
         children: Vec<ConnectInfo>,
+        is_empty: bool,
     ) -> SessionInfo {
-        SessionInfo { session_name, session_id, parent, children }
+        SessionInfo { session_name, session_id, parent, children, is_empty }
     }
 }
 

bin/dnetview/src/util.rs

@@ -1,4 +1,4 @@
-use crate::model::Session;
+use crate::model::{ConnectInfo, Session};
 use darkfi::{util::serial, Result};
 use rand::{thread_rng, Rng};
 
@@ -74,6 +74,7 @@ pub fn make_empty_id(node_id: String, session: &Session, count: u64) -> Result<S
 
     Ok(serial::serialize_hex(&num))
 }
-//pub fn is_empty_outbound(slots: Vec<Slot>) -> bool {
-//    return slots.iter().all(|slot| slot.is_empty);
-//}
+
+pub fn is_empty_session(connects: Vec<ConnectInfo>) -> bool {
+    return connects.iter().all(|conn| conn.is_empty)
+}

bin/dnetview/src/view.rs

@@ -17,34 +17,52 @@ use crate::model::{ConnectInfo, Model, NodeInfo, SelectableObject, SessionInfo};
 
 #[derive(Debug, Clone)]
 pub struct View {
-    pub id_list: IdListView,
+    pub all_ids: IdListView,
+    pub active_ids: IdListView,
     pub info_list: NodeInfoView,
     pub selectables: FxHashMap<String, SelectableObject>,
 }
 
 impl View {
     pub fn new(
-        id_list: IdListView,
+        all_ids: IdListView,
+        active_ids: IdListView,
         info_list: NodeInfoView,
         selectables: FxHashMap<String, SelectableObject>,
     ) -> View {
-        View { id_list, info_list, selectables }
+        View { all_ids, active_ids, info_list, selectables }
     }
 
-    pub fn update_ids(&mut self, ids: FxHashSet<String>) {
-        // TODO: check if it's active
+    pub fn init_active_ids(&mut self) {
+        for (id, node) in &self.info_list.infos {
+            self.active_ids.ids.insert(id.to_string());
+            for session in &node.children {
+                if session.is_empty == false {
+                    self.active_ids.ids.insert(session.session_id.to_string());
+                    for connection in &session.children {
+                        self.active_ids.ids.insert(connection.connect_id.to_string());
+                    }
+                }
+            }
+        }
+        //debug!("ACTIVE IDS {:?}", self.active_ids.ids);
+        //debug!("ALL IDS {:?}", self.all_ids.ids);
+    }
+
+    pub fn init_ids(&mut self, ids: FxHashSet<String>) {
         for id in ids {
-            self.id_list.ids.insert(id);
+            self.all_ids.ids.insert(id);
         }
+        self.init_active_ids();
     }
 
-    pub fn update_node_info(&mut self, nodes: FxHashMap<String, NodeInfo>) {
+    pub fn init_node_info(&mut self, nodes: FxHashMap<String, NodeInfo>) {
         for (id, node) in nodes {
             self.info_list.infos.insert(id, node);
         }
     }
 
-    pub fn update_selectable(&mut self, selectables: FxHashMap<String, SelectableObject>) {
+    pub fn init_selectable(&mut self, selectables: FxHashMap<String, SelectableObject>) {
         // TODO: remove unactive selectables
         for (id, obj) in selectables {
             self.selectables.insert(id, obj);
@@ -87,7 +105,7 @@ impl View {
         let nodes =
             List::new(nodes).block(Block::default().borders(Borders::ALL)).highlight_symbol(">> ");
 
-        f.render_stateful_widget(nodes, slice[0], &mut self.id_list.state);
+        f.render_stateful_widget(nodes, slice[0], &mut self.active_ids.state);
     }
 }