simpledht 0.1.0__tar.gz → 0.1.2__tar.gz

simpledht-0.1.2/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: simpledht
+Version: 0.1.2
+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.0/simpledht.egg-info/PKG-INFO → simpledht-0.1.2/README.md

@@ -1,29 +1,3 @@
-Metadata-Version: 2.4
-Name: simpledht
-Version: 0.1.0
-Summary: A simple distributed hash table implementation
-Home-page: https://github.com/yourusername/simpledht
-Author: Your Name
-Author-email: your.email@example.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.
@@ -34,9 +8,12 @@ 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
+- Python library interface for programmatic use
 
 ## Installation
 
@@ -67,51 +44,81 @@ pip install -e .
 
 ## Usage
 
-### Starting a Node
+### 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
-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
@@ -135,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
@@ -161,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
 
@@ -170,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.0 → simpledht-0.1.2}/setup.py

@@ -5,13 +5,13 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="simpledht",
-    version="0.1.0",
-    author="Your Name",
-    author_email="your.email@example.com",
+    version="0.1.2",
+    author="Dhruvkumar Patel",
+    author_email="dhruv.ldrp9@gmail.com",
     description="A simple distributed hash table implementation",
-    long_description=long_description,
+    long_description="A simple distributed hash table implementation",
     long_description_content_type="text/markdown",
-    url="https://github.com/yourusername/simpledht",
+    url="https://github.com/dhruvldrp9/simpledht",
     packages=find_packages(),
     classifiers=[
         "Programming Language :: Python :: 3",

simpledht-0.1.2/simpledht/__init__.py

@@ -0,0 +1,28 @@
+"""
+SimpleDHT - A simple distributed hash table implementation
+
+Example usage:
+    from simpledht import DHTNode
+
+    # Create a new node
+    node = DHTNode(host='0.0.0.0', port=5000)
+    
+    # Start the node
+    node.start()
+    
+    # Store a value
+    node.put('mykey', 'myvalue')
+    
+    # Retrieve a value
+    value = node.get('mykey')
+    
+    # Connect to another node
+    node.bootstrap('other_node_ip:5000')
+"""
+
+__version__ = "0.1.2"
+
+from .dht_node import DHTNode
+from .cli import main as cli_main
+
+__all__ = ["DHTNode", "cli_main"] 

{simpledht-0.1.0 → 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.0 → 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.2/simpledht.egg-info/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: simpledht
+Version: 0.1.2
+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.0/PKG-INFO

@@ -1,193 +0,0 @@
-Metadata-Version: 2.4
-Name: simpledht
-Version: 0.1.0
-Summary: A simple distributed hash table implementation
-Home-page: https://github.com/yourusername/simpledht
-Author: Your Name
-Author-email: your.email@example.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
-- Simple CLI interface
-- Public IP detection
-- Local network support
-
-## 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
-
-### Starting a Node
-
-To start a new DHT node:
-```bash
-python cli.py 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"
-```
-
-### Storing Data
-
-To store a key-value pair:
-```bash
-python cli.py put --host PUBLIC_IP --port 5000 mykey "my value"
-```
-
-### Retrieving Data
-
-To retrieve a value:
-```bash
-python cli.py 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
-```
-
-2. Start Node 2 (Second network):
-```bash
-python cli.py 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"
-
-# Retrieve from Node 2
-python cli.py 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
-
-## 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
-
-## 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
-
-## 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.0/README.md

@@ -1,167 +0,0 @@
-# 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
-- Simple CLI interface
-- Public IP detection
-- Local network support
-
-## 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
-
-### Starting a Node
-
-To start a new DHT node:
-```bash
-python cli.py 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"
-```
-
-### Storing Data
-
-To store a key-value pair:
-```bash
-python cli.py put --host PUBLIC_IP --port 5000 mykey "my value"
-```
-
-### Retrieving Data
-
-To retrieve a value:
-```bash
-python cli.py 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
-```
-
-2. Start Node 2 (Second network):
-```bash
-python cli.py 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"
-
-# Retrieve from Node 2
-python cli.py 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
-
-## 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
-
-## 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
-
-## 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.0/simpledht/__init__.py

@@ -1,10 +0,0 @@
-"""
-SimpleDHT - A simple distributed hash table implementation
-"""
-
-__version__ = "0.1.0"
-
-from .dht_node import DHTNode
-from .cli import main
-
-__all__ = ["DHTNode", "main"]