dnet: add events to model and display on view

also includes some minor cleanups

bin/dnet/main.py

@@ -86,14 +86,12 @@ class Dnetview:
             try:
                 info = await self.queue.get()
                 values = list(info.values())[0]
+                method = values.get("method")
 
-                # Update node info
-                if "result" in values:
-                    self.model.handle_nodes(info)
-
-                # Update event info: TODO
-                if "params" in values:
+                if method == "dnet.subscribe_events":
                     self.model.handle_event(info)
+                else:
+                    self.model.handle_nodes(info)
 
                 self.queue.task_done()
             except OSError as e:

bin/dnet/model.py

@@ -60,7 +60,7 @@ class Model:
 
             assert id in channel_lookup
             url = channel_lookup[id]["url"]
-            self.info.update_outbound(f"{i}", url)
+            self.info.update_outbound(f"{id}", url)
 
         for channel in channels:
             if channel["session"] != "seed":
@@ -80,65 +80,57 @@ class Model:
         name = list(event.keys())[0]
         values = list(event.values())[0]
         params = values.get("params")
-
         event = params[0].get("event")
         info = params[0].get("info")
 
         t = time.localtime()
         current_time = time.strftime("%H:%M:%S", t)
         
-        match event:
+        match event:                        
             case "send":
                 nano = info.get("time")
                 cmd = info.get("cmd")
                 chan = info.get("chan")
                 addr = chan.get("addr")
-
                 t = (dt.datetime
                         .fromtimestamp(int(nano)/1000000000)
                         .strftime('%Y-%m-%d %H:%M:%S.%f'))
-
                 self.info.update_msg(addr, (t, event, cmd))
-                logging.debug(f"{t} {addr} {event} {cmd}")
             case "recv":
                 nano = info.get("time")
                 cmd = info.get("cmd")
                 chan = info.get("chan")
                 addr = chan.get("addr")
-
                 t = (dt.datetime
                         .fromtimestamp(int(nano)/1000000000)
                         .strftime('%Y-%m-%d %H:%M:%S.%f'))
-                
                 self.info.update_msg(addr, (t, event, cmd))
-                logging.debug(f"{t} {addr} {event} {cmd}")
             case "inbound_connected":
                 addr = info["addr"]
-                logging.debug(f"{current_time} inbound (connect):    {addr}")
+                self.info.update_event((f"{name}", "inbound"), f"inbound (connect): {addr}")
             case "inbound_disconnected":
                 addr = info["addr"]
-                logging.debug(f"{current_time} inbound (disconnect): {addr}")
+                self.info.update_event((f"{name}","inbound"), f"inbound (disconnect): {addr}")
             case "outbound_slot_sleeping":
                 slot = info["slot"]
-                logging.debug(f"{current_time} slot {slot}: sleeping")
-                self.info.append_outbound(str(slot), "sleeping")
+                self.info.update_event((f"{name}", f"{slot}"), "sleeping")
             case "outbound_slot_connecting":
                 slot = info["slot"]
                 addr = info["addr"]
-                logging.debug(f"{current_time} slot {slot}: connecting   addr={addr}")
+                self.info.update_event((f"{name}", f"{slot}"), f"connecting  addr={addr}")
             case "outbound_slot_connected":
                 slot = info["slot"]
                 addr = info["addr"]
                 channel_id = info["channel_id"]
-                logging.debug(f"{current_time} slot {slot}: connected    addr={addr}")
+                self.info.update_event(f"{name}, {slot}", f"connected   addr={addr}")
             case "outbound_slot_disconnected":
                 slot = info["slot"]
                 err = info["err"]
-                logging.debug(f"{current_time} slot {slot}: disconnected")
+                self.info.update_event((f"{slot}", "{slot}"), "disconnected")
             case "outbound_peer_discovery":
                 attempt = info["attempt"]
                 state = info["state"]
-                logging.debug(f"{current_time} peer_discovery: {state} (attempt {attempt})")
+                self.info.update_event((f"{name}", "outbound"), f"peer discovery: {state} (attempt {attempt})")
 
     def __repr__(self):
         return f"{self.nodes}"
@@ -150,11 +142,12 @@ class Info:
         self.outbounds = {}
         self.inbound = {}
         self.manual = {}
+        self.event = {}
         self.seed = {}
         self.msgs = {}
     
     def update_outbound(self, key, value):
-        self.outbounds[key] = [value]
+        self.outbounds[key] = value
 
     def update_inbound(self, key, value):
         self.inbound[key] = value
@@ -165,16 +158,15 @@ class Info:
     def update_seed(self, key, value):
         self.seed[key] = value
 
+    def update_event(self, key, value):
+        self.event[key] = value
+
     def update_msg(self, key, value):
         if key in self.msgs:
             self.msgs[key] += [value]
         else:
             self.msgs[key] = [value]
 
