koi-net 1.0.0b19__py3-none-any.whl → 1.1.0b2__py3-none-any.whl

koi_net/network/__init__.py

@@ -1 +0,0 @@
-from .interface import NetworkInterface

koi_net/network/behavior.py

@@ -0,0 +1,42 @@
+from logging import getLogger
+from rid_lib.types import KoiNetNode
+from ..protocol.event import Event, EventType
+from ..identity import NodeIdentity
+from ..effector import Effector
+from ..network.event_queue import NetworkEventQueue
+
+logger = getLogger(__name__)
+
+
+class Actor:
+    identity: NodeIdentity
+    effector: Effector
+    event_queue: NetworkEventQueue
+    
+    def __init__(
+        self, 
+        identity: NodeIdentity, 
+        effector: Effector,
+        event_queue: NetworkEventQueue
+    ):
+        self.identity = identity
+        self.effector = effector
+        self.event_queue = event_queue
+    
+    def handshake_with(self, target: KoiNetNode):
+        logger.debug(f"Initiating handshake with {target}")
+        self.event_queue.push_event_to(
+            Event.from_rid(
+                event_type=EventType.FORGET, 
+                rid=self.identity.rid),
+            node=target
+        )
+            
+        self.event_queue.push_event_to(
+            event=Event.from_bundle(
+                event_type=EventType.NEW, 
+                bundle=self.effector.deref(self.identity.rid)),
+            node=target
+        )
+        
+        self.event_queue.flush_webhook_queue(target)

koi_net/network/error_handler.py

@@ -0,0 +1,50 @@
+from logging import getLogger
+from koi_net.protocol.errors import ErrorTypes
+from koi_net.protocol.event import EventType
+from rid_lib.types import KoiNetNode
+from ..processor.interface import ProcessorInterface
+from ..network.behavior import Actor
+
+logger = getLogger(__name__)
+
+
+class ErrorHandler:
+    timeout_counter: dict[KoiNetNode, int]
+    processor: ProcessorInterface
+    actor: Actor
+    
+    def __init__(
+        self, 
+        processor: ProcessorInterface,
+        actor: Actor
+    ):
+        self.processor = processor
+        self.actor = actor
+        self.timeout_counter = {}
+        
+    def handle_connection_error(self, node: KoiNetNode):
+        self.timeout_counter.setdefault(node, 0)
+        self.timeout_counter[node] += 1
+        
+        logger.debug(f"{node} has timed out {self.timeout_counter[node]} time(s)")
+        
+        if self.timeout_counter[node] > 3:
+            logger.debug(f"Exceeded time out limit, forgetting node")
+            self.processor.handle(rid=node, event_type=EventType.FORGET)
+            # do something
+        
+        
+    def handle_protocol_error(
+        self, 
+        error_type: ErrorTypes, 
+        node: KoiNetNode
+    ):
+        logger.info(f"Handling protocol error {error_type} for node {node!r}")
+        match error_type:
+            case ErrorTypes.UnknownNode:
+                logger.info("Peer doesn't know me, attempting handshake...")
+                self.actor.handshake_with(node)
+                
+            case ErrorTypes.InvalidKey: ...
+            case ErrorTypes.InvalidSignature: ...
+            case ErrorTypes.InvalidTarget: ...

koi_net/network/{interface.py → event_queue.py}

@@ -1,21 +1,19 @@
 import logging
 from queue import Queue
-from typing import Generic
 import httpx
 from pydantic import BaseModel
 from rid_lib import RID
-from rid_lib.core import RIDType
 from rid_lib.ext import Cache
 from rid_lib.types import KoiNetNode
 
 from .graph import NetworkGraph
 from .request_handler import RequestHandler
-from .response_handler import ResponseHandler
-from ..protocol.node import NodeType
-from ..protocol.edge import EdgeType
+from ..protocol.node import NodeProfile, NodeType
+from ..protocol.edge import EdgeProfile, EdgeType
 from ..protocol.event import Event
 from ..identity import NodeIdentity
-from ..config import ConfigType
+from ..config import NodeConfig
+from ..effector import Effector
 
 logger = logging.getLogger(__name__)
 
