distributed-state-network 0.0.1__tar.gz → 0.0.2__tar.gz

{distributed_state_network-0.0.1 → distributed_state_network-0.0.2}/.gitignore

@@ -7,4 +7,5 @@ test.key
 .coverage
 count.py
 appended.py
-py_line_count_history.jsonl
+py_line_count_history.jsonl
+network.key

{distributed_state_network-0.0.1 → distributed_state_network-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed-state-network
-Version: 0.0.1
+Version: 0.0.2
 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
@@ -99,9 +99,7 @@ temperature = node.read_data("sensor_node", "temperature")
 connected_nodes = node.peers()
 ```
 
-## Real-World Examples
-
-### Distributed Temperature Monitoring
+## Example: Distributed Temperature Monitoring
 
 Create a network of temperature sensors that share readings:
 
@@ -128,22 +126,4 @@ for node_id in monitor.node.peers():
     if node_id.startswith("sensor_"):
         temp = monitor.node.read_data(node_id, "temperature")
         print(f"{node_id}: {temp}°F")
-```
-
-## Troubleshooting
-
-### Node Can't Connect
-- Verify the AES key file is identical on all nodes
-- Check firewall rules allow traffic on the configured port
-- Ensure bootstrap node address is reachable
-
-### State Not Updating
-- Confirm nodes show as connected with `node.peers()`
-- Check network latency between nodes
-- Verify no duplicate node IDs (each must be unique)
-
-## Performance Characteristics
-- State updates typically propagate in <100ms on local networks
-- Each node stores the complete state of all other nodes
-- Suitable for networks up to ~100 nodes
-- State values should be kept reasonably small (< 1MB per key)
+```

{distributed_state_network-0.0.1 → distributed_state_network-0.0.2}/README.md

@@ -74,9 +74,7 @@ temperature = node.read_data("sensor_node", "temperature")
 connected_nodes = node.peers()
 ```
 
-## Real-World Examples
-
-### Distributed Temperature Monitoring
+## Example: Distributed Temperature Monitoring
 
 Create a network of temperature sensors that share readings:
 
@@ -103,22 +101,4 @@ for node_id in monitor.node.peers():
     if node_id.startswith("sensor_"):
         temp = monitor.node.read_data(node_id, "temperature")
         print(f"{node_id}: {temp}°F")
-```
-
-## Troubleshooting
-
-### Node Can't Connect
-- Verify the AES key file is identical on all nodes
-- Check firewall rules allow traffic on the configured port
-- Ensure bootstrap node address is reachable
-
-### State Not Updating
-- Confirm nodes show as connected with `node.peers()`
-- Check network latency between nodes
-- Verify no duplicate node IDs (each must be unique)
-
-## Performance Characteristics
-- State updates typically propagate in <100ms on local networks
-- Each node stores the complete state of all other nodes
-- Suitable for networks up to ~100 nodes
-- State values should be kept reasonably small (< 1MB per key)
+```

{distributed_state_network-0.0.1 → distributed_state_network-0.0.2}/pyproject.toml

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

@@ -1,6 +1,5 @@
 import os
 import time
-import json
 import logging
 
 import requests
@@ -16,7 +15,7 @@ from distributed_state_network.objects.config import DSNodeConfig
 
 from distributed_state_network.util import get_dict_hash
 from distributed_state_network.util.key_manager import CertManager, CredentialManager
-from distributed_state_network.util.aes import aes_encrypt, aes_decrypt, generate_aes_key
+from distributed_state_network.util.aes import aes_encrypt, aes_decrypt
 
 TICK_INTERVAL = 3
 
@@ -60,7 +59,7 @@ class DSNode:
     def network_tick(self):
         time.sleep(TICK_INTERVAL)
         if self.shutting_down:
-            self.logger.info(f"Shutting down node")
+            self.logger.info("Shutting down node")
             return
         self.test_connections()
         threading.Thread(target=self.network_tick).start()
@@ -69,9 +68,10 @@ class DSNode:
         def remove(node_id: str):
             if node_id in self.node_states:
                 del self.node_states[node_id]
+                del self.address_book[node_id]
                 self.logger.info(f"PING failed for {node_id}, disconnecting...")
         for node_id in self.node_states.copy().keys():
-            if not node_id in self.node_states or node_id == self.config.node_id:
+            if node_id not in self.node_states or node_id == self.config.node_id:
                 continue
             try:
                 if self.shutting_down:

distributed_state_network-0.0.2/tests/connections.py

@@ -0,0 +1,75 @@
+import os
+import sys
+import time
+import unittest
+
+sys.path.append(os.path.join(os.path.dirname(__file__), '../src'))
+
+from distributed_state_network import DSNodeServer, DSNodeConfig, Endpoint
+
+KEY_FILE = "network.key"
+
+if not os.path.exists(KEY_FILE):
+    DSNodeServer.generate_key("network.key")
+
+current_port = 5000
+
+def start_node(node_id: str, bootstrap_port: int = None):
+    global current_port
+    args = {
+        "node_id": node_id,
+        "port": current_port,
+        "aes_key_file": KEY_FILE
+    }
+    current_port += 1
+    if bootstrap_port is not None:
+        args["bootstrap_nodes"] = [Endpoint(
+            address="127.0.0.1",
+            port=bootstrap_port
+        )]
+    else:
+        args["bootstrap_nodes"] = []
+
+    return DSNodeServer.start(DSNodeConfig(**args))
+
+class ConnectionsTest(unittest.TestCase):
+    def test_one(self):
+        node = start_node("node-1")
+        self.assertEqual(["node-1"], node.node.peers())
+
+    def test_two(self):
+        node1 = start_node("node-1")
+        node2 = start_node("node-2", node1.config.port)
+        self.assertEqual(["node-1", "node-2"], sorted(node1.node.peers()))
+        self.assertEqual(["node-1", "node-2"], sorted(node2.node.peers()))
+
+    def test_many(self):
+        bootstrap_node = start_node("bootstrap")
+        nodes = []
+        for i in range(10):
+            nodes.append(start_node(f"node-{i}", bootstrap_node.config.port))
+
+        node_list = ["bootstrap"]
+        node_list.extend([f"node-{i}" for i in range(10)])
+
+        time.sleep(5)
+        self.assertEqual(node_list, sorted(bootstrap_node.node.peers()))
+        for i in range(10):
+            self.assertEqual(node_list, sorted(nodes[i].node.peers()))
+
+    def test_disconnect(self):
+        node1 = start_node("node-1")
+        node2 = start_node("node-2", node1.config.port)
+        node3 = start_node("node-3", node1.config.port)
+
+        time.sleep(1)
+        node2.stop()
+        time.sleep(10)
+        node4 = start_node("node-4", node1.config.port)
+        time.sleep(10)
+        self.assertEqual(["node-1", "node-3", "node-4"], sorted(node1.node.peers()))
+        self.assertEqual(["node-1", "node-3", "node-4"], sorted(node3.node.peers()))
+        self.assertEqual(["node-1", "node-3", "node-4"], sorted(node4.node.peers()))
+
+if __name__ == '__main__':
+    unittest.main()

distributed_state_network-0.0.1/security.md

@@ -1,14 +0,0 @@
-## Security Architecture
-We use a three-layer security model where each layer addresses a specific vulnerability. Understanding this design helps explain why certain setup steps are necessary and how your data stays protected.
-The Three-Layer Defense
-Think of our security like protecting a secret club where members share sensitive information. You need multiple types of protection because different attacks require different defenses.
-### Layer 1: AES
-AES Encryption acts as the network's membership card. Every message between nodes is encrypted with a shared AES key, making the network invisible to outsiders. If someone intercepts your network traffic without this key, they see only meaningless encrypted bytes. This is why you must carefully share the key file with trusted nodes - it's the fundamental gatekeeper of your network.
-### Layer 2: ECDSA
-ECDSA Signatures solve a critical problem that AES alone cannot address. Once someone has the network key, how do you prevent them from impersonating other nodes? Each node has its own unforgeable cryptographic identity. When node "sensor_1" shares its temperature reading, it signs that data with its private key. Other nodes verify this signature to ensure the data truly came from sensor_1, not from an attacker pretending to be sensor_1. This is why node IDs must be unique - each ID is permanently bound to a specific cryptographic identity.
-### Layer 3: HTTPS
-HTTPS/TLS prevents sophisticated network-level attacks. Even with encryption and signatures, an attacker positioned between two nodes could intercept messages, block updates, or redirect traffic to malicious servers. HTTPS certificates ensure you're communicating with the exact node you intend to reach. During the initial handshake, nodes exchange certificates that get verified on every subsequent connection, creating authenticated channels that can't be hijacked.
-
-## Why This Matters
-Each layer compensates for what the others cannot protect. AES keeps outsiders out but can't distinguish between insiders. ECDSA proves identity but doesn't hide data. HTTPS secures the transport but doesn't control network access. Together, they create a system where only authorized nodes can join, every piece of state data is cryptographically guaranteed to come from its claimed source, and all communications flow through verified channels. This isn't over-engineering - it's the minimum required for nodes to trust each other in a truly distributed system without any central authority.
-When you see the various key files and certificates being generated during setup, you're watching these three defensive layers being constructed. Each one is essential for maintaining the integrity and privacy of your distributed application.