distributed-state-network 0.0.3__tar.gz → 0.0.4__tar.gz

{distributed_state_network-0.0.3 → distributed_state_network-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed-state-network
-Version: 0.0.3
+Version: 0.0.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.0.3 → distributed_state_network-0.0.4}/documentation/ds-node-server.md

@@ -18,10 +18,11 @@ class DSNodeServer(HTTPServer):
 **Parameters:**
 - `config` (`DSNodeConfig`): Node configuration
 - `disconnect_callback` (`Optional[Callable]`): Callback for disconnect events
+- `update_callback` (`Optional[Callable]`): Callback for state update events
 
 ### Static Methods
 
-### `start(config: DSNodeConfig, disconnect_callback: Optional[Callable] = None) -> DSNodeServer`
+### `start(config: DSNodeConfig, disconnect_callback: Optional[Callable] = None, update_callback: Optional[Callable] = None) -> DSNodeServer`
 Creates and starts a new DSNodeServer instance with SSL configuration.
 ```python
 server = DSNodeServer.start(config)
@@ -30,6 +31,7 @@ server = DSNodeServer.start(config)
 **Parameters:**
 - `config` (`DSNodeConfig`): Node configuration
 - `disconnect_callback` (`Optional[Callable]`): Callback for disconnect events
+- `update_callback` (`Optional[Callable]`): Callback for state update events
 
 **Returns:**
 - `DSNodeServer`: Running server instance

{distributed_state_network-0.0.3 → distributed_state_network-0.0.4}/documentation/ds-node.md

@@ -18,13 +18,14 @@ class DSNode:
 ### Constructor
 
 ```python
-node = DSNode(config, "0.0.3", disconnect_callback=on_disconnect)
+node = DSNode(config, "0.0.3", disconnect_callback=on_disconnect, update_callback=on_update)
 ```
 
 **Parameters:**
 - `config` (`DSNodeConfig`): Node configuration
 - `version` (`str`): Protocol version string for compatibility checking
 - `disconnect_callback` (`Optional[Callable]`): Callback function invoked when a peer disconnects
+- `update_callback` (`Optional[Callable]`): Callback function invoked when the state of node updates
 
 ### Key Methods
 

{distributed_state_network-0.0.3 → distributed_state_network-0.0.4}/documentation/usage.md

@@ -65,4 +65,20 @@ config = DSNodeConfig(
 )
 
 server = DSNodeServer.start(config, disconnect_callback=handle_disconnect)
+```
+
+### With Update Callback
+
+```python
+def handle_update():
+    print("A peer has updated!")
+
+config = DSNodeConfig(
+    node_id="node3",
+    port=8002,
+    aes_key_file="/path/to/shared.key",
+    bootstrap_nodes=[Endpoint("127.0.0.1", 8000)]
+)
+
+server = DSNodeServer.start(config, update_callback=handle_update)
 ```

{distributed_state_network-0.0.3 → distributed_state_network-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "distributed-state-network"
-version = "0.0.3"
+version = "0.0.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.0.3 → distributed_state_network-0.0.4}/src/distributed_state_network/dsnode.py

@@ -29,7 +29,8 @@ class DSNode:
             self, 
             config: DSNodeConfig,
             version: str,
-            disconnect_callback: Optional[Callable] = None
+            disconnect_callback: Optional[Callable] = None,
+            update_callback: Optional[Callable] = None
         ):
         self.config = config
         self.version = version
@@ -50,6 +51,7 @@ class DSNode:
         
         self.logger = logging.getLogger("DSN: " + config.node_id)
         self.disconnect_cb = disconnect_callback
+        self.update_cb = update_callback
         if not os.path.exists(config.aes_key_file):
             raise Exception(f"Could not find aes key file in {config.aes_key_file}")
         threading.Thread(target=self.network_tick).start()
@@ -231,6 +233,9 @@ class DSNode:
         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
 
+        if self.update_cb is not None:
+            self.update_cb()
+
         return self.my_state().to_bytes()
 
     def my_state(self):

{distributed_state_network-0.0.3 → distributed_state_network-0.0.4}/src/distributed_state_network/handler.py

@@ -70,11 +70,12 @@ class DSNodeServer(HTTPServer):
     def __init__(
         self, 
         config: DSNodeConfig,
-        disconnect_callback: Optional[Callable] = None
+        disconnect_callback: Optional[Callable] = None,
+        update_callback: Optional[Callable] = None
     ):
         super().__init__(("127.0.0.1", config.port), DSNodeHandler)
         self.config = config
-        self.node = DSNode(config, VERSION, disconnect_callback)
+        self.node = DSNode(config, VERSION, disconnect_callback, update_callback)
         self.node.logger.info(f'Started DSNode on port {config.port}')
 
     def stop(self):
@@ -90,8 +91,8 @@ class DSNodeServer(HTTPServer):
             f.write(key)
 
     @staticmethod 
-    def start(config: DSNodeConfig, disconnect_callback: Optional[Callable] = None) -> 'NodeServer':
-        n = DSNodeServer(config, disconnect_callback)
+    def start(config: DSNodeConfig, disconnect_callback: Optional[Callable] = None, update_callback: Optional[Callable] = None) -> 'NodeServer':
+        n = DSNodeServer(config, disconnect_callback, update_callback)
         ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
         public_path = n.node.cert_manager.public_path(n.config.node_id)
         ssl_context.load_cert_chain(

{distributed_state_network-0.0.3 → distributed_state_network-0.0.4}/tests/connections.py

@@ -13,11 +13,11 @@ KEY_FILE = "network.key"
 if not os.path.exists(KEY_FILE):
     DSNodeServer.generate_key("network.key")
 
-d_cb_test = 0
+cb_test = 0
 
 current_port = 5000
 
-def start_node(node_id: str, bootstrap_port: int = None, disconnect_cb: Optional[Callable] = None):
+def start_node(node_id: str, bootstrap_port: int = None, disconnect_cb: Optional[Callable] = None, update_cb: Optional[Callable] = None):
     global current_port
     args = {
         "node_id": node_id,
@@ -33,7 +33,7 @@ def start_node(node_id: str, bootstrap_port: int = None, disconnect_cb: Optional
     else:
         args["bootstrap_nodes"] = []
 
-    return DSNodeServer.start(DSNodeConfig(**args), disconnect_cb)
+    return DSNodeServer.start(DSNodeConfig(**args), disconnect_cb, update_cb)
 
 class ConnectionsTest(unittest.TestCase):
     def test_one(self):
@@ -75,17 +75,31 @@ class ConnectionsTest(unittest.TestCase):
         self.assertEqual(["node-1", "node-3", "node-4"], sorted(node4.node.peers()))
 
     def test_disconnect_cb(self):
-        global d_cb_test
-        d_cb_test = 0
+        global cb_test
+        cb_test = 0
         def inc():
-            global d_cb_test
-            d_cb_test = 1
+            global cb_test
+            cb_test = 1
         node1 = start_node("node-1", None, inc)
         node2 = start_node("node-2", node1.config.port)
         time.sleep(1)
         node2.stop()
         time.sleep(5)
-        self.assertEqual(d_cb_test, 1)
+        self.assertEqual(cb_test, 1)
+
+    def test_update_cb(self):
+        global cb_test
+        cb_test = 0
+        def inc():
+            global cb_test
+            cb_test = 1
+        node1 = start_node("node-1", None, None, inc)
+        node2 = start_node("node-2", node1.config.port)
+        
+        node2.node.update_data("key", "value")
+        time.sleep(1)
+
+        self.assertEqual(cb_test, 1)
 
 if __name__ == '__main__':
     unittest.main()