@@ -26,34 +24,36 @@ class EventQueueModel(BaseModel):
 
 type EventQueue = dict[RID, Queue[Event]]
 
-class NetworkInterface(Generic[ConfigType]):
+class NetworkEventQueue:
     """A collection of functions and classes to interact with the KOI network."""
     
-    config: ConfigType    
+    config: NodeConfig    
     identity: NodeIdentity
+    effector: Effector
     cache: Cache
     graph: NetworkGraph
     request_handler: RequestHandler
-    response_handler: ResponseHandler
     poll_event_queue: EventQueue
     webhook_event_queue: EventQueue
     
     def __init__(
         self, 
-        config: ConfigType,
+        config: NodeConfig,
         cache: Cache, 
-        identity: NodeIdentity
+        identity: NodeIdentity,
+        effector: Effector,
+        graph: NetworkGraph,
+        request_handler: RequestHandler,
     ):
         self.config = config
         self.identity = identity
         self.cache = cache
-        self.graph = NetworkGraph(cache, identity)
-        self.request_handler = RequestHandler(cache, self.graph)
-        self.response_handler = ResponseHandler(cache)
+        self.graph = graph
+        self.request_handler = request_handler
+        self.effector = effector
         
         self.poll_event_queue = dict()
         self.webhook_event_queue = dict()
-        self._load_event_queues()
     
     def _load_event_queues(self):
         """Loads event queues from storage."""
@@ -100,29 +100,43 @@ class NetworkInterface(Generic[ConfigType]):
         
         Event will be sent to webhook or poll queue depending on the node type and edge type of the specified node. If `flush` is set to `True`, the webhook queued will be flushed after pushing the event.
         """
-        logger.debug(f"Pushing event {event.event_type} {event.rid} to {node}")
-            
-        node_profile = self.graph.get_node_profile(node)
-        if not node_profile:
-            logger.warning(f"Node {node!r} unknown to me")
+        logger.debug(f"Pushing event {event.event_type} {event.rid!r} to {node}")
+                        
+        node_bundle = self.effector.deref(node)
         
         # if there's an edge from me to the target node, override broadcast type
-        edge_profile = self.graph.get_edge_profile(
+        edge_rid = self.graph.get_edge(
             source=self.identity.rid,
             target=node
         )
         
-        if edge_profile:
+        edge_bundle = self.effector.deref(edge_rid) if edge_rid else None
+        
+        if edge_bundle:
+            logger.debug(f"Found edge from me to {node!r}")
+            edge_profile = edge_bundle.validate_contents(EdgeProfile)
             if edge_profile.edge_type == EdgeType.WEBHOOK:
                 event_queue = self.webhook_event_queue
             elif edge_profile.edge_type == EdgeType.POLL:
                 event_queue = self.poll_event_queue
-        else:
+                
+        elif node_bundle:
+            logger.debug(f"Found bundle for {node!r}")
+            node_profile = node_bundle.validate_contents(NodeProfile)
             if node_profile.node_type == NodeType.FULL:
                 event_queue = self.webhook_event_queue
             elif node_profile.node_type == NodeType.PARTIAL:
                 event_queue = self.poll_event_queue
         
+        elif node == self.config.koi_net.first_contact.rid:
+            logger.debug(f"Node {node!r} is my first contact")
+            # first contact node is always a webhook node
+            event_queue = self.webhook_event_queue
+        
+        else:
+            logger.warning(f"Node {node!r} unknown to me")
+            return
+        
         queue = event_queue.setdefault(node, Queue())
         queue.put(event)
                 
@@ -136,7 +150,7 @@ class NetworkInterface(Generic[ConfigType]):
         if queue:
             while not queue.empty():
                 event = queue.get()
-                logger.debug(f"Dequeued {event.event_type} '{event.rid}'")
+                logger.debug(f"Dequeued {event.event_type} {event.rid!r}")
                 events.append(event)
         
         return events
@@ -146,7 +160,7 @@ class NetworkInterface(Generic[ConfigType]):
         logger.debug(f"Flushing poll queue for {node}")
         return self._flush_queue(self.poll_event_queue, node)
     
-    def flush_webhook_queue(self, node: KoiNetNode):
+    def flush_webhook_queue(self, node: KoiNetNode, requeue_on_fail: bool = True):
         """Flushes a node's webhook queue, and broadcasts events.
         
         If node profile is unknown, or node type is not `FULL`, this operation will fail silently. If the remote node cannot be reached, all events will be requeued.
