distributed-state-network 0.2.1__tar.gz → 0.4.0__tar.gz

{distributed_state_network-0.2.1 → distributed_state_network-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distributed-state-network
-Version: 0.2.1
+Version: 0.4.0
 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
@@ -18,6 +18,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: cryptography
 Requires-Dist: ecdsa
+Requires-Dist: flask
 Requires-Dist: ipaddress
 Requires-Dist: logging
 Requires-Dist: requests

distributed_state_network-0.4.0/documentation/ds-node-server.md

@@ -0,0 +1,192 @@
+## DSNodeServer
+
+UDP server wrapper for DSNode that handles incoming network requests.
+
+```python
+from distributed_state_network import DSNodeServer
+```
+
+### Class Definition
+```python
+class DSNodeServer:
+    config: DSNodeConfig
+    node: DSNode
+    socket: socket.socket
+    running: bool
+    thread: threading.Thread
+```
+
+### Constructor
+
+**Parameters:**
+- `config` (`DSNodeConfig`): Node configuration
+- `sock` (`Optional[socket.socket]`): Custom UDP socket to use (optional, creates new socket if not provided)
+- `disconnect_callback` (`Optional[Callable]`): Callback for disconnect events
+- `update_callback` (`Optional[Callable]`): Callback for state update events
+
+**Example:**
+```python
+# Create with default socket
+server = DSNodeServer(config)
+
+# Or with custom socket
+custom_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+custom_socket.bind(("0.0.0.0", 8000))
+server = DSNodeServer(config, sock=custom_socket)
+```
+
+### Static Methods
+
+### `start(config: DSNodeConfig, sock: Optional[socket.socket] = None, disconnect_callback: Optional[Callable] = None, update_callback: Optional[Callable] = None) -> DSNodeServer`
+Creates and starts a new DSNodeServer instance with UDP socket.
+
+```python
+server = DSNodeServer.start(config)
+```
+
+**Parameters:**
+- `config` (`DSNodeConfig`): Node configuration
+- `sock` (`Optional[socket.socket]`): Custom UDP socket to use (optional)
+- `disconnect_callback` (`Optional[Callable]`): Callback for disconnect events (no parameters)
+- `update_callback` (`Optional[Callable]`): Callback for state update events (no parameters)
+
+**Returns:**
+- `DSNodeServer`: Running server instance
+
+**Example with bootstrap:**
+```python
+# Bootstrap node (first node in network)
+bootstrap_config = DSNodeConfig(
+    node_id="bootstrap",
+    port=8000,
+    aes_key_file="network.key",
+    bootstrap_nodes=[]
+)
+bootstrap = DSNodeServer.start(bootstrap_config)
+
+# Connector node (joins existing network)
+connector_config = DSNodeConfig(
+    node_id="connector",
+    port=8001,
+    aes_key_file="network.key",
+    bootstrap_nodes=[Endpoint("127.0.0.1", 8000)]
+)
+connector = DSNodeServer.start(connector_config)
+```
+
+### `generate_key(out_file_path: str) -> None`
+Generates a new AES key file for network encryption. All nodes in the same network must share the same AES key.
+
+**Parameters:**
+- `out_file_path` (`str`): Path where the key file will be saved
+
+**Example:**
+```python
+DSNodeServer.generate_key("/path/to/network.key")
+```
+
+### Instance Methods
+
+### `stop() -> None`
+Gracefully shuts down the server and cleans up resources.
+
+**Example:**
+```python
+server.stop()
+```
+
+### `serve_forever() -> None`
+Main UDP server loop. Continuously listens for incoming packets and routes them to appropriate handlers. This method is typically called automatically by `start()` in a daemon thread.
+
+**Note:** This method blocks until the server is stopped.
+
+## Network Protocol
+
+The server uses UDP sockets with the following characteristics:
+
+- **Port**: Configurable via DSNodeConfig
+- **Encryption**: All packets encrypted with AES
+- **Authentication**: ECDSA signatures for message verification
+- **Max Packet Size**: 65507 bytes (UDP limit)
+- **Timeout**: 2 seconds with automatic retry (up to 3 attempts)
+
+## Message Types
+
+The server handles four types of messages:
+
+1. **HELLO (1)**: Node introduction and public key exchange
+2. **PEERS (2)**: Request/response for peer list
+3. **UPDATE (3)**: State synchronization
+4. **PING (4)**: Connection health check
+
+## Automatic IP Detection
+
+When a client connects to a bootstrap server:
+
+1. Server extracts client's IP from UDP packet source address
+2. Server includes detected IP in HELLO response via `detected_address` field
+3. Client updates its own address book with the detected IP
+4. Correct IP propagates to other nodes through peer discovery
+
+This eliminates the need for manual IP configuration and works correctly behind NAT.
+
+## Thread Safety
+
+The server spawns separate threads for:
+- Main UDP receive loop (`serve_forever`)
+- Packet handling (one thread per packet)
+- Node network tick (periodic health checks)
+
+All shared state is protected with appropriate locks.
+
+## Example: Multi-Node Setup
+
+```python
+from distributed_state_network import DSNodeServer, DSNodeConfig, Endpoint
+
+# Generate shared AES key (only once)
+DSNodeServer.generate_key("shared.key")
+
+# Start bootstrap node
+bootstrap = DSNodeServer.start(DSNodeConfig(
+    node_id="bootstrap",
+    port=8000,
+    aes_key_file="shared.key",
+    bootstrap_nodes=[]
+))
+
+# Start additional nodes
+node1 = DSNodeServer.start(DSNodeConfig(
+    node_id="node1",
+    port=8001,
+    aes_key_file="shared.key",
+    bootstrap_nodes=[Endpoint("192.168.1.100", 8000)]
+))
+
+node2 = DSNodeServer.start(DSNodeConfig(
+    node_id="node2",
+    port=8002,
+    aes_key_file="shared.key",
+    bootstrap_nodes=[Endpoint("192.168.1.100", 8000)]
+))
+
+# Nodes automatically discover each other through bootstrap
+```
+
+## Troubleshooting
+
+### Server won't start
+- Check if port is already in use
+- Verify AES key file exists and is readable
+- Ensure firewall allows UDP traffic on specified port
+
+### Nodes can't connect
+- Verify all nodes use the same AES key
+- Check bootstrap node is running and reachable
+- Verify network connectivity (ping bootstrap address)
+- Check firewall rules for UDP ports
+
+### Connection drops
+- Increase timeout if on slow networks
+- Check network stability
+- Verify nodes aren't being stopped unexpectedly

distributed_state_network-0.4.0/documentation/protocol.md

@@ -0,0 +1,114 @@
+## Network Protocol
+
+### Transport Layer
+The network now uses **HTTP (HyperText Transfer Protocol)** with a Flask server for all communication. This provides:
+- Standard HTTP semantics for request/response patterns
+- Better compatibility with firewalls and proxies
+- Built-in error handling with HTTP status codes
+- Easy integration with monitoring and debugging tools
+- More flexible for future enhancements
+
+### Message Types and Endpoints
+All HTTP requests use specific endpoints to identify the packet type:
+
+- **POST /hello**: Exchange node information and credentials
+- **POST /peers**: Request/share peer list
+- **POST /update**: Send/receive state updates
+- **POST /ping**: Connectivity check
+
+### Packet Structure
+Each HTTP request follows this structure:
+1. **HTTP POST request** to the appropriate endpoint
+2. **Request Body**: AES Encrypted Payload containing:
+   - Message type (1 byte) - for verification
+   - Message payload (variable length)
+3. **Response Body**: AES Encrypted Payload containing:
+   - Message type (1 byte) - matches request type
+   - Response payload (variable length)
+
+### Message Types
+Internal message type constants (used for verification):
+- **Type 1 (HELLO)**: Exchange node information and credentials
+- **Type 2 (PEERS)**: Request/share peer list
+- **Type 3 (UPDATE)**: Send/receive state updates
+- **Type 4 (PING)**: Connectivity check
+
+### Security
+- All communication is encrypted using AES with a shared key
+- Messages are signed using ECDSA for authentication
+- HTTP request/response bodies are encrypted end-to-end
+- HTTPS/TLS can be added by placing a reverse proxy (nginx, apache) in front of the Flask server
+
+### State Synchronization
+- Nodes maintain a copy of all peers' states
+- Updates are broadcast to all connected peers
+- Timestamps prevent older updates from overwriting newer ones
+
+### HTTP Server Configuration
+- Flask server runs on specified port with threading enabled
+- Default timeout is 5 seconds for requests
+- Maximum retry attempts: 3 with 0.5 second delay between retries
+- Server runs in a separate daemon thread
+
+### HTTP Status Codes
+- **200 OK**: Successful request with response data
+- **204 No Content**: Successful request with no response data (e.g., some HELLO responses)
+- **400 Bad Request**: Malformed request or message type mismatch
+- **401 Unauthorized**: Signature verification failed
+- **406 Not Acceptable**: Invalid data, stale update, or other validation error
+- **500 Internal Server Error**: Unexpected server error
+- **505 HTTP Version Not Supported**: Used for version mismatch errors
+
+## Important Notes
+
+1. **Shared AES Key**: All nodes in the network must use the same AES key file
+2. **Unique Node IDs**: Each node must have a unique node_id
+3. **Port Availability**: Ensure the specified HTTP port is available before starting
+4. **Bootstrap Nodes**: At least one bootstrap node is required to join an existing network
+5. **Network Tick**: The network performs maintenance checks every 3 seconds
+6. **Credential Management**: ECDSA keys are automatically generated and stored in `credentials/` directory
+7. **HTTP Reliability**: The protocol implements retry logic (up to 3 attempts) for failed requests
+8. **HTTPS Support**: While the base implementation uses HTTP, you can add HTTPS by:
+   - Using a reverse proxy (nginx, apache) with SSL certificates
+   - Configuring Flask with SSL context (requires certificate files)
+
+## Error Handling
+
+Common error codes:
+- **401**: Not Authorized (signature verification failed)
+- **406**: Not Acceptable (invalid data, stale update, or version mismatch)
+- **505**: Version not supported
+
+## Migration from UDP
+
+If you're migrating from the UDP-based version:
+1. Install Flask: The dependency is now included in pyproject.toml
+2. Update firewall rules to allow HTTP traffic on your ports instead of UDP
+3. The API remains largely the same, but transport is now HTTP
+4. HTTP endpoints replace UDP message types for routing
+5. Consider adding HTTPS via reverse proxy for production deployments
+
+## Example URLs
+
+For a node running on `192.168.1.100:8080`:
+- HELLO endpoint: `http://192.168.1.100:8080/hello`
+- PEERS endpoint: `http://192.168.1.100:8080/peers`
+- UPDATE endpoint: `http://192.168.1.100:8080/update`
+- PING endpoint: `http://192.168.1.100:8080/ping`
+
+## Request Flow
+
+1. **Client prepares message**: Message type byte + payload
+2. **Client encrypts**: AES encryption applied to entire message
+3. **Client sends**: HTTP POST to appropriate endpoint
+4. **Server receives**: Flask routes to appropriate handler
+5. **Server decrypts**: AES decryption applied
+6. **Server validates**: Message type verification, signature checks
+7. **Server processes**: Business logic executed
+8. **Server prepares response**: Message type byte + response payload
+9. **Server encrypts**: AES encryption applied
+10. **Server sends**: HTTP response with encrypted body
+11. **Client receives**: Response status and body
+12. **Client decrypts**: AES decryption applied
+13. **Client validates**: Message type verification
+14. **Client processes**: Response data used

{distributed_state_network-0.2.1 → distributed_state_network-0.4.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["hatchling", "cryptography", "logging", "ipaddress", "requests", "ecdsa"]
+requires = ["hatchling", "cryptography", "logging", "ipaddress", "requests", "ecdsa", "flask"]
 build-backend = "hatchling.build"
 
 [project]
 name = "distributed-state-network"
-version = "0.2.1"
+version = "0.4.0"
 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"]
@@ -26,7 +26,8 @@ dependencies = [
     "logging",
     "ipaddress",
     "requests",
-    "ecdsa"
+    "ecdsa",
+    "flask"
 ]
 
 [project.urls]
@@ -34,4 +35,4 @@ Homepage = "https://github.com/erinclemmer/distributed_state_network"
 Issues = "https://github.com/erinclemmer/distributed_state_network/issues"
  
 [tool.hatch.build.targets.wheel]
-packages = ["src/distributed_state_network"]
+packages = ["src/distributed_state_network"]

{distributed_state_network-0.2.1 → distributed_state_network-0.4.0}/src/distributed_state_network/dsnode.py

@@ -1,8 +1,8 @@
 import os
 import time
-import socket
 import logging
 import threading
+import requests
 from typing import Dict, List, Optional, Callable
 
 from distributed_state_network.objects.endpoint import Endpoint
@@ -16,7 +16,7 @@ from distributed_state_network.util.key_manager import CredentialManager
 from distributed_state_network.util.aes import aes_encrypt, aes_decrypt
 
 TICK_INTERVAL = 3
-UDP_TIMEOUT = 2  # seconds
+HTTP_TIMEOUT = 2  # seconds
 
 # Message type constants (must match handler.py)
 MSG_HELLO = 1
@@ -24,6 +24,14 @@ MSG_PEERS = 2
 MSG_UPDATE = 3
 MSG_PING = 4
 
+# Map message types to endpoint paths
+MSG_TYPE_TO_PATH = {
+    MSG_HELLO: '/hello',
+    MSG_PEERS: '/peers',
+    MSG_UPDATE: '/update',
+    MSG_PING: '/ping'
+}
+
 class DSNode:
     config: DSNodeConfig
     address_book: Dict[str, Endpoint]
@@ -34,13 +42,12 @@ class DSNode:
             self, 
             config: DSNodeConfig,
             version: str,
-            sock: Optional[socket.socket] = None,
             disconnect_callback: Optional[Callable] = None,
             update_callback: Optional[Callable] = None
         ):
         self.config = config
         self.version = version
-        self.socket = sock  # Use the server's socket for sending
+        self.server = None  # Reference to the Flask server
         
         self.cred_manager = CredentialManager(config.node_id)
         self.cred_manager.generate_keys()
@@ -61,15 +68,11 @@ class DSNode:
         if not os.path.exists(config.aes_key_file):
             raise Exception(f"Could not find aes key file in {config.aes_key_file}")
         
-        # Response tracking for request/response matching
-        self.pending_responses = {}
-        self.response_lock = threading.Lock()
-        
         threading.Thread(target=self.network_tick, daemon=True).start()
 
-    def set_socket(self, sock: socket.socket):
-        """Set the socket to use for sending requests"""
-        self.socket = sock
+    def set_server(self, server):
+        """Set reference to the Flask server"""
+        self.server = server
 
     def get_aes_key(self):
         with open(self.config.aes_key_file, 'rb') as f:
@@ -102,83 +105,68 @@ class DSNode:
                     if self.disconnect_cb is not None:
                         self.disconnect_cb()
 
-    def send_udp_request(self, endpoint: Endpoint, msg_type: int, payload: bytes, retries: int = 0) -> bytes:
-        """Send UDP request and wait for response using the server's socket"""
-        if self.socket is None:
-            raise Exception("Socket not set. Cannot send UDP request.")
-        
+    def send_http_request(self, endpoint: Endpoint, msg_type: int, payload: bytes, retries: int = 0) -> bytes:
+        """Send HTTP request and wait for response"""
         try:
             # Prepend message type to payload
             data_with_type = bytes([msg_type]) + payload
             encrypted_data = self.encrypt_data(data_with_type)
             
-            # Create a unique ID for this request based on endpoint and msg type
-            request_id = (endpoint.address, endpoint.port, msg_type)
+            # Determine the URL path based on message type
+            path = MSG_TYPE_TO_PATH.get(msg_type, '/unknown')
+            url = f"http://{endpoint.address}:{endpoint.port}{path}"
             
-            # Set up response tracking
-            response_event = threading.Event()
-            with self.response_lock:
-                self.pending_responses[request_id] = {'event': response_event, 'data': None}
+            # Send HTTP POST request
+            response = requests.post(
+                url,
+                data=encrypted_data,
+                headers={'Content-Type': 'application/octet-stream'},
+                timeout=HTTP_TIMEOUT
+            )
             
-            # Send the packet using the server's socket
-            self.socket.sendto(encrypted_data, (endpoint.address, endpoint.port))
+            # Check response status
+            if response.status_code == 204:
+                # No content - valid for some responses like successful HELLO with no data
+                return b''
+            elif response.status_code != 200:
+                raise Exception(f"HTTP error: {response.status_code}")
             
-            # Wait for response
-            if response_event.wait(timeout=UDP_TIMEOUT):
-                with self.response_lock:
-                    response_data = self.pending_responses[request_id]['data']
-                    del self.pending_responses[request_id]
-                
-                if response_data is None:
-                    raise Exception("Response was None")
-                
-                return response_data
-            else:
-                # Timeout
-                with self.response_lock:
-                    if request_id in self.pending_responses:
-                        del self.pending_responses[request_id]
-                raise socket.timeout("Request timed out")
+            # Decrypt the response
+            decrypted = self.decrypt_data(response.content)
+            
+            if len(decrypted) < 1:
+                raise Exception("Empty response")
             
-        except socket.timeout:
+            # First byte is message type
+            response_msg_type = decrypted[0]
+            if response_msg_type != msg_type:
+                raise Exception(f"Response message type mismatch: expected {msg_type}, got {response_msg_type}")
+            
+            # Return the body (everything after the message type byte)
+            return decrypted[1:]
+            
+        except requests.exceptions.Timeout:
             if retries < 2:
                 time.sleep(0.5)
-                return self.send_udp_request(endpoint, msg_type, payload, retries + 1)
+                return self.send_http_request(endpoint, msg_type, payload, retries + 1)
             else:
-                raise Exception(f"UDP request to {endpoint.to_string()} timed out")
-        except Exception as e:
+                raise Exception(f"HTTP request to {endpoint.to_string()} timed out")
+        except requests.exceptions.RequestException as e:
             if retries < 2:
                 time.sleep(0.5)
-                return self.send_udp_request(endpoint, msg_type, payload, retries + 1)
+                return self.send_http_request(endpoint, msg_type, payload, retries + 1)
             else:
-                raise Exception(f"UDP request to {endpoint.to_string()} failed: {e}")
-
-    def handle_response(self, data: bytes, addr: tuple):
-        """Handle incoming response and match it to pending request"""
-        try:
-            # Decrypt the data
-            decrypted = self.decrypt_data(data)
-            
-            if len(decrypted) == 0:
-                return
-            
-            # First byte is message type
-            msg_type = decrypted[0]
-            body = decrypted[1:]
-            
-            # Find matching pending request
-            request_id = (addr[0], addr[1], msg_type)
-            
-            with self.response_lock:
-                if request_id in self.pending_responses:
-                    self.pending_responses[request_id]['data'] = body
-                    self.pending_responses[request_id]['event'].set()
+                raise Exception(f"HTTP request to {endpoint.to_string()} failed: {e}")
         except Exception as e:
-            self.logger.error(f"Error handling response from {addr}: {e}")
+            if retries < 2:
+                time.sleep(0.5)
+                return self.send_http_request(endpoint, msg_type, payload, retries + 1)
+            else:
+                raise Exception(f"HTTP request to {endpoint.to_string()} failed: {e}")
 
     def send_request_to_node(self, node_id: str, msg_type: int, payload: bytes) -> bytes:
         con = self.connection_from_node(node_id)
-        return self.send_udp_request(con, msg_type, payload)
+        return self.send_http_request(con, msg_type, payload)
 
     def encrypt_data(self, data: bytes) -> bytes:
         return aes_encrypt(self.get_aes_key(), data)
@@ -226,7 +214,7 @@ class DSNode:
         self.logger.info(f"HELLO => {con.to_string()}")
 
         payload = self.my_hello_packet().to_bytes()
-        content = self.send_udp_request(con, MSG_HELLO, payload)
+        content = self.send_http_request(con, MSG_HELLO, payload)
         
         # Get the response packet
         pkt = HelloPacket.from_bytes(content)
@@ -256,7 +244,7 @@ class DSNode:
 
         return pkt.node_id
 
-    def handle_hello(self, data: bytes, detected_address: str = None) -> bytes:
+    def handle_hello(self, data: bytes, detected_address: str = None) -> bytes | None:
         pkt = HelloPacket.from_bytes(data)
         self.logger.info(f"Received HELLO from {pkt.node_id}")
         if pkt.version != self.version:
@@ -268,6 +256,8 @@ class DSNode:
         
         if pkt.node_id not in self.address_book:
             self.address_book[pkt.node_id] = pkt.connection
+        else:
+            return None
 
         if pkt.node_id not in self.node_states:
             self.node_states[pkt.node_id] = StatePacket(pkt.node_id, 0, b'', { })
@@ -284,7 +274,7 @@ class DSNode:
             self.my_con(), 
             self.cred_manager.my_public(), 
             None,
-            None  # No certificate for UDP
+            None  # No certificate for HTTP
         )
         pkt.sign(self.cred_manager.my_private())
         return pkt

