astreum 0.3.9__py3-none-any.whl → 0.3.46__py3-none-any.whl

astreum/communication/{start.py → node.py}

@@ -1,19 +1,18 @@
-def connect_to_network_and_verify(self):
+
+def connect_node(self):
     """Initialize communication and consensus components, then load latest block state."""
+    if self.is_connected:
+        self.logger.debug("Node already connected; skipping communication setup")
+        return
+
     self.logger.info("Starting communication and consensus setup")
     try:
         from astreum.communication import communication_setup  # type: ignore
         communication_setup(node=self, config=self.config)
         self.logger.info("Communication setup completed")
-    except Exception:
-        self.logger.exception("Communication setup failed")
-
-    try:
-        from astreum.consensus import consensus_setup  # type: ignore
-        consensus_setup(node=self, config=self.config)
-        self.logger.info("Consensus setup completed")
-    except Exception:
-        self.logger.exception("Consensus setup failed")
+    except Exception as exc:
+        self.logger.exception("Communication setup failed: %s", exc)
+        return exc
 
     # Load latest_block_hash from config
     self.latest_block_hash = getattr(self, "latest_block_hash", None)
@@ -30,7 +29,7 @@ def connect_to_network_and_verify(self):
 
     if self.latest_block_hash and self.latest_block is None:
         try:
-            from astreum.consensus.models.block import Block
+            from astreum.validation.models.block import Block
             self.latest_block = Block.from_atom(self, self.latest_block_hash)
             self.logger.info("Loaded latest block %s from storage", self.latest_block_hash.hex())
         except Exception as exc:

astreum/communication/outgoing_queue.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional, Tuple
+
+from .message_pow import NONCE_SIZE, calculate_message_nonce
+
+if TYPE_CHECKING:
+    from .models.message import Message
+    from .. import Node
+
+
+OUTGOING_QUEUE_ITEM_OVERHEAD_BYTES = 6
+def enqueue_outgoing(
+    node: "Node",
+    address: Tuple[str, int],
+    message: Optional["Message"] = None,
+    message_bytes: Optional[bytes] = None,
+    difficulty: int = 1,
+) -> bool:
+    """Enqueue an outgoing UDP payload while tracking queued bytes.
+    When used, it increments `node.outgoing_queue_size` by `len(payload) + 6` and enforces
+    `node.outgoing_queue_size_limit` (bytes) as a soft cap by dropping enqueues that
+    would exceed the limit. If `node.outgoing_queue_timeout` is > 0, it waits up to
+    that many seconds (using `communication_stop_event.wait`) for space before dropping.
+    """
+    if not node.is_connected:
+        raise RuntimeError("node is not connected; call node.connect() (communication_setup) first")
+
+    if message is not None and message_bytes is not None:
+        raise ValueError("Specify only one of message or message_bytes")
+
+    if message_bytes is not None:
+        payload = message_bytes
+    elif message is not None:
+        payload = message.to_bytes()
+    else:
+        raise ValueError("Either message or message_bytes must be provided")
+
+    try:
+        difficulty_value = int(difficulty)
+    except Exception:
+        difficulty_value = 1
+    if difficulty_value < 1:
+        difficulty_value = 1
+
+    try:
+        nonce = calculate_message_nonce(payload, difficulty_value)
+    except Exception as exc:
+        node.logger.warning(
+            "Failed generating message nonce (difficulty=%s bytes=%s): %s",
+            difficulty_value,
+            len(payload),
+            exc,
+        )
+        return False
+
+    payload = int(nonce).to_bytes(NONCE_SIZE, "big", signed=False) + payload
+
+    accounted_size = len(payload) + OUTGOING_QUEUE_ITEM_OVERHEAD_BYTES
+
+    timeout = float(node.outgoing_queue_timeout or 0)
+
+    with node.outgoing_queue_size_lock:
+        current_size = int(node.outgoing_queue_size)
+        limit = int(node.outgoing_queue_size_limit)
+        projected_size = current_size + accounted_size
+        if projected_size > limit:
+            if timeout <= 0:
+                node.logger.warning(
+                    "Outgoing queue size limit reached (%s > %s); dropping outbound payload (bytes=%s)",
+                    projected_size,
+                    limit,
+                    len(payload),
+                )
+                return False
+            wait_for_space = True
+        else:
+            node.outgoing_queue_size = projected_size
+            wait_for_space = False
+
+    if wait_for_space:
+        if node.communication_stop_event.wait(timeout):
+            return False
+        if not node.is_connected:
+            return False
+        with node.outgoing_queue_size_lock:
+            current_size = int(node.outgoing_queue_size)
+            limit = int(node.outgoing_queue_size_limit)
+            projected_size = current_size + accounted_size
+            if limit and projected_size > limit:
+                node.logger.warning(
+                    "Outgoing queue still full after waiting %ss (%s > %s); dropping outbound payload (bytes=%s)",
+                    timeout,
+                    projected_size,
+                    limit,
+                    len(payload),
+                )
+                return False
+            node.outgoing_queue_size = projected_size
+
+    try:
+        node.outgoing_queue.put((payload, address, accounted_size))
+    except Exception:
+        with node.outgoing_queue_size_lock:
+            node.outgoing_queue_size = max(0, int(node.outgoing_queue_size) - accounted_size)
+        raise
+
+    return True

