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

koi_net/network/request_handler.py

@@ -1,8 +1,9 @@
 import logging
 import httpx
 from rid_lib import RID
-from rid_lib.ext import Cache
 from rid_lib.types.koi_net_node import KoiNetNode
+
+from ..identity import NodeIdentity
 from ..protocol.api_models import (
     RidsPayload,
     ManifestsPayload,
@@ -13,8 +14,10 @@ from ..protocol.api_models import (
     FetchBundles,
     PollEvents,
     RequestModels,
-    ResponseModels
+    ResponseModels,
+    ErrorResponse
 )
+from ..protocol.envelope import SignedEnvelope
 from ..protocol.consts import (
     BROADCAST_EVENTS_PATH,
     POLL_EVENTS_PATH,
@@ -22,128 +25,188 @@ from ..protocol.consts import (
     FETCH_MANIFESTS_PATH,
     FETCH_BUNDLES_PATH
 )
-from ..protocol.node import NodeType
-from .graph import NetworkGraph
+from ..protocol.node import NodeProfile, NodeType
+from ..secure import Secure
+from ..effector import Effector
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from .error_handler import ErrorHandler
 
 
 logger = logging.getLogger(__name__)
 
 
+# Custom error types for request handling
+class SelfRequestError(Exception):
+    """Raised when a node tries to request itself."""
+    pass
+
+class PartialNodeQueryError(Exception):
+    """Raised when attempting to query a partial node."""
+    pass
+
+class NodeNotFoundError(Exception):
+    """Raised when a node URL cannot be found."""
+    pass
+
+class UnknownPathError(Exception):
+    """Raised when an unknown path is requested."""
+    pass
+
 class RequestHandler:
     """Handles making requests to other KOI nodes."""
     
-    cache: Cache
-    graph: NetworkGraph
+    effector: Effector
+    identity: NodeIdentity
+    secure: Secure
+    error_handler: "ErrorHandler"
     
-    def __init__(self, cache: Cache, graph: NetworkGraph):
-        self.cache = cache
-        self.graph = graph
+    def __init__(
+        self, 
+        effector: Effector,
+        identity: NodeIdentity,
+        secure: Secure
+    ):
+        self.effector = effector
+        self.identity = identity
+        self.secure = secure
+        
+    def set_error_handler(self, error_handler: "ErrorHandler"):
+        self.error_handler = error_handler
+    
+    def get_url(self, node_rid: KoiNetNode) -> str:
+        """Retrieves URL of a node."""
+        
+        logger.debug(f"Getting URL for {node_rid!r}")
+        node_url = None
+        
+        if node_rid == self.identity.rid:
+            raise SelfRequestError("Don't talk to yourself")
+        
+        node_bundle = self.effector.deref(node_rid)
                 
+        if node_bundle:
+            node_profile = node_bundle.validate_contents(NodeProfile)
+            logger.debug(f"Found node profile: {node_profile}")
+            if node_profile.node_type != NodeType.FULL:
+                raise PartialNodeQueryError("Can't query partial node")
+            node_url = node_profile.base_url
+        
+        else:
+            if node_rid == self.identity.config.koi_net.first_contact.rid:
+                logger.debug("Found URL of first contact")
+                node_url = self.identity.config.koi_net.first_contact.url
+        
+        if not node_url:
+            raise NodeNotFoundError("Node not found")
+        
+        logger.debug(f"Resolved {node_rid!r} to {node_url}")
+        return node_url
+    
     def make_request(
-        self, 
-        url: str, 
+        self,
+        node: KoiNetNode,
+        path: str, 
         request: RequestModels,
-        response_model: type[ResponseModels] | None = None
     ) -> ResponseModels | None:
-        logger.debug(f"Making request to {url}")
-        resp = httpx.post(
-            url=url,
-            data=request.model_dump_json()
+        url = self.get_url(node) + path
+        logger.info(f"Making request to {url}")
+    
+        signed_envelope = self.secure.create_envelope(
+            payload=request,
+            target=node
         )
-        if response_model:
-            return response_model.model_validate_json(resp.text)
-            
-    def get_url(self, node_rid: KoiNetNode, url: str) -> str:
-        """Retrieves URL of a node, or returns provided URL."""
         
-        if not node_rid and not url:
-            raise ValueError("One of 'node_rid' and 'url' must be provided")
+        try:
+            result = httpx.post(url, data=signed_envelope.model_dump_json(exclude_none=True))
+        except httpx.ConnectError as err:
+            logger.debug("Failed to connect")
+            self.error_handler.handle_connection_error(node)
+            raise err
         
-        if node_rid:
-            node_profile = self.graph.get_node_profile(node_rid)
-            if not node_profile:
-                raise Exception("Node not found")
-            if node_profile.node_type != NodeType.FULL:
-                raise Exception("Can't query partial node")
-            logger.debug(f"Resolved {node_rid!r} to {node_profile.base_url}")
-            return node_profile.base_url
+        if result.status_code != 200:
+            resp = ErrorResponse.model_validate_json(result.text)
+            self.error_handler.handle_protocol_error(resp.error, node)
+            return resp
+        
+        if path == BROADCAST_EVENTS_PATH:
+            return None
+        elif path == POLL_EVENTS_PATH:
+            EnvelopeModel = SignedEnvelope[EventsPayload]
+        elif path == FETCH_RIDS_PATH:
+            EnvelopeModel = SignedEnvelope[RidsPayload]
+        elif path == FETCH_MANIFESTS_PATH:
+            EnvelopeModel = SignedEnvelope[ManifestsPayload]
+        elif path == FETCH_BUNDLES_PATH:
+            EnvelopeModel = SignedEnvelope[BundlesPayload]
         else:
-            return url
+            raise UnknownPathError(f"Unknown path '{path}'")
+        
+        resp_envelope = EnvelopeModel.model_validate_json(result.text)
+        self.secure.validate_envelope(resp_envelope)
+        
+        return resp_envelope.payload
     
     def broadcast_events(
         self, 
-        node: RID = None, 
-        url: str = None, 
+        node: RID, 
         req: EventsPayload | None = None,
         **kwargs
     ) -> None:
         """See protocol.api_models.EventsPayload for available kwargs."""
         request = req or EventsPayload.model_validate(kwargs)
-        self.make_request(
-            self.get_url(node, url) + BROADCAST_EVENTS_PATH, request
-        )
-        logger.info(f"Broadcasted {len(request.events)} event(s) to {node or url!r}")
+        self.make_request(node, BROADCAST_EVENTS_PATH, request)
+        logger.info(f"Broadcasted {len(request.events)} event(s) to {node!r}")
         
     def poll_events(
         self, 
-        node: RID = None, 
-        url: str = None, 
+        node: RID, 
         req: PollEvents | None = None,
         **kwargs
     ) -> EventsPayload:
         """See protocol.api_models.PollEvents for available kwargs."""
         request = req or PollEvents.model_validate(kwargs)
-        resp = self.make_request(
-            self.get_url(node, url) + POLL_EVENTS_PATH, request,
-            response_model=EventsPayload
-        )
-        logger.info(f"Polled {len(resp.events)} events from {node or url!r}")
+        resp = self.make_request(node, POLL_EVENTS_PATH, request)
+        if type(resp) != ErrorResponse:
+            logger.info(f"Polled {len(resp.events)} events from {node!r}")
         return resp
         
     def fetch_rids(
         self, 
-        node: RID = None, 
-        url: str = None, 
+        node: RID, 
         req: FetchRids | None = None,
         **kwargs
     ) -> RidsPayload:
         """See protocol.api_models.FetchRids for available kwargs."""
         request = req or FetchRids.model_validate(kwargs)
-        resp = self.make_request(
-            self.get_url(node, url) + FETCH_RIDS_PATH, request,
-            response_model=RidsPayload
-        )
-        logger.info(f"Fetched {len(resp.rids)} RID(s) from {node or url!r}")
+        resp = self.make_request(node, FETCH_RIDS_PATH, request)
+        if type(resp) != ErrorResponse:
+            logger.info(f"Fetched {len(resp.rids)} RID(s) from {node!r}")
         return resp
                 
     def fetch_manifests(
         self, 
-        node: RID = None, 
-        url: str = None, 
+        node: RID, 
         req: FetchManifests | None = None,
         **kwargs
     ) -> ManifestsPayload:
         """See protocol.api_models.FetchManifests for available kwargs."""
         request = req or FetchManifests.model_validate(kwargs)
-        resp = self.make_request(
-            self.get_url(node, url) + FETCH_MANIFESTS_PATH, request,
-            response_model=ManifestsPayload
-        )
-        logger.info(f"Fetched {len(resp.manifests)} manifest(s) from {node or url!r}")
+        resp = self.make_request(node, FETCH_MANIFESTS_PATH, request)
+        if type(resp) != ErrorResponse:
+            logger.info(f"Fetched {len(resp.manifests)} manifest(s) from {node!r}")
         return resp
                 
     def fetch_bundles(
         self, 
-        node: RID = None, 
-        url: str = None, 
+        node: RID, 
         req: FetchBundles | None = None,
         **kwargs
     ) -> BundlesPayload:
         """See protocol.api_models.FetchBundles for available kwargs."""
         request = req or FetchBundles.model_validate(kwargs)
-        resp = self.make_request(
-            self.get_url(node, url) + FETCH_BUNDLES_PATH, request,
-            response_model=BundlesPayload
-        )
-        logger.info(f"Fetched {len(resp.bundles)} bundle(s) from {node or url!r}")
+        resp = self.make_request(node, FETCH_BUNDLES_PATH, request)
+        if type(resp) != ErrorResponse:
+            logger.info(f"Fetched {len(resp.bundles)} bundle(s) from {node!r}")
         return resp

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

@@ -1,7 +1,9 @@
 import logging
 from rid_lib import RID
+from rid_lib.types import KoiNetNode
 from rid_lib.ext import Manifest, Cache
 from rid_lib.ext.bundle import Bundle
+
 from ..protocol.api_models import (
     RidsPayload,
     ManifestsPayload,
@@ -10,6 +12,7 @@ from ..protocol.api_models import (
     FetchManifests,
     FetchBundles,
 )
+from ..effector import Effector
 
 logger = logging.getLogger(__name__)
 
@@ -18,24 +21,30 @@ 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:
+    def fetch_rids(self, req: FetchRids, source: KoiNetNode) -> RidsPayload:
         logger.info(f"Request to fetch rids, allowed types {req.rid_types}")
         rids = self.cache.list_rids(req.rid_types)
         
         return RidsPayload(rids=rids)
         
-    def fetch_manifests(self, req: FetchManifests) -> ManifestsPayload:
+    def fetch_manifests(self, req: FetchManifests, source: KoiNetNode) -> ManifestsPayload:
         logger.info(f"Request to fetch manifests, allowed types {req.rid_types}, rids {req.rids}")
         
         manifests: list[Manifest] = []
         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:
@@ -43,14 +52,14 @@ class ResponseHandler:
         
         return ManifestsPayload(manifests=manifests, not_found=not_found)
         
-    def fetch_bundles(self, req: FetchBundles) -> BundlesPayload:
+    def fetch_bundles(self, req: FetchBundles, source: KoiNetNode) -> BundlesPayload:
         logger.info(f"Request to fetch bundles, requested rids {req.rids}")
         
         bundles: list[Bundle] = []
         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/poller.py

@@ -0,0 +1,40 @@
+
+import time
+import logging
+from .processor.interface import ProcessorInterface
+from .lifecycle import NodeLifecycle
+from .network.resolver import NetworkResolver
+from .config import NodeConfig
+
+logger = logging.getLogger(__name__)
+
+
+class NodePoller:
+    def __init__(
+        self,
+        processor: ProcessorInterface,
+        lifecycle: NodeLifecycle,
+        resolver: NetworkResolver,
+        config: NodeConfig
+    ):
+        self.processor = processor
+        self.lifecycle = lifecycle
+        self.resolver = resolver
+        self.config = config
+
+    def poll(self):
+        neighbors = self.resolver.poll_neighbors()
+        for node_rid in neighbors:
+            for event in neighbors[node_rid]:
+                self.processor.handle(event=event, source=node_rid)
+        self.processor.flush_kobj_queue()
+
+    def run(self):
+        with self.lifecycle.run():
+            while True:
+                start_time = time.time()
+                self.poll()
+                elapsed = time.time() - start_time
+                sleep_time = self.config.koi_net.polling_interval - elapsed
+                if sleep_time > 0:
+                    time.sleep(sleep_time)

koi_net/processor/__init__.py

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