@@ -154,15 +168,17 @@ class NetworkInterface(Generic[ConfigType]):
         
         logger.debug(f"Flushing webhook queue for {node}")
         
-        node_profile = self.graph.get_node_profile(node)
+        # node_bundle = self.effector.deref(node)
         
-        if not node_profile:
-            logger.warning(f"{node!r} not found")
-            return
+        # if not node_bundle:
+        #     logger.warning(f"{node!r} not found")
+        #     return
         
-        if node_profile.node_type != NodeType.FULL:
-            logger.warning(f"{node!r} is a partial node!")
-            return
+        # node_profile = node_bundle.validate_contents(NodeProfile)
+        
+        # if node_profile.node_type != NodeType.FULL:
+        #     logger.warning(f"{node!r} is a partial node!")
+        #     return
         
         events = self._flush_queue(self.webhook_event_queue, node)
         if not events: return
@@ -174,103 +190,8 @@ class NetworkInterface(Generic[ConfigType]):
             return True
         except httpx.ConnectError:
             logger.warning("Broadcast failed")
-            for event in events:
-                self.push_event_to(event, node)
-            return False
-            
-    def get_state_providers(self, rid_type: RIDType) -> list[KoiNetNode]:
-        """Returns list of node RIDs which provide state for the specified RID type."""
-        
-        logger.debug(f"Looking for state providers of '{rid_type}'")
-        provider_nodes = []
-        for node_rid in self.cache.list_rids(rid_types=[KoiNetNode]):
-            node = self.graph.get_node_profile(node_rid)
-                        
-            if node.node_type == NodeType.FULL and rid_type in node.provides.state:
-                logger.debug(f"Found provider '{node_rid}'")
-                provider_nodes.append(node_rid)
-        
-        if not provider_nodes:
-            logger.debug("Failed to find providers")
-        return provider_nodes
             
-    def fetch_remote_bundle(self, rid: RID):
-        """Attempts to fetch a bundle by RID from known peer nodes."""
-        
-        logger.debug(f"Fetching remote bundle '{rid}'")
-        remote_bundle = None
-        for node_rid in self.get_state_providers(type(rid)):
-            payload = self.request_handler.fetch_bundles(
-                node=node_rid, rids=[rid])
-            
-            if payload.bundles:
-                remote_bundle = payload.bundles[0]
-                logger.debug(f"Got bundle from '{node_rid}'")
-                break
-        
-        if not remote_bundle:
-            logger.warning("Failed to fetch remote bundle")
-            
-        return remote_bundle
-    
-    def fetch_remote_manifest(self, rid: RID):
-        """Attempts to fetch a manifest by RID from known peer nodes."""
-        
-        logger.debug(f"Fetching remote manifest '{rid}'")
-        remote_manifest = None
-        for node_rid in self.get_state_providers(type(rid)):
-            payload = self.request_handler.fetch_manifests(
-                node=node_rid, rids=[rid])
-            
-            if payload.manifests:
-                remote_manifest = payload.manifests[0]
-                logger.debug(f"Got bundle from '{node_rid}'")
-                break
-        
-        if not remote_manifest:
-            logger.warning("Failed to fetch remote bundle")
-            
-        return remote_manifest
-    
-    def poll_neighbors(self) -> list[Event]:
-        """Polls all neighboring nodes and returns compiled list of events.
-        
-        If this node has no neighbors, it will instead attempt to poll the provided first contact URL.
-        """
-        
-        neighbors = self.graph.get_neighbors()
-        
-        if not neighbors and self.config.koi_net.first_contact:
-            logger.debug("No neighbors found, polling first contact")
-            try:
-                payload = self.request_handler.poll_events(
-                    url=self.config.koi_net.first_contact, 
-                    rid=self.identity.rid
-                )
-                if payload.events:
-                    logger.debug(f"Received {len(payload.events)} events from '{self.config.koi_net.first_contact}'")
-                return payload.events
-            except httpx.ConnectError:
-                logger.debug(f"Failed to reach first contact '{self.config.koi_net.first_contact}'")
-        
-        events = []
-        for node_rid in neighbors:
-            node = self.graph.get_node_profile(node_rid)
-            if not node: continue
-            if node.node_type != NodeType.FULL: continue
-            
-            try:
-                payload = self.request_handler.poll_events(
-                    node=node_rid, 
-                    rid=self.identity.rid
-                )
-                if payload.events:
-                    logger.debug(f"Received {len(payload.events)} events from {node_rid!r}")
-                events.extend(payload.events)
-            except httpx.ConnectError:
-                logger.debug(f"Failed to reach node '{node_rid}'")
-                continue
-            
-        return events                
-        
-        
+            if requeue_on_fail:
+                for event in events:
+                    self.push_event_to(event, node)
+            return False

