two variants of swarm

deccom/nodes/streamnode.py

@@ -8,13 +8,12 @@
 from deccom.cryptofuncs import SHA256
 class StreamNode(Node):
     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)
+        super().__init__(p, 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)
+        p.tcp = tcp_port
         # print("tcp_port", tcp_port)
         self.peer_reads = dict()
         self.peer_writes = dict()

trainer.py

@@ -111,10 +111,10 @@ def forward(self, x):
                       momentum=momentum)
 training = TrainingProtocol(3,3,int(argv[1]),net,optimizer,train_loader)
 training.set_lower(stream)
-me = TrainingNode(training,"127.0.0.1", 10015 if argv[1] == "0" else None)
+peer = Peer(None, None, pub_key=argv[1])
+me = TrainingNode(peer, training,"127.0.0.1", 10015 if argv[1] == "0" else None)
 print( "TCP", me.tcp_port)
-self.peer = Peer((me.ip_addr,me.port), tcp=me.tcp_port, pub_key=argv[1])
-print(self.peer.id_node)
+print(peer.id_node)
 loop = asyncio.new_event_loop()
 print("run...")
 

trainingnode.py

@@ -2,18 +2,20 @@
 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 trainingprotocol import TrainingProtocol
 from deccom.cryptofuncs import SHA256
 class TrainingNode(Node):
-    def __init__(self, protocol: TrainingProtocol, 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)
+    def __init__(self, p: Peer, protocol: TrainingProtocol, 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__(p, protocol, ip_addr, port, call_back)
         if tcp_port == None:
             tcp_port = find_open_port()
         self.protocol_type = protocol
         self.tcp_port = tcp_port
-        ("tcp_port", tcp_port)
+        print("tcp_port", tcp_port)
+        p.tcp = tcp_port
         self.peer_reads = dict()
         self.peer_writes = dict()
         # self.protocol_type.callback = lambda **kwargs: 0
@@ -25,7 +27,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")