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

koi_net/network/resolver.py

@@ -0,0 +1,150 @@
+import logging
+import httpx
+from rid_lib import RID
+from rid_lib.core import RIDType
+from rid_lib.ext import Cache, Bundle
+from rid_lib.types import KoiNetNode
+
+from .graph import NetworkGraph
+from .request_handler import RequestHandler
+from ..protocol.node import NodeProfile, NodeType
+from ..protocol.event import Event
+from ..protocol.api_models import ErrorResponse
+from ..identity import NodeIdentity
+from ..config import NodeConfig
+from ..effector import Effector
+
+logger = logging.getLogger(__name__)
+
+
+class NetworkResolver:
+    """A collection of functions and classes to interact with the KOI network."""
+    
+    config: NodeConfig    
+    identity: NodeIdentity
+    effector: Effector
+    cache: Cache
+    graph: NetworkGraph
+    request_handler: RequestHandler
+    
+    def __init__(
+        self, 
+        config: NodeConfig,
+        cache: Cache, 
+        identity: NodeIdentity,
+        effector: Effector,
+        graph: NetworkGraph,
+        request_handler: RequestHandler,
+    ):
+        self.config = config
+        self.identity = identity
+        self.cache = cache
+        self.graph = graph
+        self.request_handler = request_handler
+        self.effector = effector
+        
+        self.poll_event_queue = dict()
+        self.webhook_event_queue = dict()
+    
+    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]):
+            if node_rid == self.identity.rid:
+                continue
+            
+            node_bundle = self.cache.read(node_rid)
+            
+            node_profile = node_bundle.validate_contents(NodeProfile)
+            
+            if (node_profile.node_type == NodeType.FULL) and (rid_type in node_profile.provides.state):
+                logger.debug(f"Found provider {node_rid!r}")
+                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) -> tuple[Bundle | None, KoiNetNode | None]:
+        """Attempts to fetch a bundle by RID from known peer nodes."""
+        
+        logger.debug(f"Fetching remote bundle {rid!r}")
+        remote_bundle, node_rid = None, 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!r}")
+                break
+        
+        if not remote_bundle:
+            logger.warning("Failed to fetch remote bundle")
+            
+        return remote_bundle, node_rid
+    
+    def fetch_remote_manifest(self, rid: RID) -> tuple[Bundle | None, KoiNetNode | None]:
+        """Attempts to fetch a manifest by RID from known peer nodes."""
+        
+        logger.debug(f"Fetching remote manifest {rid!r}")
+        remote_manifest, node_rid = None, 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!r}")
+                break
+        
+        if not remote_manifest:
+            logger.warning("Failed to fetch remote bundle")
+            
+        return remote_manifest, node_rid
+    
+    def poll_neighbors(self) -> dict[KoiNetNode, 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.
+        """
+        
+        graph_neighbors = self.graph.get_neighbors()
+        neighbors = []
+        
+        if graph_neighbors:
+            for node_rid in graph_neighbors:
+                node_bundle = self.cache.read(node_rid)
+                if not node_bundle: 
+                    continue
+                node_profile = node_bundle.validate_contents(NodeProfile)
+                if node_profile.node_type != NodeType.FULL: 
+                    continue
+                neighbors.append(node_rid)
+            
+        elif self.config.koi_net.first_contact.rid:
+            neighbors.append(self.config.koi_net.first_contact.rid)
+        
+        event_dict = dict()
+        for node_rid in neighbors:
+            try:
+                payload = self.request_handler.poll_events(
+                    node=node_rid, 
+                    rid=self.identity.rid
+                )
+                
+                if type(payload) == ErrorResponse:
+                    continue
+                    
+                if payload.events:
+                    logger.debug(f"Received {len(payload.events)} events from {node_rid!r}")
+                    
+                    event_dict[node_rid] = payload.events
+                    
+            except httpx.ConnectError:
+                logger.debug(f"Failed to reach node {node_rid!r}")
+                continue
+        
+        return event_dict

koi_net/network/response_handler.py

@@ -2,6 +2,7 @@ import logging
 from rid_lib import RID
 from rid_lib.ext import Manifest, Cache
 from rid_lib.ext.bundle import Bundle
+
 from ..protocol.api_models import (
     RidsPayload,
     ManifestsPayload,
@@ -10,6 +11,7 @@ from ..protocol.api_models import (
     FetchManifests,
     FetchBundles,
 )
+from ..effector import Effector
 
 logger = logging.getLogger(__name__)
 
@@ -18,9 +20,15 @@ class ResponseHandler:
     """Handles generating responses to requests from other KOI nodes."""
     
     cache: Cache
+    effector: Effector
     
-    def __init__(self, cache: Cache):
+    def __init__(
+        self, 
+        cache: Cache, 
+        effector: Effector,
+    ):
         self.cache = cache
+        self.effector = effector
         
     def fetch_rids(self, req: FetchRids) -> RidsPayload:
         logger.info(f"Request to fetch rids, allowed types {req.rid_types}")
@@ -35,7 +43,7 @@ class ResponseHandler:
         not_found: list[RID] = []
         
         for rid in (req.rids or self.cache.list_rids(req.rid_types)):
-            bundle = self.cache.read(rid)
+            bundle = self.effector.deref(rid)
             if bundle:
                 manifests.append(bundle.manifest)
             else:
@@ -50,7 +58,7 @@ class ResponseHandler:
         not_found: list[RID] = []
 
         for rid in req.rids:
-            bundle = self.cache.read(rid)
+            bundle = self.effector.deref(rid)
             if bundle:
                 bundles.append(bundle)
             else:

koi_net/processor/__init__.py

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

koi_net/processor/default_handlers.py

@@ -1,29 +1,28 @@
 """Provides implementations of default knowledge handlers."""
 
 import logging
-from rid_lib.ext.bundle import Bundle
+from rid_lib.ext import Bundle
+from rid_lib.ext.utils import sha256_hash
 from rid_lib.types import KoiNetNode, KoiNetEdge
 from koi_net.protocol.node import NodeType
-from .interface import ProcessorInterface
 from .handler import KnowledgeHandler, HandlerType, STOP_CHAIN
-from .knowledge_object import KnowledgeObject, KnowledgeSource
+from .knowledge_object import KnowledgeObject
+from ..context import HandlerContext
 from ..protocol.event import Event, EventType
-from ..protocol.edge import EdgeProfile, EdgeStatus, EdgeType
+from ..protocol.edge import EdgeProfile, EdgeStatus, EdgeType, generate_edge_bundle
 from ..protocol.node import NodeProfile
-from ..protocol.helpers import generate_edge_bundle
 
 logger = logging.getLogger(__name__)
 
 # RID handlers
 
 @KnowledgeHandler.create(HandlerType.RID)
-def basic_rid_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
+def basic_rid_handler(ctx: HandlerContext, kobj: KnowledgeObject):
     """Default RID handler.
     
     Blocks external events about this node. Allows `FORGET` events if RID is known to this node.
     """
-    if (kobj.rid == processor.identity.rid and 
-        kobj.source == KnowledgeSource.External):
+    if (kobj.rid == ctx.identity.rid and kobj.source):
         logger.debug("Don't let anyone else tell me who I am!")
         return STOP_CHAIN
     
@@ -34,12 +33,12 @@ def basic_rid_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
 # Manifest handlers
 
 @KnowledgeHandler.create(HandlerType.Manifest)
-def basic_manifest_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
+def basic_manifest_handler(ctx: HandlerContext, kobj: KnowledgeObject):
     """Default manifest handler.
     
     Blocks manifests with the same hash, or aren't newer than the cached version. Sets the normalized event type to `NEW` or `UPDATE` depending on whether the RID was previously known to this node.
     """
-    prev_bundle = processor.cache.read(kobj.rid)
+    prev_bundle = ctx.cache.read(kobj.rid)
 
     if prev_bundle:
         if kobj.manifest.sha256_hash == prev_bundle.manifest.sha256_hash:
@@ -61,36 +60,53 @@ def basic_manifest_handler(processor: ProcessorInterface, kobj: KnowledgeObject)
 
 # Bundle handlers
 
+@KnowledgeHandler.create(
+    handler_type=HandlerType.Bundle,
+    rid_types=[KoiNetNode],
+    event_types=[EventType.NEW, EventType.UPDATE]
+)
+def secure_profile_handler(ctx: HandlerContext, kobj: KnowledgeObject):
+    node_profile = kobj.bundle.validate_contents(NodeProfile)
+    node_rid: KoiNetNode = kobj.rid
+    
+    if sha256_hash(node_profile.public_key) != node_rid.hash:
+        logger.warning(f"Public key hash mismatch for {node_rid!r}!")
+        return STOP_CHAIN
+
 @KnowledgeHandler.create(
     handler_type=HandlerType.Bundle, 
     rid_types=[KoiNetEdge], 
-    source=KnowledgeSource.External,
     event_types=[EventType.NEW, EventType.UPDATE])
-def edge_negotiation_handler(processor: ProcessorInterface, kobj: KnowledgeObject):
+def edge_negotiation_handler(ctx: HandlerContext, kobj: KnowledgeObject):
     """Handles basic edge negotiation process.
     
     Automatically approves proposed edges if they request RID types this node can provide (or KOI nodes/edges). Validates the edge type is allowed for the node type (partial nodes cannot use webhooks). If edge is invalid, a `FORGET` event is sent to the other node.
     """
+
+    # only respond when source is another node
+    if kobj.source is None: return
     
-    edge_profile = EdgeProfile.model_validate(kobj.contents)
+    edge_profile = kobj.bundle.validate_contents(EdgeProfile)
 
     # indicates peer subscribing to me
-    if edge_profile.source == processor.identity.rid:     
+    if edge_profile.source == ctx.identity.rid:     
         if edge_profile.status != EdgeStatus.PROPOSED:
             return
         
         logger.debug("Handling edge negotiation")
         
         peer_rid = edge_profile.target
-        peer_profile = processor.network.graph.get_node_profile(peer_rid)
+        peer_bundle = ctx.effector.deref(peer_rid)
         
-        if not peer_profile:
-            logger.warning(f"Peer {peer_rid} unknown to me")
+        if not peer_bundle:
+            logger.warning(f"Peer {peer_rid!r} unknown to me")
             return STOP_CHAIN
         
+        peer_profile = peer_bundle.validate_contents(NodeProfile)
+        
         # explicitly provided event RID types and (self) node + edge objects
         provided_events = (
-            *processor.identity.profile.provides.event,
+            *ctx.identity.profile.provides.event,
             KoiNetNode, KoiNetEdge
         )
         
@@ -107,7 +123,7 @@ def edge_negotiation_handler(processor: ProcessorInterface, kobj: KnowledgeObjec
         
         if abort:
             event = Event.from_rid(EventType.FORGET, kobj.rid)
-            processor.network.push_event_to(event, peer_rid, flush=True)
+            ctx.event_queue.push_event_to(event, peer_rid, flush=True)
             return STOP_CHAIN
 
         else:
@@ -116,10 +132,10 @@ def edge_negotiation_handler(processor: ProcessorInterface, kobj: KnowledgeObjec
             edge_profile.status = EdgeStatus.APPROVED
             updated_bundle = Bundle.generate(kobj.rid, edge_profile.model_dump())
       
-            processor.handle(bundle=updated_bundle, event_type=EventType.UPDATE)
+            ctx.handle(bundle=updated_bundle, event_type=EventType.UPDATE)
             return
               
-    elif edge_profile.target == processor.identity.rid:
+    elif edge_profile.target == ctx.identity.rid:
         if edge_profile.status == EdgeStatus.APPROVED:
             logger.debug("Edge approved by other node!")
 
@@ -127,88 +143,88 @@ def edge_negotiation_handler(processor: ProcessorInterface, kobj: KnowledgeObjec
 # Network handlers
 
 @KnowledgeHandler.create(HandlerType.Network, rid_types=[KoiNetNode])
-def coordinator_contact(processor: ProcessorInterface, kobj: KnowledgeObject):
+def coordinator_contact(ctx: HandlerContext, kobj: KnowledgeObject):
     node_profile = kobj.bundle.validate_contents(NodeProfile)
-    
+            
     # looking for event provider of nodes
     if KoiNetNode not in node_profile.provides.event:
         return
     
     # prevents coordinators from attempting to form a self loop
-    if kobj.rid == processor.identity.rid:
+    if kobj.rid == ctx.identity.rid:
         return
     
     # already have an edge established
-    if processor.network.graph.get_edge_profile(
+    if ctx.graph.get_edge(
         source=kobj.rid,
-        target=processor.identity.rid,
+        target=ctx.identity.rid,
     ) is not None:
         return
     
     logger.info("Identified a coordinator!")
     logger.info("Proposing new edge")
     
-    if processor.identity.profile.node_type == NodeType.FULL:
+    if ctx.identity.profile.node_type == NodeType.FULL:
         edge_type = EdgeType.WEBHOOK
     else:
         edge_type = EdgeType.POLL
     
     # queued for processing
-    processor.handle(bundle=generate_edge_bundle(
+    ctx.handle(bundle=generate_edge_bundle(
         source=kobj.rid,
-        target=processor.identity.rid,
+        target=ctx.identity.rid,
         edge_type=edge_type,
         rid_types=[KoiNetNode]
     ))
     
     logger.info("Catching up on network state")
     
-    payload = processor.network.request_handler.fetch_rids(
+    payload = ctx.request_handler.fetch_rids(
         node=kobj.rid, 
         rid_types=[KoiNetNode]
     )
     for rid in payload.rids:
-        if rid == processor.identity.rid:
+        if rid == ctx.identity.rid:
             logger.info("Skipping myself")
             continue
-        if processor.cache.exists(rid):
-            logger.info(f"Skipping known RID '{rid}'")
+        if ctx.cache.exists(rid):
+            logger.info(f"Skipping known RID {rid!r}")
             continue
         
         # marked as external since we are handling RIDs from another node
         # will fetch remotely instead of checking local cache
-        processor.handle(rid=rid, source=KnowledgeSource.External)
+        ctx.handle(rid=rid, source=kobj.rid)
     logger.info("Done")
     
 
 @KnowledgeHandler.create(HandlerType.Network)
-def basic_network_output_filter(processor: ProcessorInterface, kobj: KnowledgeObject):
+def basic_network_output_filter(ctx: HandlerContext, kobj: KnowledgeObject):
     """Default network handler.
     
     Allows broadcasting of all RID types this node is an event provider for (set in node profile), and other nodes have subscribed to. All nodes will also broadcast about their own (internally sourced) KOI node, and KOI edges that they are part of, regardless of their node profile configuration. Finally, nodes will also broadcast about edges to the other node involved (regardless of if they are subscribed)."""
     
     involves_me = False
-    if kobj.source == KnowledgeSource.Internal:
+    if kobj.source is None:
         if (type(kobj.rid) == KoiNetNode):
-            if (kobj.rid == processor.identity.rid):
+            if (kobj.rid == ctx.identity.rid):
                 involves_me = True
         
         elif type(kobj.rid) == KoiNetEdge:
             edge_profile = kobj.bundle.validate_contents(EdgeProfile)
             
-            if edge_profile.source == processor.identity.rid:
+            if edge_profile.source == ctx.identity.rid:
                 logger.debug(f"Adding edge target '{edge_profile.target!r}' to network targets")
                 kobj.network_targets.update([edge_profile.target])
                 involves_me = True
                 
-            elif edge_profile.target == processor.identity.rid:
+            elif edge_profile.target == ctx.identity.rid:
                 logger.debug(f"Adding edge source '{edge_profile.source!r}' to network targets")
                 kobj.network_targets.update([edge_profile.source])
                 involves_me = True
     
-    if (type(kobj.rid) in processor.identity.profile.provides.event or involves_me):
+    if (type(kobj.rid) in ctx.identity.profile.provides.event or involves_me):
         # broadcasts to subscribers if I'm an event provider of this RID type OR it involves me
-        subscribers = processor.network.graph.get_neighbors(
+        subscribers = ctx.graph.get_neighbors(
             direction="out",
             allowed_type=type(kobj.rid)
         )

koi_net/processor/handler.py

@@ -2,9 +2,7 @@ from dataclasses import dataclass
 from enum import StrEnum
 from typing import Callable
 from rid_lib import RIDType
-
 from ..protocol.event import EventType
-from .knowledge_object import KnowledgeSource, KnowledgeEventType
 
 
 class StopChain:
@@ -37,23 +35,21 @@ class KnowledgeHandler:
     func: Callable
     handler_type: HandlerType
     rid_types: list[RIDType] | None
-    source: KnowledgeSource | None = None
-    event_types: list[KnowledgeEventType] | None = None
+    event_types: list[EventType | None] | None = None
     
     @classmethod
     def create(
         cls,
         handler_type: HandlerType,
         rid_types: list[RIDType] | None = None,
-        source: KnowledgeSource | None = None,
-        event_types: list[KnowledgeEventType] | None = None
+        event_types: list[EventType | None] | None = None
     ):
         """Special decorator that returns a KnowledgeHandler instead of a function.
         
         The function symbol will redefined as a `KnowledgeHandler`, which can be passed into the `ProcessorInterface` constructor. This is used to register default handlers.
         """
         def decorator(func: Callable) -> KnowledgeHandler:
-            handler = cls(func, handler_type, rid_types, source, event_types)
+            handler = cls(func, handler_type, rid_types, event_types)
             return handler
         return decorator