distributed_state_network-0.4.0/src/distributed_state_network/handler.py

@@ -0,0 +1,156 @@
+import sys
+import threading
+import logging
+from typing import Callable, Optional
+from flask import Flask, request, Response
+from distributed_state_network.dsnode import DSNode
+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.4.0"
+logging.basicConfig(level=logging.INFO)
+
+# Silence Flask and Werkzeug logging
+logging.getLogger('werkzeug').setLevel(logging.ERROR)
+
+# Message type constants
+MSG_HELLO = 1
+MSG_PEERS = 2
+MSG_UPDATE = 3
+MSG_PING = 4
+
+class DSNodeServer:
+    def __init__(
+        self, 
+        config: DSNodeConfig,
+        disconnect_callback: Optional[Callable] = None,
+        update_callback: Optional[Callable] = None
+    ):
+        self.config = config
+        self.running = False
+        
+        # Create Flask app
+        self.app = Flask(__name__)
+        self.app.logger.setLevel(logging.ERROR)  # Reduce Flask's logging noise
+        
+        # Create DSNode
+        self.node = DSNode(config, VERSION, disconnect_callback, update_callback)
+        self.node.set_server(self)  # Give node reference to server for making HTTP requests
+        
+        # Set up Flask routes
+        self._setup_routes()
+
+    def _setup_routes(self):
+        """Set up Flask routes for each message type"""
+        
+        @self.app.route('/hello', methods=['POST'])
+        def handle_hello_route():
+            return self._handle_request(MSG_HELLO, request.data, request.remote_addr)
+        
+        @self.app.route('/peers', methods=['POST'])
+        def handle_peers_route():
+            return self._handle_request(MSG_PEERS, request.data, request.remote_addr)
+        
+        @self.app.route('/update', methods=['POST'])
+        def handle_update_route():
+            return self._handle_request(MSG_UPDATE, request.data, request.remote_addr)
+        
+        @self.app.route('/ping', methods=['POST'])
+        def handle_ping_route():
+            return self._handle_request(MSG_PING, request.data, request.remote_addr)
+
+    def _handle_request(self, msg_type: int, data: bytes, remote_addr: str) -> Response:
+        if not self.running:
+            return Response(status=500)
+        """Handle incoming HTTP request"""
+        try:
+            # Decrypt the data
+            decrypted = self.node.decrypt_data(data)
+            
+            if len(decrypted) < 1:
+                return Response(status=400)
+            
+            # First byte should be message type (for verification)
+            received_msg_type = decrypted[0]
+            body = decrypted[1:]
+            
+            if received_msg_type != msg_type:
+                self.node.logger.error(f"Message type mismatch: expected {msg_type}, got {received_msg_type}")
+                return Response(status=400)
+            
+            response_data = None
+            
+            if msg_type == MSG_HELLO:
+                # Pass the detected IP address to handle_hello
+                response_data = self.node.handle_hello(body, remote_addr)
+                
+            elif msg_type == MSG_PEERS:
+                response_data = self.node.handle_peers(body)
+                
+            elif msg_type == MSG_UPDATE:
+                response_data = self.node.handle_update(body)
+                
+            elif msg_type == MSG_PING:
+                response_data = b''
+            
+            # Send response if handler returned data
+            if response_data is not None:
+                # Prepend message type to response
+                response_with_type = bytes([msg_type]) + response_data
+                encrypted_response = self.node.encrypt_data(response_with_type)
+                return Response(encrypted_response, status=200, mimetype='application/octet-stream')
+            else:
+                return Response(status=204)  # No content
+                
+        except Exception as e:
+            if len(e.args) >= 2 and isinstance(e.args[0], int):
+                # Error with HTTP status code
+                self.node.logger.error(f"Error handling {msg_type} from {remote_addr}: {e.args[1]}")
+                return Response(status=e.args[0])
+            else:
+                self.node.logger.error(f"Error handling {msg_type} from {remote_addr}: {e}")
+                return Response(status=500)
+
+    def stop(self):
+        self.node.shutting_down = True
+        self.running = False
+        if hasattr(self, 'thread'):
+            stop_thread(self.thread)
+
+    def serve_forever(self, port: int):
+        if self.running:
+            return
+        # Suppress Flask startup messages
+        cli = sys.modules['flask.cli']
+        cli.show_server_banner = lambda *x: None
+        
+        self.running = True
+        self.app.run(host='0.0.0.0', port=port, threaded=True, use_reloader=False)
+        self.node.logger.info(f'Started DSNode on HTTP port {port}')
+
+    @staticmethod
+    def generate_key(out_file_path: str):
+        key = generate_aes_key()
+        with open(out_file_path, 'wb') as f:
+            f.write(key)
+
+    @staticmethod 
+    def start(
+        config: DSNodeConfig, 
+        disconnect_callback: Optional[Callable] = None, 
+        update_callback: Optional[Callable] = None
+    ) -> 'DSNodeServer':
+        n = DSNodeServer(config, disconnect_callback, update_callback)
+        n.thread = threading.Thread(target=n.serve_forever, daemon=True, args=(config.port, ))
+        n.thread.start()
+
+        if n.config.bootstrap_nodes is not None and len(n.config.bootstrap_nodes) > 0:
+            for bs in n.config.bootstrap_nodes:
+                try:
+                    n.node.bootstrap(bs)
+                    break # Throws exception if connection is not made
+                except Exception as e:
+                    print(e)
+
+        return n

