swchp2pcom 0.3.0__py3-none-any.whl

swchp2pcom/__init__.py

@@ -0,0 +1,7 @@
+"""Swarmchestrate P2P Communication Library"""
+
+from .swchpeer import SwchPeer
+
+__all__ = [
+    'SwchPeer',
+]

swchp2pcom/factory.py

@@ -0,0 +1,261 @@
+import logging
+import json
+import uuid
+import time
+from typing import Optional, Dict, Any, List
+
+from twisted.internet.protocol import Factory
+from twisted.internet.task import LoopingCall
+
+from swchp2pcom.node import P2PNode
+from swchp2pcom.peers import Peers
+from swchp2pcom.message_types import SystemMessageType
+
+class P2PFactory(Factory):
+    def __init__(self, peer_id: str, metadata: dict, public_ip: Optional[str] = None, public_port: Optional[str] = None):
+        """
+        Initialize the P2P factory with peer information and metadata.
+        :param peer_id: Unique identifier for this peer
+        :param metadata: Dictionary containing peer metadata (e.g., universe, peer_type, etc.)
+        :param public_ip: Public IP address of this peer
+        :param public_port: Public port of this peer
+        """
+        self.peers = Peers()
+
+        self.seen_messages = {}  # Dictionary to store message_id -> timestamp
+        self.message_ttl = 20  # Time to live for messages in seconds
+        self.id = peer_id  # Unique ID for this node
+
+        self.public_ip = public_ip
+        self.public_port = public_port
+        self.metadata = metadata
+
+        self.peers.add_peer(self.id)
+        self.peers.set_public_info(self.id, public_ip, public_port)
+        self.peers.set_peer_metadata(self.id, metadata)
+
+        self.logger = logging.getLogger(__name__)  # Initialize logger
+
+        self.user_defined_msg_handlers=dict()
+        
+        self.event_listeners = {
+            'entered': [],
+            'left': [],
+            'peer:connected': [],
+            'peer:disconnected': [],
+            'peer:discovered': [],
+            'peer:undiscovered': [],
+            'peer:all_disconnected': [],
+            'message': []
+        }
+
+        self._connection_count = 0  # Private connection counter
+        self._is_shutting_down = False  # Track intentional shutdown
+
+        # Start cleanup task for old messages
+        self.cleanup_task = LoopingCall(self._cleanup_old_messages)
+        self.cleanup_task.start(5)  # Run cleanup every 5 seconds
+
+    def _cleanup_old_messages(self):
+        """Remove messages older than message_ttl seconds"""
+        current_time = time.time()
+        expired_messages = [
+            msg_id for msg_id, timestamp in self.seen_messages.items()
+            if current_time - timestamp > self.message_ttl
+        ]
+        
+        for msg_id in expired_messages:
+            del self.seen_messages[msg_id]
+        
+        if expired_messages:
+            self.logger.debug(f"Cleaned up {len(expired_messages)} expired messages")
+
+    def _is_message_seen(self, message_id: str) -> bool:
+        """Check if a message has been seen before"""
+        return message_id in self.seen_messages
+
+    def _mark_message_seen(self, message_id: str):
+        """Mark a message as seen with current timestamp"""
+        self.seen_messages[message_id] = time.time()
+
+    def buildProtocol(self, addr):
+        """Create a new P2PNode protocol instance"""
+        node = P2PNode(self, self.peers)  # Pass the factory instance to P2PNode
+        return node
+    
+    def _increment_connection_count(self):
+        """Private method to increment connection count"""
+        self._connection_count += 1
+
+    def _decrement_connection_count(self):
+        """Private method to decrement connection count"""
+        self._connection_count -= 1
+
+    def disconnect_from_peer(self, peer_id: str) -> None:
+        """Disconnect from a specific peer by closing their transport connection."""
+        peer_info = self.peers.get_peer_info(peer_id)
+        if not peer_info:
+            self.logger.warning(f"Cannot disconnect: peer {peer_id} not found")
+            raise ValueError(f"No such peer {peer_id} in registry.")
+        # Close both local and remote connections if they exist
+        for connection_type in ['local', 'remote']:
+            if connection_type in peer_info and 'transport' in peer_info[connection_type]:
+                transport = peer_info[connection_type]['transport']
+                if transport:
+                    transport.loseConnection()      
+
+    def get_connection_count(self) -> int:
+        """Private method to get current connection count"""
+        return self._connection_count
+
+    def send_message(self, message: dict, peer_transport: Optional[Any] = None) -> None:
+        """Send a message to all connected peers or a specific peer."""
+        if "message_id" in message:
+            self._mark_message_seen(message["message_id"])
+        else:
+            self.logger.debug("Message without message_id generating id...")
+            message_id = str(uuid.uuid4())
+            message["message_id"] = message_id
+            self._mark_message_seen(message_id)
+
+        # Ensure the message has required fields
+        if "message_type" not in message:
+            self.logger.error("Message must have a 'message_type' field.")
+            return
+        if "peer_id" not in message:
+            self.logger.debug("Message must have a 'peer_id' field. Setting to factory ID.")
+            message["peer_id"] = self.id
+
+        if message.get("peer_id") != self.id:
+            self.logger.debug(f"Forwarding message: {message}")
+        else:
+            self.logger.debug(f"Sending message {message}")
+
+        serialized_message = json.dumps(message) + "\n"
+        data = serialized_message.encode("utf-8")
+
+        if peer_transport:
+            peer_transport.write(data)
+        else:
+            for transport in self.peers.get_peer_transports():
+                transport.write(data)
+            
+    def send_to_peer(self, peer_id: str, message: dict) -> None:
+        """Send a message to a specific peer identified by peer_id.
+        If the peer is not connected, the message will be sent to all connected peers.
+        :param peer_id: Identifier for the peer.
+        :param message: The message to send, which must include 'message_type' and 'payload'.
+        """
+        # Ensure target_id is set
+        message["target_id"] = peer_id
+        
+        peer_info = self.peers.get_peer_info(peer_id)
+        if not peer_info:
+            self.logger.error(f"No such peer {peer_id} in registry.")
+            raise ValueError(f"No such peer {peer_id} in registry.")
+
+        # Find an active transport (local or remote) for that peer
+        transport = None
+        for loc in ("remote", "local"):
+            info = peer_info.get(loc)
+            if info and "transport" in info:
+                transport = info["transport"]
+                break
+        if not transport:
+            self.logger.debug(f"Peer {peer_id} is not currently connected. Sending to all connected peers.")
+            self.send_message(message)
+        else:
+            self.logger.debug(f"Sending message to peer {peer_id}")
+            self.send_message(message, transport)
+
+    def broadcast_remove_peer(self, peer_id: str):
+        """Broadcast a message to all peers to remove a disconnected peer."""
+        message_id = str(uuid.uuid4())
+        message = {
+            "message_type": SystemMessageType.BROADCAST_REMOVE_PEER.value,
+            "message_id": message_id,
+            "peer_id": self.id,
+            "remove_peer_id": peer_id,
+        }
+        self.send_message(message)
+
+    def send_intentional_disconnect(self, peer_id: str):
+        """Send a message to indicate an intentional disconnect."""
+        message_id = str(uuid.uuid4())
+        message = {
+            "message_type": SystemMessageType.SEND_INTENTIONAL_DISCONNECT.value,
+            "message_id": message_id,
+            "peer_id": self.id,
+        }
+        self.send_to_peer(peer_id, message)
+
+    def add_event_listener(self, event_name, listener):
+        """Register an event listener for a specific event"""
+        if event_name in self.event_listeners:
+            self.event_listeners[event_name].append(listener)
+        else:
+            self.event_listeners[event_name] = [listener]
+
+    def remove_event_listener(self, event_name, listener):
+        """Remove an event listener for a specific event"""
+        if event_name in self.event_listeners:
+            self.event_listeners[event_name].remove(listener)
+
+    def set_shutting_down(self, shutting_down: bool):
+        """Set the shutdown state to distinguish intentional vs unintentional disconnections"""
+        self._is_shutting_down = shutting_down
+
+    def on_entered_event(self):
+        """Trigger the entered event"""
+        self.logger.info(f"Successfully entered the network.")
+        for listener in self.event_listeners.get('entered', []):
+            listener()
+
+    def on_left_event(self):
+        """Trigger the left event"""
+        self.logger.info(f"Left the network.")
+        for listener in self.event_listeners.get('left', []):
+            listener()
+
+    def on_peer_connected_event(self, peer_id: str):
+        """Trigger the peer:connected event"""
+        self._increment_connection_count()
+        self.logger.info(f"Connection established with {peer_id}. Connection count: {self._connection_count}")
+        for listener in self.event_listeners.get('peer:connected', []):
+            listener(peer_id)
+
+    def on_peer_disconnected_event(self, peer_id: str):
+        """Trigger the peer:disconnected event"""
+        self._decrement_connection_count()
+        self.logger.info(f"Connection lost with {peer_id}. Connection count: {self._connection_count}")
+        
+        # Check if this was the last connection and it wasn't intentional
+        if self._connection_count == 0:
+            self.logger.info("Disconnected from all peers.")
+            for listener in self.event_listeners.get('peer:all_disconnected', []):
+                listener()
+        
+        for listener in self.event_listeners.get('peer:disconnected', []):
+            listener(peer_id)
+
+    def on_peer_discovered_event(self, peer_id: str):
+        """Trigger the peer:discovered event"""
+        self.logger.info(f"Peer discovered: {peer_id}")
+        for listener in self.event_listeners.get('peer:discovered', []):
+            listener(peer_id)
+    
+    def on_peer_undiscovered_event(self, peer_id: str):
+        """Trigger the peer:undiscovered event"""
+        self.logger.info(f"Peer undiscovered: {peer_id}")
+        for listener in self.event_listeners.get('peer:undiscovered', []):
+            listener(peer_id)
+
+    def emit_message(self, peer_id: str, message: dict):
+        """Trigger the message event with formatted payload"""
+        event_data = {
+            'peer_id': peer_id,
+            'message_type': message.get('message_type'),
+            'payload': message.get('payload')
+        }
+        for listener in self.event_listeners.get('message', []):
+            listener(event_data)

