simpledht 0.1.1__py3-none-any.whl → 0.1.3__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.3"
 
 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.3.dist-info/METADATA

@@ -0,0 +1,235 @@
+Metadata-Version: 2.4
+Name: simpledht
+Version: 0.1.3
+Summary: A simple distributed hash table implementation
+Home-page: https://github.com/dhruvldrp9/simpledht
+Author: Dhruvkumar Patel
+Author-email: dhruv.ldrp9@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.1
+Requires-Dist: click>=8.0.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Distributed Hash Table (DHT) Implementation
+
+A Python-based Distributed Hash Table implementation that allows nodes to connect across different networks using IP addresses. This implementation supports key-value storage and retrieval across multiple nodes.
+
+## Features
+
+- Cross-network node communication
+- 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
+- Python library interface for programmatic use
+
+## Installation
+
+### From PyPI (Recommended)
+
+```bash
+pip install simpledht
+```
+
+### From Source
+
+1. Clone the repository:
+```bash
+git clone <repository-url>
+cd SimpleDHT
+```
+
+2. Create and activate a virtual environment:
+```bash
+python -m venv env
+source env/bin/activate  # On Windows: env\Scripts\activate
+```
+
+3. Install the package in development mode:
+```bash
+pip install -e .
+```
+
+## Usage
+
+### As a Python Library
+
+The package can be used programmatically in your Python code:
+
+```python
+from simpledht import DHTNode
+
+# Create and start a node
+node = DHTNode(host='0.0.0.0', port=5000)
+node.start()
+
+# Store data
+node.put('mykey', 'myvalue')
+
+# Retrieve data
+value = node.get('mykey')
+
+# Connect to another node
+node.bootstrap('other_node_ip:5000')
+
+# Stop the node when done
+node.stop()
+```
+
+See the `examples/` directory for more detailed usage examples:
+- `basic_usage.py`: Simple example of creating and connecting nodes
+- `distributed_storage.py`: Advanced example showing distributed storage with multiple nodes
+
+### Command Line Interface
+
+#### Starting a Node
+
+To start a new DHT node:
+```bash
+simpledht start --host 0.0.0.0 --port 5000
+```
+
+To start a node and connect to existing nodes:
+```bash
+simpledht start --host 0.0.0.0 --port 5001 --bootstrap "PUBLIC_IP:5000"
+```
+
+#### Storing Data
+
+To store a key-value pair:
+```bash
+simpledht put --host PUBLIC_IP --port 5000 mykey "my value"
+```
+
+#### Retrieving Data
+
+To retrieve a value:
+```bash
+simpledht get --host PUBLIC_IP --port 5000 mykey
+```
+
+### Cross-Network Example
+
+1. Start Node 1 (First network):
+```bash
+simpledht start --host 0.0.0.0 --port 5000
+```
+
+2. Start Node 2 (Second network):
+```bash
+simpledht start --host 0.0.0.0 --port 5000 --bootstrap "NODE1_PUBLIC_IP:5000"
+```
+
+3. Store and retrieve data:
+```bash
+# Store on Node 1
+simpledht put --host NODE1_PUBLIC_IP --port 5000 test_key "test_value"
+
+# Retrieve from Node 2
+simpledht get --host NODE2_PUBLIC_IP --port 5000 test_key
+```
+
+## Network Configuration
+
+### Firewall Setup
+
+Ensure the UDP port (default: 5000) is open in your firewall:
+
+```bash
+# For UFW (Ubuntu)
+sudo ufw allow 5000/udp
+
+# For iptables
+sudo iptables -A INPUT -p udp --dport 5000 -j ACCEPT
+```
+
+### Port Forwarding
+
+If your node is behind a NAT router:
+1. Access your router's admin interface
+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
+
+1. **Connection Timeout**
+   - Check if the target node is running
+   - Verify firewall settings
+   - Ensure port forwarding is configured correctly
+   - Try increasing the timeout: `--timeout 10`
+
+2. **Address Already in Use**
+   - The port is already being used by another process
+   - Try a different port number
+   - Check running processes: `netstat -tuln | grep 5000`
+
+3. **No Response from Node**
+   - Verify the node is running
+   - Check network connectivity: `ping NODE_IP`
+   - Test port connectivity: `nc -vzu NODE_IP 5000`
+
+### Error Messages
+
+- `Failed to bootstrap with IP:PORT`: Invalid bootstrap node format
+- `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
+
+The DHT implementation uses:
+- UDP sockets for communication
+- SHA-256 for node ID generation
+- Automatic public IP detection
+- Data replication between nodes
+- Bootstrap nodes for network discovery
+- Retry mechanism for reliable connections
+
+## Security Considerations
+
+- This is a basic implementation and should not be used in production without additional security measures
+- Consider adding:
+  - Encryption for data in transit
+  - Authentication for node joining
+  - Rate limiting to prevent abuse
+  - Input validation
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

simpledht-0.1.3.dist-info/RECORD

@@ -0,0 +1,10 @@
+simpledht/__init__.py,sha256=j0WY2O6SGOuBS3CVdz_u-9R-fIoR6ArZ3XfP2qIrWMc,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.3.dist-info/licenses/LICENSE,sha256=MrSAzCY_7J3C4Hp8PaXaaFJP2ygfmuAWoLTVowEE3B0,1073
+simpledht-0.1.3.dist-info/METADATA,sha256=cnSOqwQOc4hZAT7w2QGolEvcz0Op_3PLHELYhKYIIfI,5809
+simpledht-0.1.3.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+simpledht-0.1.3.dist-info/entry_points.txt,sha256=Hm3BYz1MykAhg94m3JSYsMcdEQEia3bdRocokc-0wxs,49
+simpledht-0.1.3.dist-info/top_level.txt,sha256=VjRxeoXfQJeoPoFhr5JGGMAI5NSLkYJl0WbySmpZ4bs,10
+simpledht-0.1.3.dist-info/RECORD,,

{simpledht-0.1.1.dist-info → simpledht-0.1.3.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/METADATA

@@ -1,27 +0,0 @@
-Metadata-Version: 2.4
-Name: simpledht
-Version: 0.1.1
-Summary: A simple distributed hash table implementation
-Home-page: https://github.com/dhruvldrp9/simpledht
-Author: Dhruvkumar Patel
-Author-email: dhruv.ldrp9@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests>=2.25.1
-Requires-Dist: click>=8.0.1
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-A simple distributed hash table implementation

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,,