{distributed_state_network-0.2.1 → distributed_state_network-0.4.0}/test.py

@@ -3,9 +3,8 @@ import sys
 import time
 import random
 import shutil
-import logging
 import unittest
-import socket
+import requests
 from typing import List, Dict
 
 sys.path.append(os.path.join(os.path.dirname(__file__), './src'))
@@ -26,7 +25,7 @@ key_file = "src/distributed_state_network/test.key"
 if not os.path.exists(key_file):
     DSNodeServer.generate_key(key_file)
 
-def spawn_node(node_id: str, bootstrap_nodes: List[Dict] = [], sock: socket.socket = None):
+def spawn_node(node_id: str, bootstrap_nodes: List[Dict] = []):
     global current_port
     current_port += 1
     n = DSNodeServer.start(DSNodeConfig.from_dict({
@@ -34,7 +33,7 @@ def spawn_node(node_id: str, bootstrap_nodes: List[Dict] = [], sock: socket.sock
         "port": current_port,
         "aes_key_file": key_file,
         "bootstrap_nodes": bootstrap_nodes
-    }), sock=sock)
+    }))
     global nodes
     nodes.append(n)
     return n
@@ -140,10 +139,10 @@ class TestNode(unittest.TestCase):
         self.assertEqual(None, bootstrap.node.read_data("connector", "foo"))
 
         connector.node.update_data("foo", "bar")
