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

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

@@ -1,59 +1,134 @@
-from __future__ import annotations
-
-import time
-from datetime import datetime, timedelta, timezone
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from .. import Node
-
-
-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"],
-    )
-    while True:
-        timeout_seconds = node.config["peer_timeout"]
-        interval_seconds = node.config["peer_timeout_interval"]
+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:
-            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)
-        except Exception:
-            node.logger.exception("Peer manager iteration failed")
-
-        time.sleep(interval_seconds)
+            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")