swchp2pcom/message_types.py

@@ -0,0 +1,65 @@
+"""
+Message type constants and enums for the SwchPeer P2P communication library.
+
+This module defines standardized message types used for system-level communication
+between peers in the network, ensuring consistency and reducing the risk of typos
+in message type strings throughout the codebase.
+"""
+
+from enum import Enum, unique
+
+
+@unique
+class SystemMessageType(Enum):
+    """
+    Enumeration of system-level message types used for P2P network management.
+    
+    These message types are reserved for internal network operations such as
+    peer discovery, connection management, and network state synchronization.
+    User-defined message types should not use these reserved values.
+    """
+    
+    # System message types
+    SEND_WELCOME_INFO = "system_send_welcome_info"
+    BROADCAST_PEER_LIST_UPDATE = "system_broadcast_peer_list_update"
+    BROADCAST_REMOVE_PEER = "system_broadcast_remove_peer"
+    SEND_INTENTIONAL_DISCONNECT = "system_send_intentional_disconnect"
+    
+    def __str__(self):
+        """Return the string value of the message type."""
+        return self.value
+    
+    @classmethod
+    def is_system_message(cls, message_type: str) -> bool:
+        """
+        Check if a message type is a reserved system message.
+        
+        Args:
+            message_type: The message type string to check
+            
+        Returns:
+            True if the message type is a system message, False otherwise
+        """
+        return message_type in [msg_type.value for msg_type in cls]
+    
+    @classmethod
+    def get_all_system_types(cls) -> list[str]:
+        """
+        Get a list of all system message type strings.
+        
+        Returns:
+            List of all system message type values
+        """
+        return [msg_type.value for msg_type in cls]
+
+def is_system_message(message_type: str) -> bool:
+    """
+    Convenience function to check if a message type is a system message.
+    
+    Args:
+        message_type: The message type string to check
+        
+    Returns:
+        True if the message type is a system message, False otherwise
+    """
+    return SystemMessageType.is_system_message(message_type)