astreum/communication/processors/incoming.py

@@ -1,30 +1,56 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from ..handlers.handshake import handle_handshake
+from __future__ import annotations
+
+import socket
+from queue import Empty
+from typing import TYPE_CHECKING
+
+from ..handlers.handshake import handle_handshake
 from ..handlers.object_request import handle_object_request
 from ..handlers.object_response import handle_object_response
 from ..handlers.ping import handle_ping
 from ..handlers.route_request import handle_route_request
 from ..handlers.route_response import handle_route_response
+from ..incoming_queue import enqueue_incoming
 from ..models.message import Message, MessageTopic
 from ..models.peer import Peer
+from ..outgoing_queue import enqueue_outgoing
 from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PublicKey
 
 if TYPE_CHECKING:
-    from .. import Node
-
-
+    from .. import Node
+
+
 def process_incoming_messages(node: "Node") -> None:
     """Process incoming messages (placeholder)."""
-    while True:
+    stop = getattr(node, "communication_stop_event", None)
+    while stop is None or not stop.is_set():
         try:
-            data, addr = node.incoming_queue.get()
-        except Exception as exc:
+            item = node.incoming_queue.get(timeout=0.5)
+        except Empty:
+            continue
+        except Exception:
             node.logger.exception("Error taking from incoming queue")
             continue
 
+        data = None
+        addr = None
+        accounted_size = None
+
+        if isinstance(item, tuple) and len(item) == 3:
+            data, addr, accounted_size = item
+        else:
+            node.logger.warning("Incoming queue item has unexpected shape: %r", item)
+            continue
+
+        if stop is not None and stop.is_set():
+            if accounted_size is not None:
+                try:
+                    with node.incoming_queue_size_lock:
+                        node.incoming_queue_size = max(0, node.incoming_queue_size - int(accounted_size))
+                except Exception:
+                    node.logger.exception("Failed updating incoming_queue_size on shutdown")
+            break
+
         try:
             message = Message.from_bytes(data)
         except Exception as exc:
@@ -34,7 +60,7 @@ def process_incoming_messages(node: "Node") -> None:
         if message.handshake:
             if handle_handshake(node, addr, message):
                 continue
-        
+
         peer = None
         try:
             peer = node.get_peer(message.sender_bytes)
@@ -44,10 +70,13 @@ def process_incoming_messages(node: "Node") -> None:
             try:
                 peer_key = X25519PublicKey.from_public_bytes(message.sender_bytes)
                 host, port = addr[0], int(addr[1])
+                default_seed_ips = getattr(node, "default_seed_ips", None)
+                is_default_seed = bool(default_seed_ips) and host in default_seed_ips
                 peer = Peer(
                     node_secret_key=node.relay_secret_key,
                     peer_public_key=peer_key,
                     address=(host, port),
+                    is_default_seed=is_default_seed,
                 )
             except Exception:
                 peer = None
@@ -60,39 +89,83 @@ def process_incoming_messages(node: "Node") -> None:
         try:
             message.decrypt(peer.shared_key_bytes)
         except Exception as exc:
-            node.logger.warning("Error decrypting message from %s: %s", peer.address, exc)
+            node.logger.warning(
+                "Error decrypting message from %s (len=%s, enc_len=%s, exc=%s)",
+                peer.address,
+                len(data),
+                len(message.encrypted) if message.encrypted is not None else None,
+                exc,
+            )
+            try:
+                host, port = addr[0], int(addr[1])
+                handshake_message = Message(
+                    handshake=True,
+                    sender=node.relay_public_key,
+                    content=int(node.config["incoming_port"]).to_bytes(2, "big", signed=False),
+                )
+                enqueue_outgoing(
+                    node,
+                    (host, port),
+                    message=handshake_message,
+                    difficulty=1,
+                )
+            except Exception as handshake_exc:
+                node.logger.debug(
+                    "Failed queueing rekey handshake to %s: %s",
+                    addr,
+                    handshake_exc,
+                )
             continue
 
