simpledht 0.1.0__py3-none-any.whl

simpledht/__init__.py

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

simpledht/cli.py

@@ -0,0 +1,98 @@
+import click
+from dht_node import DHTNode
+import json
+import time
+import socket
+import sys
+
+@click.group()
+def cli():
+    """Simple DHT CLI interface."""
+    pass
+
+@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('--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()
+
+def _send_message(host: str, port: int, message: dict, timeout: int = 5) -> dict:
+    """Send a message to a DHT node and wait for response."""
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        # Set timeout before sending
+        sock.settimeout(timeout)
+        
+        # Send message
+        click.echo(f"Sending message to {host}:{port}...")
+        sock.sendto(json.dumps(message).encode(), (host, port))
+        
+        # Wait for response
+        try:
+            data, _ = sock.recvfrom(4096)
+            return json.loads(data.decode())
+        except socket.timeout:
+            click.echo(f"Error: No response received from {host}:{port} within {timeout} seconds")
+            click.echo("Possible reasons:")
+            click.echo("1. The node is not running")
+            click.echo("2. The port is blocked by a firewall")
+            click.echo("3. The node is behind NAT without port forwarding")
+            sys.exit(1)
+    except Exception as e:
+        click.echo(f"Error sending message: {e}")
+        sys.exit(1)
+    finally:
+        sock.close()
+
+@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')
+@click.argument('key')
+@click.argument('value')
+def put(host, port, timeout, key, value):
+    """Store a key-value pair in the DHT."""
+    response = _send_message(host, port, {
+        'type': 'store',
+        'key': key,
+        'value': value
+    }, timeout)
+    
+    if response.get('type') == 'store_ack':
+        click.echo(f"Successfully stored {key}={value}")
+    else:
+        click.echo(f"Failed to store {key}={value}")
+
+@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')
+@click.argument('key')
+def get(host, port, timeout, key):
+    """Retrieve a value from the DHT."""
+    response = _send_message(host, port, {
+        'type': 'get',
+        'key': key
+    }, timeout)
+    
+    if response.get('type') == 'get_response':
+        value = response.get('value')
+        if value is None:
+            click.echo(f"No value found for key: {key}")
+        else:
+            click.echo(f"Value for {key}: {value}")
+    else:
+        click.echo(f"Failed to retrieve value for key: {key}")
+
+if __name__ == '__main__':
+    cli() 

simpledht/dht_node.py

@@ -0,0 +1,211 @@
+import socket
+import threading
+import json
+import hashlib
+from typing import Dict, Optional, Tuple
+import requests
+from datetime import datetime
+import netifaces
+
+class DHTNode:
+    def __init__(self, host: str, port: int, bootstrap_nodes: list = None):
+        self.host = host
+        self.port = port
+        self.id = self._generate_node_id(host, port)
+        self.data: Dict[str, str] = {}
+        self.routing_table: Dict[str, Tuple[str, int]] = {}
+        self.bootstrap_nodes = bootstrap_nodes or []
+        self.running = False
+        
+        # Create socket with proper options for cross-network communication
+        self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        
+        # Bind to all interfaces if host is 0.0.0.0
+        if host == '0.0.0.0':
+            self.socket.bind(('0.0.0.0', port))
+            # Get actual IP address
+            self.public_ip = self._get_public_ip()
+            self.local_ips = self._get_local_ips()
+        else:
+            self.socket.bind((host, port))
+            self.public_ip = host
+            self.local_ips = [host]
+        
+        # Add self to routing table
+        self.routing_table[self.id] = (self.public_ip, port)
+        print(f"Node initialized with public IP: {self.public_ip}")
+
+    def _get_public_ip(self) -> str:
+        """Get the public IP address of this node."""
+        try:
+            response = requests.get('https://api.ipify.org?format=json', timeout=5)
+            return response.json()['ip']
+        except Exception as e:
+            print(f"Failed to get public IP: {e}")
+            return '0.0.0.0'
+
+    def _get_local_ips(self) -> list:
+        """Get all local IP addresses of this node."""
+        ips = []
+        for interface in netifaces.interfaces():
+            try:
+                addrs = netifaces.ifaddresses(interface)
+                if netifaces.AF_INET in addrs:
+                    for addr in addrs[netifaces.AF_INET]:
+                        if 'addr' in addr:
+                            ips.append(addr['addr'])
+            except Exception as e:
+                print(f"Failed to get IP for interface {interface}: {e}")
+        return ips
+
+    def _generate_node_id(self, host: str, port: int) -> str:
+        """Generate a unique node ID based on host and port."""
+        return hashlib.sha256(f"{host}:{port}".encode()).hexdigest()[:16]
+
+    def start(self):
+        """Start the DHT node."""
+        self.running = True
+        print(f"Starting DHT node {self.id} on {self.public_ip}:{self.port}")
+        print(f"Local IPs: {', '.join(self.local_ips)}")
+        
+        # Start listening for messages
+        listen_thread = threading.Thread(target=self._listen)
+        listen_thread.start()
+
+        # Bootstrap with other nodes if available
+        if self.bootstrap_nodes:
+            self._bootstrap()
+
+    def _listen(self):
+        """Listen for incoming messages."""
+        while self.running:
+            try:
+                data, addr = self.socket.recvfrom(4096)
+                message = json.loads(data.decode())
+                self._handle_message(message, addr)
+            except Exception as e:
+                print(f"Error handling message: {e}")
+
+    def _handle_message(self, message: dict, addr: Tuple[str, int]):
+        """Handle incoming messages."""
+        msg_type = message.get('type')
+        
+        if msg_type == 'ping':
+            self._send_response(addr, {'type': 'pong'})
+        elif msg_type == 'store':
+            key = message.get('key')
+            value = message.get('value')
+            if key and value:
+                self.data[key] = value
+                # Replicate to other nodes
+                self._replicate_data(key, value)
+                self._send_response(addr, {'type': 'store_ack'})
+        elif msg_type == 'get':
+            key = message.get('key')
+            if key in self.data:
+                self._send_response(addr, {
+                    'type': 'get_response',
+                    'value': self.data[key]
+                })
+            else:
+                # If not found locally, check other nodes
+                self._forward_get_request(key, addr)
+        elif msg_type == 'join':
+            # Add the joining node to our routing table
+            node_id = message.get('node_id')
+            host = message.get('host')
+            port = message.get('port')
+            if node_id and host and port:
+                self.routing_table[node_id] = (host, port)
+                # Send our routing table to the new node
+                self._send_response(addr, {
+                    'type': 'join_ack',
+                    'routing_table': self.routing_table
+                })
+        elif msg_type == 'join_ack':
+            # Update our routing table with the received nodes
+            received_table = message.get('routing_table', {})
+            self.routing_table.update(received_table)
+
+    def _replicate_data(self, key: str, value: str):
+        """Replicate data to other nodes in the network."""
+        for node_id, (host, port) in self.routing_table.items():
+            if node_id != self.id:  # Don't send to self
+                try:
+                    self._send_message((host, port), {
+                        'type': 'store',
+                        'key': key,
+                        'value': value
+                    })
+                except Exception as e:
+                    print(f"Failed to replicate to {host}:{port}: {e}")
+
+    def _forward_get_request(self, key: str, original_addr: Tuple[str, int]):
+        """Forward a get request to other nodes if not found locally."""
+        for node_id, (host, port) in self.routing_table.items():
+            if node_id != self.id:  # Don't send to 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:
+                        # Forward the response back to the original requester
+                        self._send_message(original_addr, response)
+                        return
+                except Exception as e:
+                    print(f"Failed to forward get request to {host}:{port}: {e}")
+        
+        # If no node had the value, send a negative response
+        self._send_message(original_addr, {
+            'type': 'get_response',
+            'value': None
+        })
+
+    def _send_message_with_response(self, addr: Tuple[str, int], message: dict) -> dict:
+        """Send a message and wait for response."""
+        self._send_message(addr, message)
+        data, _ = self.socket.recvfrom(4096)
+        return json.loads(data.decode())
+
+    def _send_response(self, addr: Tuple[str, int], response: dict):
+        """Send a response to a node."""
+        self.socket.sendto(json.dumps(response).encode(), addr)
+
+    def _bootstrap(self):
+        """Connect to bootstrap nodes."""
+        for node in self.bootstrap_nodes:
+            try:
+                # Split the address and handle potential errors
+                parts = node.split(':')
+                if len(parts) != 2:
+                    print(f"Invalid bootstrap node format: {node}. Expected format: IP:PORT")
+                    continue
+                
+                host, port = parts
+                try:
+                    port = int(port)
+                except ValueError:
+                    print(f"Invalid port number in bootstrap node: {node}")
+                    continue
+                
+                print(f"Attempting to bootstrap with node {host}:{port}")
+                self._send_message((host, port), {
+                    'type': 'join',
+                    'node_id': self.id,
+                    'host': self.public_ip,
+                    'port': self.port
+                })
+            except Exception as e:
+                print(f"Failed to bootstrap with {node}: {e}")
+
+    def _send_message(self, addr: Tuple[str, int], message: dict):
+        """Send a message to another node."""
+        self.socket.sendto(json.dumps(message).encode(), addr)
+
+    def stop(self):
+        """Stop the DHT node."""
+        self.running = False
+        self.socket.close() 

simpledht/test_dht.py

@@ -0,0 +1,76 @@
+import subprocess
+import time
+import click
+from dht_node import DHTNode
+import socket
+import json
+
+def start_node(host, port, bootstrap=None):
+    """Start a DHT node in a separate process."""
+    cmd = ['python', 'cli.py', 'start', '--host', host, '--port', str(port)]
+    if bootstrap:
+        cmd.extend(['--bootstrap', bootstrap])
+    return subprocess.Popen(cmd)
+
+def send_message(host, port, message):
+    """Send a message to a DHT node."""
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        sock.sendto(json.dumps(message).encode(), (host, port))
+        sock.settimeout(5.0)
+        data, _ = sock.recvfrom(4096)
+        return json.loads(data.decode())
+    finally:
+        sock.close()
+
+@click.command()
+def test():
+    """Test the DHT with multiple nodes."""
+    click.echo("Starting DHT test with 2 nodes...")
+    
+    # Start first node
+    click.echo("\nStarting Node 1 (0.0.0.0:5000)...")
+    node1 = start_node('0.0.0.0', 5000)
+    time.sleep(2)  # Wait for node to start
+    
+    # Start second node and connect to first
+    click.echo("Starting Node 2 (0.0.0.0:5001) and connecting to Node 1...")
+    node2 = start_node('0.0.0.0', 5001, '0.0.0.0:5000')
+    time.sleep(2)  # Wait for nodes to connect
+    
+    try:
+        # Store data on Node 1
+        click.echo("\nStoring data on Node 1...")
+        response = send_message('0.0.0.0', 5000, {
+            'type': 'store',
+            'key': 'test_key',
+            'value': 'test_value'
+        })
+        if response.get('type') == 'store_ack':
+            click.echo("Successfully stored data on Node 1")
+        
+        # Retrieve data from Node 2
+        click.echo("\nRetrieving data from Node 2...")
+        response = send_message('0.0.0.0', 5001, {
+            'type': 'get',
+            'key': 'test_key'
+        })
+        if response.get('type') == 'get_response':
+            value = response.get('value')
+            if value:
+                click.echo(f"Successfully retrieved value: {value}")
+            else:
+                click.echo("Failed to retrieve value")
+        
+        click.echo("\nTest completed!")
+        
+    finally:
+        # Clean up
+        click.echo("\nStopping nodes...")
+        node1.terminate()
+        node2.terminate()
+        node1.wait()
+        node2.wait()
+
+if __name__ == '__main__':
+    test() 

simpledht-0.1.0.dist-info/METADATA

@@ -0,0 +1,193 @@
+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.dist-info/RECORD

@@ -0,0 +1,10 @@
+simpledht/__init__.py,sha256=Rz_9ENT9rhI8ocZTZl_EmiHpiit8oYXiGVipRXKD2Vw,174
+simpledht/cli.py,sha256=5KrXFqxHAHuU9RleB1FPRyI2YZwKwaJijXH-DAmZV5k,3225
+simpledht/dht_node.py,sha256=FZHLigu7NLkJ9smWyJyLK2FBFu2kKy9kxr9Mig6yh0M,8481
+simpledht/test_dht.py,sha256=tsWGhtLkTArFJIdkaWManekhFx2KCUO0Gp93EGBUAlw,2346
+simpledht-0.1.0.dist-info/licenses/LICENSE,sha256=MrSAzCY_7J3C4Hp8PaXaaFJP2ygfmuAWoLTVowEE3B0,1073
+simpledht-0.1.0.dist-info/METADATA,sha256=_FnoM3ghlti3zd_zEgCS1HPmQVOfeQFaXTGfB442_7U,4503
+simpledht-0.1.0.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+simpledht-0.1.0.dist-info/entry_points.txt,sha256=Hm3BYz1MykAhg94m3JSYsMcdEQEia3bdRocokc-0wxs,49
+simpledht-0.1.0.dist-info/top_level.txt,sha256=VjRxeoXfQJeoPoFhr5JGGMAI5NSLkYJl0WbySmpZ4bs,10
+simpledht-0.1.0.dist-info/RECORD,,

simpledht-0.1.0.dist-info/WHEEL

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

simpledht-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+simpledht = simpledht.cli:main

simpledht-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dhruvkumar Patel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

simpledht-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+simpledht