-        time.sleep(0.5)  # Give time for UDP packet to arrive
+        time.sleep(0.5)  # Give time for HTTP request to complete
         self.assertEqual("bar", bootstrap.node.read_data("connector", "foo"))
         bootstrap.node.update_data("bar", "baz")
-        time.sleep(0.5)  # Give time for UDP packet to arrive
+        time.sleep(0.5)  # Give time for HTTP request to complete
         self.assertEqual("baz", connector.node.read_data("bootstrap", "bar"))
 
     def test_bad_aes_key(self):
@@ -154,38 +153,39 @@ class TestNode(unittest.TestCase):
             print(e)
 
     def test_authorization(self):
-        """Test that unauthorized UDP packets are rejected"""
+        """Test that unauthorized HTTP requests are rejected"""
         n = spawn_node("node")
         
-        # Create a UDP socket to send unauthorized data
-        test_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        test_sock.settimeout(2)
+        # Give Flask server time to start
+        time.sleep(0.5)
         
-        # Send unencrypted data - should be rejected
-        test_sock.sendto(b'TEST', ('127.0.0.1', n.config.port))
-        
-        # Try to receive response (should not get one for bad data)
+        # Send unencrypted data - should be rejected with 500 error
         try:
-            data, addr = test_sock.recvfrom(1024)
-            # If we get here, check that response indicates error
-            print(f"Received response: {data}")
-        except socket.timeout:
-            # This is expected - no valid response for bad data
-            pass
+            response = requests.post(
+                f'http://127.0.0.1:{n.config.port}/ping',
+                data=b'TEST',
+                timeout=2
+            )
+            # Should get error status code
+            self.assertNotEqual(response.status_code, 200)
+            print(f"Received status code for bad data: {response.status_code}")
+        except Exception as e:
+            # Connection errors are also acceptable
+            print(f"Request failed as expected: {e}")
         
         # Send properly encrypted data
         encrypted_data = n.node.encrypt_data(bytes([4]) + b'TEST')  # MSG_PING = 4
