nodes are now responsible for peers

deccom/nodes/node.py

@@ -2,6 +2,7 @@
 from asyncio import exceptions
 from typing import Callable
 from deccom.cryptofuncs.hash import SHA256
+from deccom.peers.peer import Peer
 from deccom.utils.common import find_open_port
 from deccom.protocols.abstractprotocol import AbstractProtocol
 
@@ -142,7 +143,7 @@ class Introduction:
 
 
 class Node(object):
-    def __init__(self,  protocol: AbstractProtocol, ip_addr = "0.0.0.0", port = None, call_back: Callable[[tuple[str,int], bytes], None] = lambda addr, data: print(addr,data)) -> None:
+    def __init__(self, p: Peer, protocol: AbstractProtocol, ip_addr = "0.0.0.0", port = None, call_back: Callable[[tuple[str,int], bytes], None] = lambda addr, data: print(addr,data)) -> None:
         if port == None:
             port = find_open_port()
         self.port = port
@@ -151,14 +152,16 @@ def __init__(self,  protocol: AbstractProtocol, ip_addr = "0.0.0.0", port = None
         self.peers: dict[bytes,tuple[str,int]] = dict()
         print(f"Node listening on {ip_addr}:{port}")
         self.protocol_type = protocol
+        self.peer = p
         protocol.callback = call_back
+        self.peer.addr = (self.ip_addr, self.port)
         pass
 
     async def listen(self):
         loop = asyncio.get_running_loop()
         listen = loop.create_datagram_endpoint(self.protocol_type.get_lowest, local_addr=(self.ip_addr, self.port))
         self.transport, self.protocol = await listen
-        await self.protocol_type.start()
+        await self.protocol_type.start(self.peer)
     async def sendto(self, msg, addr): 
         await self.protocol_type.sendto(msg, addr=addr)
     async def ping(self, addr, success, error, dt):

deccom/nodes/streamnode.py

@@ -2,16 +2,19 @@
 import asyncio
 from typing import Callable
 from deccom.nodes.node import Node
+from deccom.peers.peer import Peer
 from deccom.utils.common import find_open_port
 from deccom.protocols.streamprotocol import StreamProtocol
 from deccom.cryptofuncs import SHA256
 class StreamNode(Node):
-    def __init__(self, protocol: StreamProtocol, ip_addr="0.0.0.0", port=None, tcp_port = None, call_back: Callable[[tuple[str, int], bytes], None] = lambda addr, data: print(addr, data)) -> None:
+    def __init__(self, p: Peer, protocol: StreamProtocol, ip_addr="0.0.0.0", port=None, tcp_port = None, call_back: Callable[[tuple[str, int], bytes], None] = lambda addr, data: print(addr, data)) -> None:
         super().__init__(protocol, ip_addr, port, call_back)
         if tcp_port == None:
             tcp_port = find_open_port()
         self.protocol_type = protocol
         self.tcp_port = tcp_port
+        self.peer = p
+        self.peer.addr = (self.ip_addr, self.port)
         # print("tcp_port", tcp_port)
         self.peer_reads = dict()
         self.peer_writes = dict()
@@ -23,7 +26,7 @@ async def listen(self):
         self.server = await asyncio.start_server(
                 self.protocol_type.get_lowest_stream().handle_connection, self.ip_addr, self.tcp_port)
 
-        await self.protocol_type.start()
+        await self.protocol_type.start(self.peer)
 
     async def stream_data(self, node_id, data):
         # print("sending stream")