-        match message.topic:
-            case MessageTopic.PING:
-                handle_ping(node, peer, message.content)
-
-            case MessageTopic.OBJECT_REQUEST:
-                handle_object_request(node, peer, message)
-
-            case MessageTopic.OBJECT_RESPONSE:
-                handle_object_response(node, peer, message)
+        try:
+            match message.topic:
+                case MessageTopic.PING:
+                    handle_ping(node, peer, message.content)
 
-            case MessageTopic.ROUTE_REQUEST:
-                handle_route_request(node, peer, message)
+                case MessageTopic.OBJECT_REQUEST:
+                    handle_object_request(node, peer, message)
 
-            case MessageTopic.ROUTE_RESPONSE:
-                handle_route_response(node, peer, message)
+                case MessageTopic.OBJECT_RESPONSE:
+                    handle_object_response(node, peer, message)
 
-            case MessageTopic.TRANSACTION:
-                if node.validation_secret_key is None:
-                    continue
-                node._validation_transaction_queue.put(message.content)
+                case MessageTopic.ROUTE_REQUEST:
+                    handle_route_request(node, peer, message)
 
-            case _:
-                continue
+                case MessageTopic.ROUTE_RESPONSE:
+                    handle_route_response(node, peer, message)
 
+                case MessageTopic.TRANSACTION:
+                    if node.validation_secret_key is None:
+                        continue
+                    node._validation_transaction_queue.put(message.content)
 
-def populate_incoming_messages(node: "Node") -> None:
+                case _:
+                    continue
+        finally:
+            if accounted_size is not None:
+                try:
+                    with node.incoming_queue_size_lock:
+                        node.incoming_queue_size = max(0, node.incoming_queue_size - int(accounted_size))
+                except Exception:
+                    node.logger.exception("Failed updating incoming_queue_size")
+
+    node.logger.info("Incoming message processor stopped")
+
+
+def populate_incoming_messages(node: "Node") -> None:
     """Receive UDP packets and feed the incoming queue."""
-    while True:
+    stop = getattr(node, "communication_stop_event", None)
+    while stop is None or not stop.is_set():
         try:
             data, addr = node.incoming_socket.recvfrom(4096)
-            node.incoming_queue.put((data, addr))
-        except Exception as exc:
-            node.logger.warning("Error populating incoming queue: %s", exc)
+            enqueue_incoming(node, addr, payload=data)
+        except socket.timeout:
+            continue
+        except OSError:
+            if stop is not None and stop.is_set():
+                break
+            node.logger.warning("Error populating incoming queue: socket closed")
+        except Exception as exc:
+            node.logger.warning("Error populating incoming queue: %s", exc)
+
+    node.logger.info("Incoming message populator stopped")

astreum/communication/processors/outgoing.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from queue import Empty
 from typing import TYPE_CHECKING, Tuple
 
 if TYPE_CHECKING:
@@ -7,14 +8,46 @@ if TYPE_CHECKING:
 
 def process_outgoing_messages(node: "Node") -> None:
     """Send queued outbound packets."""
-    while True:
+    stop = getattr(node, "communication_stop_event", None)
+    while stop is None or not stop.is_set():
         try:
-            payload, addr = node.outgoing_queue.get()
+            item = node.outgoing_queue.get(timeout=0.5)
+        except Empty:
+            continue
         except Exception:
             node.logger.exception("Error taking from outgoing queue")
             continue
 
+        payload = None
+        addr = None
+        accounted_size = None
+        if isinstance(item, tuple) and len(item) == 3:
+            payload, addr, accounted_size = item
+        elif isinstance(item, tuple) and len(item) == 2:
+            payload, addr = item
+        else:
+            node.logger.warning("Outgoing queue item has unexpected shape: %r", item)
+            continue
+
+        if stop is not None and stop.is_set():
+            if accounted_size is not None:
+                try:
+                    with node.outgoing_queue_size_lock:
+                        node.outgoing_queue_size = max(0, node.outgoing_queue_size - int(accounted_size))
+                except Exception:
+                    node.logger.exception("Failed updating outgoing_queue_size on shutdown")
+            break
+
         try:
             node.outgoing_socket.sendto(payload, addr)
         except Exception as exc:
             node.logger.warning("Error sending message to %s: %s", addr, exc)
