distributed-state-network 0.5.2__tar.gz → 0.5.4__tar.gz

{distributed_state_network-0.5.2 → distributed_state_network-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed-state-network
-Version: 0.5.2
+Version: 0.5.4
 Summary: A tool to distribute the state of a network device to other devices on the network
 Project-URL: Homepage, https://github.com/erinclemmer/distributed_state_network
 Project-URL: Issues, https://github.com/erinclemmer/distributed_state_network/issues

{distributed_state_network-0.5.2 → distributed_state_network-0.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "distributed-state-network"
-version = "0.5.2"
+version = "0.5.4"
 authors = [{name="Erin Clemmer", email="erin.c.clemmer@gmail.com"}]
 description = "A tool to distribute the state of a network device to other devices on the network"
 keywords = ["distributed", "networking"]

{distributed_state_network-0.5.2 → distributed_state_network-0.5.4}/src/distributed_state_network/dsnode.py

@@ -56,10 +56,8 @@ class DSNode:
             self.config.node_id: StatePacket.create(self.config.node_id, time.time(), self.cred_manager.my_private(), { })
         }
 
-        # Determine initial IP - use 127.0.0.1 for localhost, will be updated when connecting to remote nodes
-        initial_ip = "127.0.0.1"
         self.address_book = {
-            self.config.node_id: Endpoint(initial_ip, config.port)
+            self.config.node_id: Endpoint(self.config.network_ip, config.port)
         }
         
         self.logger = logging.getLogger("DSN: " + config.node_id)
@@ -74,6 +72,12 @@ class DSNode:
     def get_aes_key(self) -> bytes:
         return bytes.fromhex(self.config.aes_key)
 
+    def write_address_book(self, node_id: str, conn: Endpoint):
+        if conn.address == "127.0.0.1":
+            return
+        self.logger.info(f"Address set: {node_id} -> {conn.address}:{conn.port}")
+        self.address_book[node_id] = conn
+
     def network_tick(self):
         time.sleep(TICK_INTERVAL)
         if self.shutting_down:
@@ -96,6 +100,7 @@ class DSNode:
                     return
                 self.send_ping(node_id)
             except Exception:
+                self.logger.error(f"PING Failure for {node_id}")
                 if node_id in self.node_states:  # double check if something has changed since the ping request started
                     remove(node_id)
                     if self.disconnect_cb is not None:
@@ -185,11 +190,11 @@ class DSNode:
             if key == self.config.node_id:
                 continue
             
-            self.address_book[key] = pkt.connections[key]
+            self.write_address_book(key, pkt.connections[key])
             
             if key not in self.node_states:
                 self.send_hello(self.address_book[key])
-            
+                
             node_state = self.send_update(key)
             self.handle_update(node_state)
 
@@ -203,6 +208,8 @@ class DSNode:
 
         peers = { }
         for key in self.address_book.keys():
+            if key == self.config.node_id:
+                continue
             peers[key] = self.address_book[key]
         
         pkt = PeersPacket(self.config.node_id, None, peers)
@@ -213,7 +220,6 @@ class DSNode:
         self.logger.info(f"HELLO => {con.to_string()}")
 
         pkt = self.my_hello_packet()
-        pkt.detected_address = con.address
         payload = pkt.to_bytes()
         content = self.send_http_request(con, MSG_HELLO, payload)
         
@@ -234,18 +240,16 @@ class DSNode:
         if pkt.detected_address:
             self.logger.info(f"Server detected our IP as: {pkt.detected_address}")
             # Update our own connection in the address book with the detected IP
-            self.address_book[self.config.node_id] = Endpoint(pkt.detected_address, self.config.port)
+            self.write_address_book(self.config.node_id, pkt.detected_address, self.config.port)
         
-        # Store the peer's connection info
-        if pkt.node_id not in self.address_book:
-            self.address_book[pkt.node_id] = pkt.connection
+        self.write_address_book(pkt.node_id, con)
 
         if pkt.node_id not in self.node_states:
             self.node_states[pkt.node_id] = StatePacket(pkt.node_id, 0, b'', { })
 
         return pkt.node_id
 
-    def handle_hello(self, data: bytes, detected_address: str = None) -> bytes | None:
+    def handle_hello(self, data: bytes, detected_address: str) -> bytes:
         pkt = HelloPacket.from_bytes(data)
         self.logger.info(f"Received HELLO from {pkt.node_id}")
         if pkt.version != self.version:
@@ -254,9 +258,7 @@ class DSNode:
             raise Exception(505)  # Version not supported
 
         self.cred_manager.ensure_public(pkt.node_id, pkt.ecdsa_public_key)
-        
-        if pkt.node_id not in self.address_book:
-            self.address_book[pkt.node_id] = pkt.connection
+        self.write_address_book(pkt.node_id, Endpoint(detected_address, pkt.connection.port))
 
         if pkt.node_id not in self.node_states:
             self.node_states[pkt.node_id] = StatePacket(pkt.node_id, 0, b'', { })
@@ -280,6 +282,8 @@ class DSNode:
 
     def send_ping(self, node_id: str):     
         try:
+            conn = self.connection_from_node(node_id)
+            self.logger.debug(f"PING => {node_id} ({conn.address}:{conn.port})")
             self.send_request_to_node(node_id, MSG_PING, b' ')
         except Exception as e:
             raise Exception(f'PING => {node_id}: {e}')
@@ -306,7 +310,6 @@ class DSNode:
         
         if pkt.node_id not in self.node_states:
             self.node_states[pkt.node_id] = pkt
-            return
 
         if get_dict_hash(self.node_states[pkt.node_id].state_data) != get_dict_hash(pkt.state_data):
             self.node_states[pkt.node_id] = pkt
@@ -325,7 +328,6 @@ class DSNode:
 
     def bootstrap(self, con: Endpoint):
         bootstrap_id = self.send_hello(con)
-        self.address_book[bootstrap_id] = con
         content = self.send_update(bootstrap_id)
         self.handle_update(content)
         self.request_peers(bootstrap_id)

{distributed_state_network-0.5.2 → distributed_state_network-0.5.4}/src/distributed_state_network/handler.py

@@ -8,7 +8,7 @@ from distributed_state_network.objects.config import DSNodeConfig
 from distributed_state_network.util.aes import generate_aes_key
 from distributed_state_network.util import stop_thread
 
-VERSION = "0.5.2"
+VERSION = "0.5.4"
 logging.basicConfig(level=logging.INFO)
 
 # Silence Flask and Werkzeug logging

{distributed_state_network-0.5.2 → distributed_state_network-0.5.4}/src/distributed_state_network/objects/config.py

@@ -8,6 +8,7 @@ class DSNodeConfig:
     node_id: str
     credential_dir: str
     port: int
+    network_ip: str
     aes_key: str | None
     bootstrap_nodes: List[Endpoint]
 
@@ -16,7 +17,8 @@ class DSNodeConfig:
         return DSNodeConfig(
             data["node_id"], 
             data["credential_dir"] if "credential_dir" in data else "credentials",
-            data["port"], 
+            data["port"],
+            data["network_ip"] if "network_ip" in data else "127.0.0.1", 
             data["aes_key"] if "aes_key" in data else None, 
             [Endpoint.from_json(e) for e in data["bootstrap_nodes"]]
         )

{distributed_state_network-0.5.2 → distributed_state_network-0.5.4}/tests/connections.py

@@ -20,6 +20,7 @@ def start_node(node_id: str, bootstrap_port: int = None, disconnect_cb: Optional
         "node_id": node_id,
         "port": current_port,
         "aes_key": aes_key,
+        "network_ip": "127.0.0.1",
         "credential_dir": "credentials"
     }
     current_port += 1