-        test_sock.sendto(encrypted_data, ('127.0.0.1', n.config.port))
+        response = requests.post(
+            f'http://127.0.0.1:{n.config.port}/ping',
+            data=encrypted_data,
+            headers={'Content-Type': 'application/octet-stream'},
+            timeout=2
+        )
         
-        # Should get a response for valid encrypted ping
-        try:
-            data, addr = test_sock.recvfrom(1024)
-            decrypted = n.node.decrypt_data(data)
-            self.assertEqual(decrypted[0], 4)  # Should be MSG_PING response
-        except socket.timeout:
-            self.fail("Should receive response for valid encrypted ping")
-        
-        test_sock.close()
+        # Should get successful response for valid encrypted ping
+        self.assertEqual(response.status_code, 200)
+        decrypted = n.node.decrypt_data(response.content)
+        self.assertEqual(decrypted[0], 4)  # Should be MSG_PING response
 
     def test_version_matching(self):
         bootstrap = spawn_node("bootstrap")
@@ -205,7 +205,7 @@ class TestNode(unittest.TestCase):
         connector = spawn_node("connector", [bootstrap.node.my_con().to_json()])
         try: 
             # Try to send malformed data
-            connector.node.send_udp_request(bootstrap.node.my_con(), 1, b'MALFORMED_DATA')
+            connector.node.send_http_request(bootstrap.node.my_con(), 1, b'MALFORMED_DATA')
             self.fail("Should throw error for malformed data")
         except Exception as e:
             print(e)