koi_net/network/graph.py

@@ -6,7 +6,6 @@ from rid_lib.ext import Cache
 from rid_lib.types import KoiNetEdge, KoiNetNode
 from ..identity import NodeIdentity
 from ..protocol.edge import EdgeProfile, EdgeStatus
-from ..protocol.node import NodeProfile
 
 logger = logging.getLogger(__name__)
 
@@ -30,43 +29,27 @@ class NetworkGraph:
         for rid in self.cache.list_rids():
             if type(rid) == KoiNetNode:                
                 self.dg.add_node(rid)
-                logger.debug(f"Added node {rid}")
+                logger.debug(f"Added node {rid!r}")
                 
             elif type(rid) == KoiNetEdge:
-                edge_profile = self.get_edge_profile(rid)
-                if not edge_profile:
+                edge_bundle = self.cache.read(rid)
+                if not edge_bundle:
                     logger.warning(f"Failed to load {rid!r}")
                     continue
+                edge_profile = edge_bundle.validate_contents(EdgeProfile)
                 self.dg.add_edge(edge_profile.source, edge_profile.target, rid=rid)
-                logger.debug(f"Added edge {rid} ({edge_profile.source} -> {edge_profile.target})")
+                logger.debug(f"Added edge {rid!r} ({edge_profile.source} -> {edge_profile.target})")
         logger.debug("Done")
         
-    def get_node_profile(self, rid: KoiNetNode) -> NodeProfile | None:
-        """Returns node profile given its RID."""
-        bundle = self.cache.read(rid)
-        if bundle:
-            return bundle.validate_contents(NodeProfile)
-        
-    def get_edge_profile(
-        self, 
-        rid: KoiNetEdge | None = None,
-        source: KoiNetNode | None = None, 
-        target: KoiNetNode | None = None,
-    ) -> EdgeProfile | None:
-        """Returns edge profile given its RID, or source and target node RIDs."""
-        if source and target:
-            if (source, target) not in self.dg.edges: return
+    def get_edge(self, source: KoiNetNode, target: KoiNetNode,) -> EdgeProfile | None:
+        """Returns edge RID given the RIDs of a source and target node."""
+        if (source, target) in self.dg.edges:
             edge_data = self.dg.get_edge_data(source, target)
-            if not edge_data: return
-            rid = edge_data.get("rid")
-            if not rid: return
-        elif not rid:
-            raise ValueError("Either 'rid' or 'source' and 'target' must be provided")
-        
-        bundle = self.cache.read(rid)
-        if bundle:
-            return bundle.validate_contents(EdgeProfile)
-        
+            if edge_data:
+                return edge_data.get("rid")
+
+        return None
+
     def get_edges(
         self,
         direction: Literal["in", "out"] | None = None,
@@ -106,12 +89,14 @@ class NetworkGraph:
         
         neighbors = []
         for edge_rid in self.get_edges(direction):
-            edge_profile = self.get_edge_profile(edge_rid)
+            edge_bundle = self.cache.read(edge_rid)
             
-            if not edge_profile: 
+            if not edge_bundle: 
                 logger.warning(f"Failed to find edge {edge_rid!r} in cache")
                 continue
-                        
+            
+            edge_profile = edge_bundle.validate_contents(EdgeProfile)
+            
             if status and edge_profile.status != status:
                 continue