+        finally:
+            if accounted_size is not None:
+                try:
+                    with node.outgoing_queue_size_lock:
+                        node.outgoing_queue_size = max(0, node.outgoing_queue_size - int(accounted_size))
+                except Exception:
+                    node.logger.exception("Failed updating outgoing_queue_size")
+
+    node.logger.info("Outgoing message processor stopped")

astreum/communication/processors/peer.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import time
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING, Any
+
+from ..models.message import Message
+from ..outgoing_queue import enqueue_outgoing
+from ..util import address_str_to_host_and_port
+
+if TYPE_CHECKING:
+    from .. import Node
+
+
+def _queue_bootstrap_handshakes(node: "Node") -> int:
+    relay_public_key = node.relay_public_key
+
+    bootstrap_peers = node.bootstrap_peers
+    if not bootstrap_peers:
+        return 0
+
+    try:
+        incoming_port = int(node.config.get("incoming_port", 0))
+        content = incoming_port.to_bytes(2, "big", signed=False)
+    except (TypeError, ValueError, OverflowError):
+        return 0
+
+    handshake_message = Message(
+        handshake=True,
+        sender=relay_public_key,
+        content=content,
+    )
+    handshake_bytes = handshake_message.to_bytes()
+    sent = 0
+    for addr in bootstrap_peers:
+        try:
+            host, port = address_str_to_host_and_port(addr)
+        except Exception as exc:
+            node.logger.warning("Invalid bootstrap address %s: %s", addr, exc)
+            continue
+        try:
+            queued = enqueue_outgoing(
+                node,
+                (host, port),
+                message_bytes=handshake_bytes,
+                difficulty=1,
+            )
+        except Exception as exc:
+            node.logger.debug(
+                "Failed queueing bootstrap handshake to %s:%s: %s",
+                host,
+                port,
+                exc,
+            )
+            continue
+        if queued:
+            node.logger.info("Retrying bootstrap handshake to %s:%s", host, port)
+            sent += 1
+        else:
+            node.logger.debug(
+                "Bootstrap handshake queue rejected for %s:%s",
+                host,
+                port,
+            )
+    return sent
+
+
+def manage_peer(node: "Node") -> None:
+    """Continuously evict peers whose timestamps exceed the configured timeout."""
+    node.logger.info(
+        "Peer manager started (timeout=%3ds, interval=%3ds)",
+        node.config["peer_timeout"],
+        node.config["peer_timeout_interval"],
+    )
+    stop = getattr(node, "communication_stop_event", None)
+    while stop is None or not stop.is_set():
+        timeout_seconds = node.config["peer_timeout"]
+        interval_seconds = node.config["peer_timeout_interval"]
+        try:
+            peers = getattr(node, "peers", None)
+            peer_route = getattr(node, "peer_route", None)
+            if not isinstance(peers, dict) or peer_route is None:
+                time.sleep(interval_seconds)
+                continue
+
+            cutoff = datetime.now(timezone.utc) - timedelta(seconds=timeout_seconds)
+            stale_keys = []
+            with node.peers_lock:
+                for peer_key, peer in list(peers.items()):
+                    if peer.timestamp < cutoff:
+                        stale_keys.append(peer_key)
+
+            removed_count = 0
+            for peer_key in stale_keys:
+                removed = node.remove_peer(peer_key)
+                if removed is None:
+                    continue
+                removed_count += 1
+                try:
+                    peer_route.remove_peer(peer_key)
+                except Exception:
+                    node.logger.debug(
+                        "Unable to remove peer %s from route",
+                        peer_key.hex(),
+                    )
+                node.logger.debug(
+                    "Evicted stale peer %s last seen at %s",
+                    peer_key.hex(),
+                    getattr(removed, "timestamp", None),
+                )
+
+            if removed_count:
+                node.logger.info("Peer manager removed %s stale peer(s)", removed_count)
+
+            try:
+                with node.peers_lock:
+                    peer_count = len(peers)
+            except Exception:
+                peer_count = len(getattr(node, "peers", {}) or {})
+            if peer_count == 0:
+                bootstrap_interval = node.config.get("bootstrap_retry_interval", 0)
+                now = time.time()
+                last_attempt = getattr(node, "_bootstrap_last_attempt", 0.0)
+                if bootstrap_interval and (now - last_attempt) >= bootstrap_interval:
+                    sent = _queue_bootstrap_handshakes(node)
+                    if sent:
+                        node._bootstrap_last_attempt = now
+        except Exception:
+            node.logger.exception("Peer manager iteration failed")
+
+        if stop is not None and stop.wait(interval_seconds):
+            break
+
+    node.logger.info("Peer manager stopped")