simpledht 0.1.1__tar.gz → 0.1.2__tar.gz

{simpledht-0.1.1 → simpledht-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simpledht
-Version: 0.1.1
+Version: 0.1.2
 Summary: A simple distributed hash table implementation
 Home-page: https://github.com/dhruvldrp9/simpledht
 Author: Dhruvkumar Patel

{simpledht-0.1.1 → simpledht-0.1.2}/README.md

@@ -8,6 +8,8 @@ A Python-based Distributed Hash Table implementation that allows nodes to connec
 - Key-value storage and retrieval
 - Automatic node discovery
 - Data replication between nodes
+- Data synchronization when joining the network
+- Reliable bootstrapping with retry mechanism
 - Simple CLI interface
 - Public IP detection
 - Local network support
@@ -72,51 +74,51 @@ See the `examples/` directory for more detailed usage examples:
 
 ### Command Line Interface
 
-### Starting a Node
+#### Starting a Node
 
 To start a new DHT node:
 ```bash
-python cli.py start --host 0.0.0.0 --port 5000
+simpledht start --host 0.0.0.0 --port 5000
 ```
 
 To start a node and connect to existing nodes:
 ```bash
-python cli.py start --host 0.0.0.0 --port 5001 --bootstrap "PUBLIC_IP:5000"
+simpledht start --host 0.0.0.0 --port 5001 --bootstrap "PUBLIC_IP:5000"
 ```
 
-### Storing Data
+#### Storing Data
 
 To store a key-value pair:
 ```bash
-python cli.py put --host PUBLIC_IP --port 5000 mykey "my value"
+simpledht put --host PUBLIC_IP --port 5000 mykey "my value"
 ```
 
-### Retrieving Data
+#### Retrieving Data
 
 To retrieve a value:
 ```bash
-python cli.py get --host PUBLIC_IP --port 5000 mykey
+simpledht get --host PUBLIC_IP --port 5000 mykey
 ```
 
 ### Cross-Network Example
 
 1. Start Node 1 (First network):
 ```bash
-python cli.py start --host 0.0.0.0 --port 5000
+simpledht start --host 0.0.0.0 --port 5000
 ```
 
 2. Start Node 2 (Second network):
 ```bash
-python cli.py start --host 0.0.0.0 --port 5000 --bootstrap "NODE1_PUBLIC_IP:5000"
+simpledht start --host 0.0.0.0 --port 5000 --bootstrap "NODE1_PUBLIC_IP:5000"
 ```
 
 3. Store and retrieve data:
 ```bash
 # Store on Node 1
-python cli.py put --host NODE1_PUBLIC_IP --port 5000 test_key "test_value"
+simpledht put --host NODE1_PUBLIC_IP --port 5000 test_key "test_value"
 
 # Retrieve from Node 2
-python cli.py get --host NODE2_PUBLIC_IP --port 5000 test_key
+simpledht get --host NODE2_PUBLIC_IP --port 5000 test_key
 ```
 
 ## Network Configuration
@@ -140,6 +142,13 @@ If your node is behind a NAT router:
 2. Set up port forwarding for UDP port 5000
 3. Forward to your node's local IP address
 
+## New Features in Version 0.1.2
+
+- **Improved Bootstrap Mechanism**: Added retry logic for more reliable connections across networks
+- **Data Synchronization**: Nodes automatically sync data when joining the network
+- **Enhanced Error Handling**: Better handling of network timeouts and connection issues
+- **Full Data Replication**: All nodes maintain a complete copy of the data for redundancy
+
 ## Troubleshooting
 
 ### Common Issues
@@ -166,6 +175,7 @@ If your node is behind a NAT router:
 - `No response received`: Node is not responding
 - `Address already in use`: Port conflict
 - `Failed to get public IP`: Network connectivity issue
+- `Connection attempt X/3 timed out, retrying...`: Network latency or connectivity issues
 
 ## Architecture
 
@@ -175,6 +185,7 @@ The DHT implementation uses:
 - Automatic public IP detection
 - Data replication between nodes
 - Bootstrap nodes for network discovery
+- Retry mechanism for reliable connections
 
 ## Security Considerations
 

{simpledht-0.1.1 → simpledht-0.1.2}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="simpledht",
-    version="0.1.1",
+    version="0.1.2",
     author="Dhruvkumar Patel",
     author_email="dhruv.ldrp9@gmail.com",
     description="A simple distributed hash table implementation",

{simpledht-0.1.1 → simpledht-0.1.2}/simpledht/__init__.py

@@ -20,7 +20,7 @@ Example usage:
     node.bootstrap('other_node_ip:5000')
 """
 
-__version__ = "0.1.1"
+__version__ = "0.1.2"
 
 from .dht_node import DHTNode
 from .cli import main as cli_main

{simpledht-0.1.1 → simpledht-0.1.2}/simpledht/cli.py

@@ -1,5 +1,5 @@
 import click
-from dht_node import DHTNode
+from .dht_node import DHTNode
 import json
 import time
 import socket
@@ -12,19 +12,35 @@ def cli():
 
 @cli.command()
 @click.option('--host', default='0.0.0.0', help='Host to bind to')
-@click.option('--port', default=5000, help='Port to bind to')
+@click.option('--port', default=5000, type=int, help='Port to bind to')
 @click.option('--bootstrap', help='Comma-separated list of bootstrap nodes (host:port)')
 def start(host, port, bootstrap):
     """Start a new DHT node."""
     bootstrap_nodes = bootstrap.split(',') if bootstrap else []
-    node = DHTNode(host, port, bootstrap_nodes)
-    node.start()
     
     try:
-        while True:
-            pass
-    except KeyboardInterrupt:
-        node.stop()
+        node = DHTNode(host, port, bootstrap_nodes)
+        node.start()
+        
+        click.echo(f"Node started successfully on {host}:{port}")
+        click.echo(f"Public IP: {node.public_ip}")
+        click.echo(f"Node ID: {node.id}")
+        
+        if bootstrap_nodes:
+            click.echo(f"Connected to bootstrap nodes: {', '.join(bootstrap_nodes)}")
+        
+        click.echo("Press Ctrl+C to stop the node...")
+        
+        try:
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            click.echo("Stopping node...")
+            node.stop()
+            click.echo("Node stopped.")
+    except Exception as e:
+        click.echo(f"Error starting node: {e}")
+        sys.exit(1)
 
 def _send_message(host: str, port: int, message: dict, timeout: int = 5) -> dict:
     """Send a message to a DHT node and wait for response."""
@@ -34,7 +50,7 @@ def _send_message(host: str, port: int, message: dict, timeout: int = 5) -> dict
         sock.settimeout(timeout)
         
         # Send message
-        click.echo(f"Sending message to {host}:{port}...")
+        click.echo(f"Connecting to node at {host}:{port}...")
         sock.sendto(json.dumps(message).encode(), (host, port))
         
         # Wait for response
@@ -70,8 +86,10 @@ def put(host, port, timeout, key, value):
     
     if response.get('type') == 'store_ack':
         click.echo(f"Successfully stored {key}={value}")
+        click.echo("Value has been replicated to all nodes in the network")
     else:
         click.echo(f"Failed to store {key}={value}")
+        click.echo(f"Response: {response}")
 
 @cli.command()
 @click.option('--host', required=True, help='Host of the DHT node')
@@ -93,6 +111,32 @@ def get(host, port, timeout, key):
             click.echo(f"Value for {key}: {value}")
     else:
         click.echo(f"Failed to retrieve value for key: {key}")
+        click.echo(f"Response: {response}")
+
+@cli.command()
+@click.option('--host', required=True, help='Host of the DHT node')
+@click.option('--port', required=True, type=int, help='Port of the DHT node')
+@click.option('--timeout', default=5, help='Timeout in seconds')
+def info(host, port, timeout):
+    """Get information about a DHT node."""
+    response = _send_message(host, port, {
+        'type': 'info_request'
+    }, timeout)
+    
+    if response.get('type') == 'info_response':
+        node_id = response.get('node_id', 'Unknown')
+        peer_count = response.get('peer_count', 0)
+        data_count = response.get('data_count', 0)
+        
+        click.echo(f"Node ID: {node_id}")
+        click.echo(f"Connected peers: {peer_count}")
+        click.echo(f"Stored key-value pairs: {data_count}")
+    else:
+        click.echo("Failed to get node information")
+
+def main():
+    """Entry point for the CLI."""
+    cli()
 
 if __name__ == '__main__':
-    cli() 
+    main() 

{simpledht-0.1.1 → simpledht-0.1.2}/simpledht/dht_node.py

@@ -128,6 +128,24 @@ class DHTNode:
             # Update our routing table with the received nodes
             received_table = message.get('routing_table', {})
             self.routing_table.update(received_table)
+        elif msg_type == 'sync_request':
+            # Send our data to the requesting node
+            self._send_response(addr, {
+                'type': 'sync_response',
+                'data': self.data
+            })
+        elif msg_type == 'sync_response':
+            # Update our data with the received data
+            received_data = message.get('data', {})
+            self.data.update(received_data)
+        elif msg_type == 'info_request':
+            # Send information about this node
+            self._send_response(addr, {
+                'type': 'info_response',
+                'node_id': self.id,
+                'peer_count': len(self.routing_table) - 1,  # Exclude self
+                'data_count': len(self.data)
+            })
 
     def _replicate_data(self, key: str, value: str):
         """Replicate data to other nodes in the network."""
@@ -164,11 +182,31 @@ class DHTNode:
             'value': None
         })
 
-    def _send_message_with_response(self, addr: Tuple[str, int], message: dict) -> dict:
-        """Send a message and wait for response."""
+    def _send_message_with_response(self, addr: Tuple[str, int], message: dict, timeout: int = 5) -> dict:
+        """Send a message and wait for response.
+        
+        Args:
+            addr: The address to send the message to
+            message: The message to send
+            timeout: The timeout in seconds
+            
+        Returns:
+            The response message
+        """
         self._send_message(addr, message)
-        data, _ = self.socket.recvfrom(4096)
-        return json.loads(data.decode())
+        
+        # Set timeout for receiving response
+        self.socket.settimeout(timeout)
+        try:
+            data, _ = self.socket.recvfrom(4096)
+            # Reset timeout to None (blocking mode)
+            self.socket.settimeout(None)
+            return json.loads(data.decode())
+        except socket.timeout:
+            raise
+        finally:
+            # Make sure we reset the timeout even if an exception occurs
+            self.socket.settimeout(None)
 
     def _send_response(self, addr: Tuple[str, int], response: dict):
         """Send a response to a node."""
@@ -208,4 +246,131 @@ class DHTNode:
     def stop(self):
         """Stop the DHT node."""
         self.running = False
-        self.socket.close() 
+        self.socket.close()
+        
+    def put(self, key: str, value: str) -> bool:
+        """Store a key-value pair in the DHT.
+        
+        Args:
+            key: The key to store
+            value: The value to store
+            
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        # Store locally
+        self.data[key] = value
+        
+        # Replicate to other nodes
+        self._replicate_data(key, value)
+        
+        return True
+        
+    def get(self, key: str) -> Optional[str]:
+        """Retrieve a value from the DHT.
+        
+        Args:
+            key: The key to retrieve
+            
+        Returns:
+            The value if found, None otherwise
+        """
+        # Check if we have it locally
+        if key in self.data:
+            return self.data[key]
+            
+        # If not, ask other nodes
+        for node_id, (host, port) in self.routing_table.items():
+            if node_id != self.id:  # Don't ask self
+                try:
+                    response = self._send_message_with_response((host, port), {
+                        'type': 'get',
+                        'key': key
+                    })
+                    
+                    if response.get('type') == 'get_response' and response.get('value') is not None:
+                        return response.get('value')
+                except Exception as e:
+                    print(f"Failed to get value from {host}:{port}: {e}")
+                    
+        # Not found anywhere
+        return None
+        
+    def bootstrap(self, node_address: str):
+        """Connect to another node to join the network.
+        
+        Args:
+            node_address: The address of the node to connect to in the format 'host:port'
+            
+        Returns:
+            bool: True if successfully connected, False otherwise
+        """
+        try:
+            parts = node_address.split(':')
+            if len(parts) != 2:
+                print(f"Invalid bootstrap node format: {node_address}. Expected format: IP:PORT")
+                return False
+                
+            host, port = parts
+            try:
+                port = int(port)
+            except ValueError:
+                print(f"Invalid port number in bootstrap node: {node_address}")
+                return False
+                
+            print(f"Bootstrapping with node {host}:{port}")
+            
+            # Try multiple times in case of network issues
+            max_attempts = 3
+            for attempt in range(max_attempts):
+                try:
+                    response = self._send_message_with_response((host, port), {
+                        'type': 'join',
+                        'node_id': self.id,
+                        'host': self.public_ip,
+                        'port': self.port
+                    }, timeout=5)
+                    
+                    if response.get('type') == 'join_ack':
+                        received_table = response.get('routing_table', {})
+                        self.routing_table.update(received_table)
+                        print(f"Successfully connected to {host}:{port}")
+                        
+                        # Sync data with the network
+                        self._sync_data_with_network()
+                        return True
+                    break
+                except socket.timeout:
+                    print(f"Connection attempt {attempt+1}/{max_attempts} timed out, retrying...")
+                    if attempt == max_attempts - 1:
+                        print(f"Failed to connect to {host}:{port} after {max_attempts} attempts")
+                        return False
+                except Exception as e:
+                    print(f"Error during connection attempt {attempt+1}: {e}")
+                    break
+        except Exception as e:
+            print(f"Failed to bootstrap with {node_address}: {e}")
+            
+        return False
+        
+    def _sync_data_with_network(self):
+        """Sync data with other nodes in the network after joining."""
+        if not self.routing_table:
+            return
+            
+        # Request data from a random node in the routing table
+        for node_id, (host, port) in self.routing_table.items():
+            if node_id != self.id:  # Don't ask self
+                try:
+                    response = self._send_message_with_response((host, port), {
+                        'type': 'sync_request'
+                    })
+                    
+                    if response.get('type') == 'sync_response':
+                        # Update our data with the received data
+                        received_data = response.get('data', {})
+                        self.data.update(received_data)
+                        print(f"Synced {len(received_data)} key-value pairs from the network")
+                        return
+                except Exception as e:
+                    print(f"Failed to sync data from {host}:{port}: {e}") 

{simpledht-0.1.1 → simpledht-0.1.2}/simpledht.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simpledht
-Version: 0.1.1
+Version: 0.1.2
 Summary: A simple distributed hash table implementation
 Home-page: https://github.com/dhruvldrp9/simpledht
 Author: Dhruvkumar Patel