swchp2pcom/node.py

@@ -0,0 +1,287 @@
+from twisted.internet.protocol import Protocol
+from twisted.internet.task import LoopingCall
+import uuid
+import json
+import logging
+from typing import Optional, Dict, Any, List
+
+from swchp2pcom.peers import Peers
+from swchp2pcom.message_types import SystemMessageType
+
+class P2PNode(Protocol):
+    def __init__(self, factory, peers: Peers, is_initiator: bool = False, is_entering: bool = False):
+        self.factory = factory
+        self.peers = peers
+
+        self.buffer = ""  # Buffer to hold partial messages
+        self.is_initiator = is_initiator  # Track if this node initiated the connection
+        self.is_entering = is_entering # Track if this node is created for entering the network
+        self.remote_id: Optional[str] = None  # ID of the remote peer
+        self.logger = logging.getLogger(__name__)  # Initialize logger
+
+    def connectionMade(self):
+        """Handle new connection."""
+        peer = self.transport.getPeer()
+        host = self.transport.getHost()
+
+        peer_address = f"{peer.host}:{peer.port}"
+        host_address = f"{host.host}:{host.port}"
+
+        self.logger.debug(f"Connected to peer at {peer_address} from {host_address}")
+        if self.is_initiator:
+            self.logger.info(f"Made connection to a peer...")
+        else:
+            self.logger.info(f"Peer made connection to us...")
+
+        self.send_welcome_info()
+
+    def dataReceived(self, data: bytes):
+        """Handle incoming data."""
+        try:
+            decoded_data = data.decode("utf-8")
+        except UnicodeDecodeError as e:
+            self.logger.error(f"Error decoding data: {e}")
+            return
+
+        self.buffer += decoded_data
+        lines = self.buffer.split("\n")
+        self.buffer = lines.pop()  # Save incomplete data
+
+        for line in lines:
+            if not line.strip():
+                continue  # Skip empty lines
+            try:
+                parsed_message = json.loads(line)
+                self.process_message(parsed_message)
+            except json.JSONDecodeError as e:
+                self.logger.error(f"Error decoding message: {e}")
+
+    def process_message(self, message: Dict[str, Any]):
+        """Handle and forward broadcast messages."""
+        message_id = message.get("message_id")
+        target_id = message.get("target_id")
+        
+        if not message_id:
+            self.logger.warning("Received message without message_id")
+            return
+
+        if self.factory._is_message_seen(message_id):
+            return  # Deduplicate messages
+
+        self.logger.debug(f"Received message: {message}")
+        self.factory._mark_message_seen(message_id)
+
+        message_type = message.get("message_type")
+
+        match message_type:
+            case SystemMessageType.BROADCAST_PEER_LIST_UPDATE.value:
+                self.handle_peer_list_update(message)
+            case SystemMessageType.SEND_WELCOME_INFO.value:
+                self.handle_welcome_info(message)
+            case SystemMessageType.BROADCAST_REMOVE_PEER.value:
+                self.handle_remove_peer(message)
+            case SystemMessageType.SEND_INTENTIONAL_DISCONNECT.value:
+                self.handle_intentional_disconnect(message)
+            case _:
+                # Forward message if we're not the target or not broadcast
+                if target_id not in ("*", self.factory.id):
+                    self.factory.send_to_peer(target_id, message)
+                    return
+
+                # Forward message if it is a broadcast
+                if target_id == "*":
+                    self.factory.send_message(message)
+
+                self.logger.info(f"Recieved user-defined message: {message}")
+
+                # Handle message since it must be a broadcast or targeted user-defined message
+                if message_type in self.factory.user_defined_msg_handlers:
+                    func = self.factory.user_defined_msg_handlers[message_type]
+                    func(message.get("peer_id",""), message.get("payload",""))
+                else:
+                    self.logger.warning(f"Unknown message type received: {message_type}")
+                
+
+                # Emit message event
+                self.factory.emit_message(message.get("peer_id", ""), message)
+
+    def send_welcome_info(self):
+        """Send peer info to the connected peer."""
+        message_id = str(uuid.uuid4())
+        peer_public_info_list = self.factory.peers.get_known_peers_public_info()
+        message = {
+            "message_type": SystemMessageType.SEND_WELCOME_INFO.value,
+            "message_id": message_id,
+            "peer_id": self.factory.id,
+            "peer_public_info": self.peers.get_peer_info(self.factory.id)["public"],
+            "peer_metadata": self.peers.get_peer_metadata(self.factory.id),
+            "peers": peer_public_info_list
+        }
+        self.factory.send_message(message, peer_transport=self.transport)
+
+    def handle_welcome_info(self, message: Dict[str, Any]):
+        """Update peer info upon receiving process_peer_info message."""
+        remote_peer_id = message.get("peer_id")
+
+        if not remote_peer_id:
+            self.logger.error(f"Received {message.get("message_type")} without id")
+            return
+        
+        # Store the remote peer ID
+        self.remote_id = remote_peer_id
+
+        is_new_peer = not self.peers.get_peer_info(remote_peer_id)
+
+        if is_new_peer:
+            # Add new peer to the peer list
+            self.peers.add_peer(remote_peer_id)
+            self.peers.set_public_info(remote_peer_id, message["peer_public_info"]["host"], message["peer_public_info"]["port"])
+            self.peers.set_peer_metadata(remote_peer_id, message.get("peer_metadata", {}))
+            
+        # Set the transport information for the peer
+        peer = self.transport.getPeer()
+        if self.is_initiator:
+            self.peers.set_local_info(remote_peer_id, peer.host, peer.port, self.transport)
+        else:
+            self.peers.set_remote_info(remote_peer_id, peer.host, peer.port, self.transport)
+
+        # Raise peer discovered and connected events
+        if is_new_peer:
+            self.factory.on_peer_discovered_event(remote_peer_id)
+        self.factory.on_peer_connected_event(remote_peer_id)
+
+        # Process the peers list from the welcome message
+        for peer_id, public_info, metadata in message.get("peers", []):
+            if not self.peers.get_peer_info(peer_id):
+                # Add new peer to the peer list
+                self.peers.add_peer(peer_id)
+                self.peers.set_public_info(peer_id, public_info["host"], public_info["port"])
+                self.peers.set_peer_metadata(peer_id, metadata)
+
+                # Raise peer discovered event
+                self.factory.on_peer_discovered_event(peer_id)
+
+        # Let others know about the new peer in the network
+        if is_new_peer and len(self.peers.get_all_peers_items()) > 2:
+            # If this is a new peer, broadcast the updated peer list
+            self.broadcast_peer_list_update()
+
+        if (not self.is_entering) and is_new_peer:
+            # Log the public peer list
+            self.log_public_peer_list(message=f"Peer {remote_peer_id} entered. Updated peer list")
+
+        if self.is_entering:
+            self.log_public_peer_list(message=f"Recieved peers after entering. Current peers")
+            self.factory.on_entered_event()
+            self.is_entering = False  # Reset entering state
+
+    def broadcast_peer_list_update(self):
+        """Broadcast the known peer list to all connected peers."""
+        message_id = str(uuid.uuid4())
+        peer_public_info_list = self.factory.peers.get_known_peers_public_info()
+        message = {
+            "message_type": SystemMessageType.BROADCAST_PEER_LIST_UPDATE.value,
+            "message_id": message_id,
+            "peer_id": self.factory.id,
+            "peers": peer_public_info_list
+        }
+        self.factory.send_message(message)
+
+    def handle_peer_list_update(self, message: Dict[str, Any]):
+        """Update the known peer list."""
+        peers = message.get("peers", [])
+        any_changed = False
+
+        for peer_id, public_info, metadata in peers:
+            old = self.peers.get_peer_info(peer_id)
+
+            if not old:
+                # Add new peer to the peer list
+                self.peers.add_peer(peer_id)
+                self.peers.set_public_info(peer_id, public_info["host"], public_info["port"])
+                self.peers.set_peer_metadata(peer_id, metadata)
+                any_changed = True
+
+                self.factory.on_peer_discovered_event(peer_id)
+            if old and (old.get("public") != public_info):
+                self.logger.info(f"New public info for peer: {peer_id}, public_info: {public_info}")
+                self.peers.set_public_info(peer_id, public_info["host"], public_info["port"])
+                any_changed = True
+
+            if old and (old.get("metadata") != metadata):
+                self.logger.info(f"New metadata for peer: {peer_id}, metadata: {metadata}")
+                self.peers.set_peer_metadata(peer_id, metadata)
+                any_changed = True
+
+        if any_changed:
+            self.log_public_peer_list()
+
+        # Forward the update peer list message to all peers
+        self.factory.send_message(message)
+
+    def handle_remove_peer(self, message: Dict[str, Any]):
+        """Remove a peer from all_peers."""
+        peer_id = message.get("remove_peer_id")
+        if peer_id:
+            # Raise peer undiscovered event
+            self.factory.on_peer_undiscovered_event(peer_id)
+
+            if self.peers.remove_peer_info(peer_id):
+                self.log_public_peer_list(message=f"Peer {peer_id} left. Peer list updated")    
+            else:
+                self.logger.debug(f"Peer {peer_id} not found in peer list.")
+            
+        # Propagate the removal to other peers
+        self.factory.send_message(message)
+
+    def handle_intentional_disconnect(self, message: Dict[str, Any]):
+        """Handle intentional disconnect from a peer."""
+        self.peers.set_is_intentional_disconnect(message.get("peer_id"),True)
+
+    def connectionLost(self, reason):
+        """Handle lost connection."""
+        self.logger.debug(f"Connection lost: {reason.getErrorMessage()}")
+
+        if not self.remote_id:
+            self.logger.debug("Remote ID is not set, cannot handle disconnection properly.")
+            return
+
+        # If we doesnt have information about the peer (Could be because we already removed him, or the peer was never added)
+        if not self.peers.get_peer_info(self.remote_id):
+            self.factory.on_peer_disconnected_event(self.remote_id)
+            return
+
+        # If it wasnt intentional
+        if not self.peers.get_is_intentional_disconnect(self.remote_id):
+            self.logger.debug("Unintentional disconnect detected, removing peer info.")
+            self.factory.on_peer_undiscovered_event(self.remote_id)
+            
+            self.peers.remove_peer_info(self.remote_id)
+            self.factory.on_peer_disconnected_event(self.remote_id)
+            
+            # Broadcast the removal of the peer
+            self.factory.broadcast_remove_peer(self.remote_id)
+
+            # log the public peer list
+            self.log_public_peer_list(message=f"Peer {self.remote_id} left. Peer list updated")
+        # If it was intentional, and he doesnt needs to be removed from the network
+        else:
+            if self.peers.get_peer_info(self.remote_id):
+                if self.is_initiator:
+                    self.peers.remove_peer_info(self.remote_id,"local")
+                else:
+                    self.peers.remove_peer_info(self.remote_id,"remote")
+
+            # Reset the intentional disconnect flag
+            self.peers.set_is_intentional_disconnect(self.remote_id, False)
+            # Raise peer disconnected event
+            self.factory.on_peer_disconnected_event(self.remote_id)
+
+    def log_public_peer_list(self, message: str = "Peer list updated"):
+        self.logger.info(
+            f"\n{'-'*13}\n{message}:\n" +
+            "\n".join(f"id: {pid}, host: {info['public']['host']}, port: {info['public']['port']}" 
+                    for pid, info in self.peers.get_all_peers_items() if info["public"]) +
+            f"\n{'-'*13}"
+        )
+