@@ -352,20 +352,26 @@ class TestNode(unittest.TestCase):
         connector = spawn_node("connector", [bootstrap.node.my_con().to_json()])
         self.assertIn('connector', bootstrap.node.peers())
 
-    def test_custom_socket(self):
-        """Test that a custom socket can be provided"""
-        # Create a custom UDP socket
-        custom_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        custom_sock.bind(("0.0.0.0", 9000))
-        
-        # Start node with custom socket
-        n = spawn_node("custom-socket-node", sock=custom_sock)
+    def test_http_endpoints(self):
+        """Test that HTTP endpoints are accessible"""
+        n = spawn_node("http-test-node")
         
-        # Verify the node is using the custom socket
-        self.assertEqual(n.socket, custom_sock)
+        # Test that all endpoints exist
+        endpoints = ['/hello', '/peers', '/update', '/ping']
         
-        # Clean up
-        n.stop()
+        for endpoint in endpoints:
+            # Send a request to each endpoint (will fail due to encryption, but should return 400/500, not 404)
+            try:
+                response = requests.post(
+                    f'http://127.0.0.1:{n.config.port}{endpoint}',
+                    data=b'test',
+                    timeout=2
+                )
+                # Should not be 404 (Not Found)
+                self.assertNotEqual(response.status_code, 404, f"Endpoint {endpoint} not found")
+                print(f"Endpoint {endpoint} exists (status: {response.status_code})")
+            except Exception as e:
+                print(f"Endpoint {endpoint} test failed: {e}")
 
 if __name__ == "__main__":
     unittest.main()