-    def append_outbound(self, key, value):
-        if value not in self.outbounds[key]:
-            self.outbounds[key].append(value)
-
     def __repr__(self):
         return (f"outbound: {self.outbounds}"
             f"inbound: {self.inbound}"

bin/dnet/view.py

@@ -78,12 +78,11 @@ class NodeView(urwid.WidgetWrap):
     def get_name(self):
         return self.name
 
-
 class ConnectView(urwid.WidgetWrap):
 
-    def __init__(self, info):
-        self.name = info
-        self.text = urwid.Text(f"{self.name}")
+    def __init__(self, node, kind):
+        self.name = (f"{node}", f"{kind}")
+        self.text = urwid.Text(f"  {kind}")
         super().__init__(self.text)
         self._w = urwid.AttrWrap(self._w, None)
         self.update_w()
@@ -103,12 +102,17 @@ class ConnectView(urwid.WidgetWrap):
     def get_name(self):
         return self.name
 
-
 class SlotView(urwid.WidgetWrap):
 
-    def __init__(self, info):
-        self.name = info
-        self.text = urwid.Text(f"{self.name}")
+    def __init__(self, node, num, info):
+        self.num = num
+        self.name = (f"{node}", f"{num}")
+        #self.name = info[0]
+        self.addr = info
+        if len(num) == 1:
+            self.text = urwid.Text(f"    {num}: {self.addr}")
+        else:
+            self.text = urwid.Text(f"    {self.addr}")
         super().__init__(self.text)
         self._w = urwid.AttrWrap(self._w, None)
         self.update_w()
@@ -128,6 +132,9 @@ class SlotView(urwid.WidgetWrap):
     def get_name(self):
         return self.name
 
+    def get_addr(self):
+        return self.addr
+
 
 class View():
     palette = [
@@ -148,53 +155,59 @@ class View():
         columns = urwid.Columns([leftbox, rightbox], focus_column=0)
         self.ui = urwid.Frame(urwid.AttrWrap( columns, 'body' ))
 
+
     async def update_view(self):
-        names = []
+        online = []
         while True:
             await asyncio.sleep(0.1)
-            for item in self.listwalker.contents:
-                name = item.get_name()
-                names.append(name)
+            for index, item in enumerate(self.listwalker.contents):
+                online.append(item.get_name())
 
-            for name, values in self.model.nodes.items():
-                # Update events
-                if name in names:
-                    for key, value in values.outbounds.items():
-                        if len(value) == 1:
-                            continue
-                        else:
-                            slot = SlotView(f"    {key}: {str(value[1])}")
-                            self.listwalker.contents[int(key)] = widget
-                # Update get_info()
+            for node, values in self.model.nodes.items():
+                if node in online:
+                    continue
                 else:
-                    widget = NodeView(name)
+                    widget = NodeView(node)
                     self.listwalker.contents.append(widget)
 
                     outbounds = values.outbounds
-                    logging.debug("outbounds", outbounds)
                     inbound = values.inbound
                     manual = values.manual
                     seed = values.seed
 
                     if len(outbounds) != 0:
-                        widget = ConnectView("  outbound")
+                        widget = ConnectView(node, "outbound")
                         self.listwalker.contents.append(widget)
-                        for num, info in outbounds.items():
-                            widget = SlotView(f"    {num}: {info[0]}")
+                        for i, info in outbounds.items():
+                            widget = SlotView(node, i, info)
                             self.listwalker.contents.append(widget)
 
                     if len(inbound) != 0:
-                        widget = ConnectView("  inbound")
+                        widget = ConnectView(node, "inbound")
                         self.listwalker.contents.append(widget)
 
                     if len(seed) != 0:
-                        widget = ConnectView("  seed")
+                        widget = ConnectView(node, "seed")
                         self.listwalker.contents.append(widget)
 
                     if len(manual) != 0:
-                        widget = ConnectView("  manual")
+                        widget = ConnectView(node, "manual")
                         self.listwalker.contents.append(widget)
 
+            for index, item in enumerate(self.listwalker.contents):
+                name = item.get_name()
+                if name in self.model.info.event.keys():
+                    slot_num = name[1]
+                    match slot_num:
+                        case "outbound":
+                            continue
+                        case "inbound":
+                            continue
+                        case _:
+                            value = self.model.info.event.get(name)
+                            widget = SlotView(node, slot_num, value)
+                            self.listwalker.contents[index] = widget
+
     async def render_info(self):
         while True:
             await asyncio.sleep(0.1)
@@ -208,17 +221,20 @@ class View():
                         self.pile.options()))
 
                 case "ConnectView":
-                    self.pile.contents.append((
-                        urwid.Text("Connection selected"),
-                        self.pile.options()))
+                    name = focus_w[0].get_name()
+                    
+                    if name in self.model.info.event.keys():
+                        values = self.model.info.event.get(name)
+
+                        self.pile.contents.append((
+                            urwid.Text(f" {values}"),
+                            self.pile.options()))
 
                 case "SlotView":
-                    numbered_name = focus_w[0].get_name()
-                    # Remove numbering
-                    name = numbered_name[7:]
+                    addr = focus_w[0].get_addr()
 
-                    if name in self.model.info.msgs.keys():
-                        values = (self.model.info.msgs.get(name))
+                    if addr in self.model.info.msgs.keys():
+                        values = self.model.info.msgs.get(addr)
 
                         for value in values:
                             time = value[0]