simpledht 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

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/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/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.dist-info → simpledht-0.1.2.dist-info}/METADATA

@@ -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.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+simpledht/__init__.py,sha256=UMGuX6JHuDsQG_JuvBv4Q5JT2Yq9zzPwTuqgRdHJVow,546
+simpledht/cli.py,sha256=9QgsyZv1-SKwblj2hYLsGKRjiCyBFjlGalafdqhoXrk,4877
+simpledht/dht_node.py,sha256=58fd7Yq8gPLVbHaaJMW-9gnrC2YjPMF0EtD3I81EI6Q,14864
+simpledht/test_dht.py,sha256=tsWGhtLkTArFJIdkaWManekhFx2KCUO0Gp93EGBUAlw,2346
+simpledht-0.1.2.dist-info/licenses/LICENSE,sha256=MrSAzCY_7J3C4Hp8PaXaaFJP2ygfmuAWoLTVowEE3B0,1073
+simpledht-0.1.2.dist-info/METADATA,sha256=n9kVjGyjUno8VTeN5IgM2isJO2UVBxfsm_p51ckxy98,779
+simpledht-0.1.2.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+simpledht-0.1.2.dist-info/entry_points.txt,sha256=Hm3BYz1MykAhg94m3JSYsMcdEQEia3bdRocokc-0wxs,49
+simpledht-0.1.2.dist-info/top_level.txt,sha256=VjRxeoXfQJeoPoFhr5JGGMAI5NSLkYJl0WbySmpZ4bs,10
+simpledht-0.1.2.dist-info/RECORD,,

{simpledht-0.1.1.dist-info → simpledht-0.1.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.1.0)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

simpledht-0.1.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-simpledht/__init__.py,sha256=g6zuNY67roLXDgvxl7JXEXbY23tVWDvWL4FQE3v1vdk,546
-simpledht/cli.py,sha256=5KrXFqxHAHuU9RleB1FPRyI2YZwKwaJijXH-DAmZV5k,3225
-simpledht/dht_node.py,sha256=FZHLigu7NLkJ9smWyJyLK2FBFu2kKy9kxr9Mig6yh0M,8481
-simpledht/test_dht.py,sha256=tsWGhtLkTArFJIdkaWManekhFx2KCUO0Gp93EGBUAlw,2346
-simpledht-0.1.1.dist-info/licenses/LICENSE,sha256=MrSAzCY_7J3C4Hp8PaXaaFJP2ygfmuAWoLTVowEE3B0,1073
-simpledht-0.1.1.dist-info/METADATA,sha256=iTVFk2v6EjXM0RhR1Mis2-6iIT9ZFl1aCmkTLkKD4jM,779
-simpledht-0.1.1.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-simpledht-0.1.1.dist-info/entry_points.txt,sha256=Hm3BYz1MykAhg94m3JSYsMcdEQEia3bdRocokc-0wxs,49
-simpledht-0.1.1.dist-info/top_level.txt,sha256=VjRxeoXfQJeoPoFhr5JGGMAI5NSLkYJl0WbySmpZ4bs,10
-simpledht-0.1.1.dist-info/RECORD,,