{distributed_state_network-0.2.1 → distributed_state_network-0.4.0}/tests/connections.py

@@ -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), None, disconnect_cb, update_cb)
+    return DSNodeServer.start(DSNodeConfig(**args), disconnect_cb, update_cb)
 
 class ConnectionsTest(unittest.TestCase):
     def test_one(self):

distributed_state_network-0.2.1/documentation/ds-node-server.md

@@ -1,58 +0,0 @@
-## DSNodeServer
-
-HTTPS server wrapper for DSNode that handles incoming network requests.
-
-```python
-from distributed_state_network import DSNodeServer
-```
-
-### Class Definition
-```python
-class DSNodeServer(HTTPServer):
-    config: DSNodeConfig
-    node: DSNode
-```
-
-### Constructor
-
-**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, update_callback: Optional[Callable] = None) -> DSNodeServer`
-Creates and starts a new DSNodeServer instance with SSL configuration.
-```python
-server = DSNodeServer.start(config)
-```
-
-**Parameters:**
-- `config` (`DSNodeConfig`): Node configuration
-- `disconnect_callback` (`Optional[Callable]`): Callback for disconnect events (no parameters)
-- `update_callback` (`Optional[Callable]`): Callback for state update events (no parameters)
-
-**Returns:**
-- `DSNodeServer`: Running server instance
-
-### `generate_key(out_file_path: str) -> None`
-Generates a new AES key file for network encryption.
-
-**Parameters:**
-- `out_file_path` (`str`): Path where the key file will be saved
-
-**Example:**
-```python
-DSNodeServer.generate_key("/path/to/network.key")
-```
-
-### Instance Methods
-
-### `stop() -> None`
-Gracefully shuts down the server and cleans up resources.
-
-**Example:**
-```python
-server.stop()
-```

distributed_state_network-0.2.1/documentation/protocol.md

@@ -1,65 +0,0 @@
-## Network Protocol
-
-### Transport Layer
-The network now uses **UDP (User Datagram Protocol)** for all communication instead of HTTP/HTTPS. This provides:
-- Lower latency for peer-to-peer communication
-- Reduced overhead compared to HTTP
-- Simpler connection management
-- More suitable for real-time distributed systems
-
-### Message Types
-All UDP packets use a message type byte prefix to identify the packet type:
-
-- **Type 1 (HELLO)**: Exchange node information and credentials
-- **Type 2 (PEERS)**: Request/share peer list
-- **Type 3 (UPDATE)**: Send/receive state updates
-- **Type 4 (PING)**: Connectivity check
-
-### Packet Structure
-Each UDP packet follows this structure:
-1. **AES Encrypted Payload** containing:
-   - Message type (1 byte)
-   - Message payload (variable length)
-
-### Security
-- All communication is encrypted using AES with a shared key
-- Messages are signed using ECDSA for authentication
-- UDP packets are encrypted end-to-end
-- HTTPS/TLS is not supported with UDP (certificates are no longer used)
-
-### State Synchronization
-- Nodes maintain a copy of all peers' states
-- Updates are broadcast to all connected peers
-- Timestamps prevent older updates from overwriting newer ones
-
-### Socket Management
-- You can provide a custom UDP socket when starting a server
-- If no socket is provided, one will be created and bound automatically
-- Socket timeout is set to 2 seconds for requests
-- Maximum UDP packet size is 65507 bytes
-
-## Important Notes
-
-1. **Shared AES Key**: All nodes in the network must use the same AES key file
-2. **Unique Node IDs**: Each node must have a unique node_id
-3. **Port Availability**: Ensure the specified UDP port is available before starting
-4. **Bootstrap Nodes**: At least one bootstrap node is required to join an existing network
-5. **Network Tick**: The network performs maintenance checks every 3 seconds
-6. **Credential Management**: ECDSA keys are automatically generated and stored in `credentials/` directory
-7. **UDP Reliability**: The protocol implements retry logic (up to 3 attempts) for failed requests
-8. **HTTPS Not Supported**: The `https` configuration option is ignored when using UDP
-
-## Error Handling
-
-Common error codes (embedded in exception messages):
-- **401**: Not Authorized (signature verification failed)
-- **406**: Not Acceptable (invalid data, stale update, or version mismatch)
-- **505**: Version not supported
-
-## Migration from HTTP
-
-If you're migrating from the HTTP-based version:
-1. Remove any HTTPS certificate dependencies
-2. Update firewall rules to allow UDP traffic on your ports
-3. The API remains largely the same, but transport is now UDP
-4. The `https` flag in configuration is now ignored

distributed_state_network-0.2.1/src/distributed_state_network/handler.py

@@ -1,144 +0,0 @@
-import socket
-import threading
-import logging
-from typing import Callable, Optional
-from distributed_state_network.dsnode import DSNode
-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.2.1"
-logging.basicConfig(level=logging.INFO)
-
-# Message type constants
-MSG_HELLO = 1
-MSG_PEERS = 2
-MSG_UPDATE = 3
-MSG_PING = 4
-
-class DSNodeServer:
-    def __init__(
-        self, 
-        config: DSNodeConfig,
-        sock: Optional[socket.socket] = None,
-        disconnect_callback: Optional[Callable] = None,
-        update_callback: Optional[Callable] = None
-    ):
-        self.config = config
-        self.running = True
-        
-        # Use provided socket or create new one
-        if sock is not None:
-            self.socket = sock
-        else:
-            self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            self.socket.bind(("0.0.0.0", config.port))
-        
-        # Create DSNode with the socket
-        self.node = DSNode(config, VERSION, self.socket, disconnect_callback, update_callback)
-        self.node.logger.info(f'Started DSNode on UDP port {config.port}')
-
-    def stop(self):
-        self.node.shutting_down = True
-        self.running = False
-        try:
-            self.socket.close()
-        except:
-            pass
-        stop_thread(self.thread)
-
-    def handle_packet(self, data: bytes, addr: tuple):
-        """Handle incoming UDP packet - either a request or a response"""
-        try:
-            # Decrypt the data
-            decrypted = self.node.decrypt_data(data)
-            
-            if len(decrypted) == 0:
-                return
-            
-            # First byte is message type
-            msg_type = decrypted[0]
-            body = decrypted[1:]
-            
-            # Check if this is a response to a pending request
-            request_id = (addr[0], addr[1], msg_type)
-            with self.node.response_lock:
-                is_response = request_id in self.node.pending_responses
-            
-            if is_response:
-                # This is a response to our request - route to response handler
-                self.node.handle_response(data, addr)
-            else:
-                # This is a new request - handle it
-                response = None
-                
-                if msg_type == MSG_HELLO:
-                    # Pass the detected IP address to handle_hello
-                    response = self.node.handle_hello(body, addr[0])
-                    
-                elif msg_type == MSG_PEERS:
-                    response = self.node.handle_peers(body)
-                    
-                elif msg_type == MSG_UPDATE:
-                    response = self.node.handle_update(body)
-                    
-                elif msg_type == MSG_PING:
-                    response = b''
-                
-                # Send response if handler returned data
-                if response is not None:
-                    # Prepend message type to response
-                    response_with_type = bytes([msg_type]) + response
-                    encrypted_response = self.node.encrypt_data(response_with_type)
-                    self.socket.sendto(encrypted_response, addr)
-                
-        except Exception as e:
-            if len(e.args) >= 2:
-                self.node.logger.error(f"Error handling packet from {addr}: {e.args[0]} {e.args[1]}")
-            else:
-                self.node.logger.error(f"Error handling packet from {addr}: {e}")
-
-    def serve_forever(self):
-        """Main UDP server loop"""
-        while self.running:
-            try:
-                # Receive UDP packet (max 65507 bytes for UDP)
-                data, addr = self.socket.recvfrom(65507)
-                if self.running:
-                    # Handle packet in separate thread to avoid blocking
-                    threading.Thread(target=self.handle_packet, args=(data, addr), daemon=True).start()
-            except OSError:
-                # Socket was closed
-                if not self.running:
-                    break
-            except Exception as e:
-                self.node.logger.error(f"Error in server loop: {e}")
-                if not self.running:
-                    break
-
-    @staticmethod
-    def generate_key(out_file_path: str):
-        key = generate_aes_key()
-        with open(out_file_path, 'wb') as f:
-            f.write(key)
-
-    @staticmethod 
-    def start(
-        config: DSNodeConfig, 
-        sock: Optional[socket.socket] = None,
-        disconnect_callback: Optional[Callable] = None, 
-        update_callback: Optional[Callable] = None
-    ) -> 'DSNodeServer':
-        n = DSNodeServer(config, sock, disconnect_callback, update_callback)
-        n.thread = threading.Thread(target=n.serve_forever, daemon=True)
-        n.thread.start()
-
-        if n.config.bootstrap_nodes is not None and len(n.config.bootstrap_nodes) > 0:
-            for bs in n.config.bootstrap_nodes:
-                try:
-                    n.node.bootstrap(bs)
-                    break # Throws exception if connection is not made
-                except Exception as e:
-                    print(e)
-
-        return n