koi-net 1.1.0b8__py3-none-any.whl → 1.2.0b1__py3-none-any.whl

koi_net/core.py

@@ -1,194 +1,233 @@
-import logging
-from typing import Generic, TypeVar
+from dataclasses import dataclass
 from rid_lib.ext import Cache
-from .network.resolver import NetworkResolver
-from .network.event_queue import NetworkEventQueue
-from .network.graph import NetworkGraph
-from .network.request_handler import RequestHandler
-from .network.response_handler import ResponseHandler
-from .network.error_handler import ErrorHandler
-from .actor import Actor
-from .processor.interface import ProcessorInterface
-from .processor import default_handlers
-from .processor.handler import KnowledgeHandler
-from .processor.knowledge_pipeline import KnowledgePipeline
-from .identity import NodeIdentity
-from .secure import Secure
-from .config import NodeConfig
-from .context import HandlerContext, ActionContext
-from .effector import Effector
-from .server import NodeServer
-from .lifecycle import NodeLifecycle
-from .poller import NodePoller
-from . import default_actions
+from koi_net.behaviors import Behaviors
+from koi_net.config import NodeConfig
+from koi_net.context import ActionContext, HandlerContext
+from koi_net.effector import Effector
+from koi_net.handshaker import Handshaker
+from koi_net.identity import NodeIdentity
+from koi_net.kobj_worker import KnowledgeProcessingWorker
+from koi_net.lifecycle import NodeLifecycle
+from koi_net.network.error_handler import ErrorHandler
+from koi_net.network.event_queue import EventQueue
+from koi_net.network.graph import NetworkGraph
+from koi_net.network.request_handler import RequestHandler
+from koi_net.network.resolver import NetworkResolver
+from koi_net.network.response_handler import ResponseHandler
+from koi_net.poll_event_buffer import PollEventBuffer
+from koi_net.poller import NodePoller
+from koi_net.processor.default_handlers import (
+    basic_manifest_handler, 
+    basic_network_output_filter, 
+    basic_rid_handler, 
+    node_contact_handler, 
+    edge_negotiation_handler, 
+    forget_edge_on_node_deletion, 
+    secure_profile_handler
+)
+from koi_net.processor.event_worker import EventProcessingWorker
+from koi_net.processor.knowledge_pipeline import KnowledgePipeline
+from koi_net.processor.kobj_queue import KobjQueue
+from koi_net.secure import Secure
+from koi_net.server import NodeServer
 
-logger = logging.getLogger(__name__)
 
-
-T = TypeVar("T", bound=NodeConfig)
-
-class NodeInterface(Generic[T]):
-    config: T
+@dataclass
+class NodeContainer:
+    poll_event_buf: PollEventBuffer
+    kobj_queue: KobjQueue
+    event_queue: EventQueue
+    config: NodeConfig
     cache: Cache
     identity: NodeIdentity
-    resolver: NetworkResolver
-    event_queue: NetworkEventQueue
     graph: NetworkGraph
-    processor: ProcessorInterface
     secure: Secure
+    request_handler: RequestHandler
+    response_handler: ResponseHandler
+    resolver: NetworkResolver
+    handler_context: HandlerContext
+    behaviors: Behaviors
+    pipeline: KnowledgePipeline
+    kobj_worker: KnowledgeProcessingWorker
+    event_worker: EventProcessingWorker
+    error_handler: ErrorHandler
+    lifecycle: NodeLifecycle
     server: NodeServer
+    poller: NodePoller
     
-    use_kobj_processor_thread: bool
+
+class NodeAssembler:
+    poll_event_buf = PollEventBuffer
+    kobj_queue = KobjQueue
+    event_queue = EventQueue
+    config = NodeConfig
+    cache = Cache
+    identity = NodeIdentity
+    graph = NetworkGraph
+    secure = Secure
+    handshaker = Handshaker
+    request_handler = RequestHandler
+    response_handler = ResponseHandler
+    resolver = NetworkResolver
+    knowledge_handlers = [
+        basic_rid_handler,
+        basic_manifest_handler,
+        secure_profile_handler,
+        edge_negotiation_handler,
+        node_contact_handler,
+        basic_network_output_filter,
+        forget_edge_on_node_deletion
+    ]
+    handler_context = HandlerContext
+    action_context = ActionContext
+    effector = Effector
+    behaviors = Behaviors
+    pipeline = KnowledgePipeline
+    kobj_worker = KnowledgeProcessingWorker
+    event_worker = EventProcessingWorker
+    error_handler = ErrorHandler
+    lifecycle = NodeLifecycle
+    server = NodeServer
+    poller = NodePoller
     
-    def __init__(
-        self,
-        config: T,
-        use_kobj_processor_thread: bool = False,
-        handlers: list[KnowledgeHandler] | None = None,
-        
-        CacheOverride: type[Cache] | None = None,
-        NodeIdentityOverride: type[NodeIdentity] | None = None,
-        EffectorOverride: type[Effector] | None = None,
-        NetworkGraphOverride: type[NetworkGraph] | None = None,
-        SecureOverride: type[Secure] | None = None,
-        RequestHandlerOverride: type[RequestHandler] | None = None,
-        ResponseHandlerOverride: type[ResponseHandler] | None = None,
-        NetworkResolverOverride: type[NetworkResolver] | None = None,
-        NetworkEventQueueOverride: type[NetworkEventQueue] | None = None,
-        ActorOverride: type[Actor] | None = None,
-        ActionContextOverride: type[ActionContext] | None = None,
-        HandlerContextOverride: type[HandlerContext] | None = None,
-        KnowledgePipelineOverride: type[KnowledgePipeline] | None = None,
-        ProcessorInterfaceOverride: type[ProcessorInterface] | None = None,
-        ErrorHandlerOverride: type[ErrorHandler] | None = None,
-        NodeLifecycleOverride: type[NodeLifecycle] | None = None,
-        NodeServerOverride: type[NodeServer] | None = None,
-        NodePollerOverride: type[NodePoller] | None = None,        
-    ):
-        self.config = config
-        self.cache = (CacheOverride or Cache)(
-            directory_path=self.config.koi_net.cache_directory_path
+    @classmethod
+    def create(cls) -> NodeContainer:
+        poll_event_buffer = cls.poll_event_buf()
+        kobj_queue = cls.kobj_queue()
+        event_queue = cls.event_queue()
+        config = cls.config.load_from_yaml()
+        cache = cls.cache(
+            directory_path=config.koi_net.cache_directory_path
         )
-
-        self.identity = (NodeIdentityOverride or NodeIdentity)(config=self.config)
-        self.effector = (EffectorOverride or Effector)(cache=self.cache)
-
-        self.graph = (NetworkGraphOverride or NetworkGraph)(
-            cache=self.cache,
-            identity=self.identity
+        identity = cls.identity(
+            config=config
         )
-
-        self.secure = (SecureOverride or Secure)(
-            identity=self.identity,
-            effector=self.effector,
-            config=self.config
+        graph = cls.graph(
+            cache=cache,
+            identity=identity
         )
-
-        self.request_handler = (RequestHandlerOverride or RequestHandler)(
-            effector=self.effector,
-            identity=self.identity,
-            secure=self.secure
+        secure = cls.secure(
+            identity=identity,
+            cache=cache,
+            config=config
         )
-
-        self.response_handler = (ResponseHandlerOverride or ResponseHandler)(self.cache, self.effector)
-
-        self.resolver = (NetworkResolverOverride or NetworkResolver)(
-            config=self.config,
-            cache=self.cache,
-            identity=self.identity,
-            graph=self.graph,
-            request_handler=self.request_handler,
-            effector=self.effector
+        handshaker = cls.handshaker(
+            cache=cache,
+            identity=identity,
+            event_queue=event_queue
         )
-
-        self.event_queue = (NetworkEventQueueOverride or NetworkEventQueue)(
-            config=self.config,
-            cache=self.cache,
-            identity=self.identity,
-            graph=self.graph,
-            request_handler=self.request_handler,
-            effector=self.effector
+        error_handler = cls.error_handler(
+            kobj_queue=kobj_queue,
+            handshaker=handshaker
         )
-        
-        self.actor = (ActorOverride or Actor)()
-        
-        # pull all handlers defined in default_handlers module
-        if handlers is None:
-            handlers = [
-                obj for obj in vars(default_handlers).values() 
-                if isinstance(obj, KnowledgeHandler)
-            ]
-
-        self.use_kobj_processor_thread = use_kobj_processor_thread
-        
-        self.action_context = (ActionContextOverride or ActionContext)(
-            identity=self.identity,
-            effector=self.effector
+        request_handler = cls.request_handler(
+            cache=cache,
+            identity=identity,
+            secure=secure,
+            error_handler=error_handler
         )
-        
-        self.handler_context = (HandlerContextOverride or HandlerContext)(
-            identity=self.identity,
-            config=self.config,
-            cache=self.cache,
-            event_queue=self.event_queue,
-            graph=self.graph,
-            request_handler=self.request_handler,
-            resolver=self.resolver,
-            effector=self.effector
+        response_handler = cls.response_handler(
+            cache=cache
         )
-        
-        self.pipeline = (KnowledgePipelineOverride or KnowledgePipeline)(
-            handler_context=self.handler_context,
-            cache=self.cache,
-            request_handler=self.request_handler,
-            event_queue=self.event_queue,
-            graph=self.graph,
-            default_handlers=handlers
+        resolver = cls.resolver(
+            config=config,
+            cache=cache,
+            identity=identity,
+            graph=graph,
+            request_handler=request_handler
         )
-        
-        self.processor = (ProcessorInterfaceOverride or ProcessorInterface)(
-            pipeline=self.pipeline,
-            use_kobj_processor_thread=self.use_kobj_processor_thread
+        handler_context = cls.handler_context(
+            identity=identity,
+            config=config,
+            cache=cache,
+            event_queue=event_queue,
+            kobj_queue=kobj_queue,
+            graph=graph,
+            request_handler=request_handler,
+            resolver=resolver
         )
-        
-        self.error_handler = (ErrorHandlerOverride or ErrorHandler)(
-            processor=self.processor,
-            actor=self.actor
+        action_context = cls.action_context(
+            identity=identity
         )
-        
-        self.request_handler.set_error_handler(self.error_handler)
-        
-        self.handler_context.set_processor(self.processor)
-        
-        self.effector.set_processor(self.processor)
-        self.effector.set_resolver(self.resolver)
-        self.effector.set_action_context(self.action_context)
-        
-        self.actor.set_ctx(self.handler_context)
-        
-        self.lifecycle = (NodeLifecycleOverride or NodeLifecycle)(
-            config=self.config,
-            identity=self.identity,
-            graph=self.graph,
-            processor=self.processor,
-            effector=self.effector,
-            actor=self.actor,
-            use_kobj_processor_thread=use_kobj_processor_thread
+        effector = cls.effector(
+            cache=cache,
+            resolver=resolver,
+            kobj_queue=kobj_queue,
+            action_context=action_context
         )
-        
-        # if self.config.koi_net.node_profile.node_type == NodeType.FULL:
-        self.server = (NodeServerOverride or NodeServer)(
-            config=self.config,
-            lifecycle=self.lifecycle,
-            secure=self.secure,
-            processor=self.processor,
-            event_queue=self.event_queue,
-            response_handler=self.response_handler
+        behaviors = cls.behaviors(
+            cache=cache,
+            identity=identity,
+            event_queue=event_queue,
+            resolver=resolver,
+            request_handler=request_handler,
+            kobj_queue=kobj_queue
         )
-        
-        self.poller = (NodePollerOverride or NodePoller)(
-            processor=self.processor,
-            lifecycle=self.lifecycle,
-            resolver=self.resolver,
-            config=self.config
+        pipeline = cls.pipeline(
+            handler_context=handler_context,
+            cache=cache,
+            request_handler=request_handler,
+            event_queue=event_queue,
+            graph=graph,
+            knowledge_handlers=cls.knowledge_handlers
+        )
+        kobj_worker = cls.kobj_worker(
+            kobj_queue=kobj_queue,
+            pipeline=pipeline
+        )
+        event_worker = cls.event_worker(
+            config=config,
+            cache=cache,
+            event_queue=event_queue,
+            request_handler=request_handler,
+            poll_event_buf=poll_event_buffer
         )
+        lifecycle = cls.lifecycle(
+            config=config,
+            identity=identity,
+            graph=graph,
+            kobj_queue=kobj_queue,
+            kobj_worker=kobj_worker,
+            event_queue=event_queue,
+            event_worker=event_worker,
+            cache=cache,
+            handshaker=handshaker,
+            behaviors=behaviors
+        )
+        server = cls.server(
+            config=config,
+            lifecycle=lifecycle,
+            secure=secure,
+            kobj_queue=kobj_queue,
+            response_handler=response_handler,
+            poll_event_buf=poll_event_buffer
+        )
+        poller = cls.poller(
+            kobj_queue=kobj_queue,
+            lifecycle=lifecycle,
+            resolver=resolver,
+            config=config
+        )
+        
+        return NodeContainer(
+            poll_event_buf=poll_event_buffer,
+            kobj_queue=kobj_queue,
+            event_queue=event_queue,
+            config=config,
+            cache=cache,
+            identity=identity,
+            graph=graph,
+            secure=secure,
+            request_handler=request_handler,
+            response_handler=response_handler,
+            resolver=resolver,
+            handler_context=handler_context,
+            behaviors=behaviors,
+            pipeline=pipeline,
+            kobj_worker=kobj_worker,
+            event_worker=event_worker,
+            error_handler=error_handler,
+            lifecycle=lifecycle,
+            server=server,
+            poller=poller
+        )

koi_net/default_actions.py

@@ -1,3 +1,5 @@
+"""Implementations of default dereference actions."""
+
 from .context import ActionContext
 from rid_lib.types import KoiNetNode
 from rid_lib.ext import Bundle
@@ -5,7 +7,14 @@ from .effector import Effector
 
 
 @Effector.register_default_action(KoiNetNode)
-def dereference_koi_node(ctx: ActionContext, rid: KoiNetNode) -> Bundle:
+def dereference_koi_node(
+    ctx: ActionContext, rid: KoiNetNode
+) -> Bundle | None:
+    """Dereference function for this KOI node.
+    
+    Generates a bundle from this node's profile data in the config.
+    """
+    
     if rid != ctx.identity.rid:
         return
     

koi_net/effector.py

@@ -4,13 +4,9 @@ from enum import StrEnum
 from rid_lib.ext import Cache, Bundle
 from rid_lib.core import RID, RIDType
 from rid_lib.types import KoiNetNode
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .network.resolver import NetworkResolver
-    from .processor.interface import ProcessorInterface
-    from .context import ActionContext
+from .network.resolver import NetworkResolver
+from .processor.kobj_queue import KobjQueue
+from .context import ActionContext
 
 logger = logging.getLogger(__name__)
 
@@ -20,14 +16,16 @@ class BundleSource(StrEnum):
     ACTION = "ACTION"
 
 class Effector:
+    """Subsystem for dereferencing RIDs."""
+    
     cache: Cache
-    resolver: "NetworkResolver | None"
-    processor: "ProcessorInterface | None"
-    action_context: "ActionContext | None"
+    resolver: NetworkResolver
+    kobj_queue: KobjQueue | None
+    action_context: ActionContext | None
     _action_table: dict[
         type[RID], 
         Callable[
-            ["ActionContext", RID], 
+            [ActionContext, RID], 
             Bundle | None
         ]
     ] = dict()
@@ -35,22 +33,16 @@ class Effector:
     def __init__(
         self, 
         cache: Cache,
+        resolver: NetworkResolver,
+        kobj_queue: KobjQueue,
+        action_context: ActionContext
     ):
         self.cache = cache
-        self.resolver = None
-        self.processor = None
-        self.action_context = None
-        self._action_table = self.__class__._action_table.copy()
-        
-    def set_processor(self, processor: "ProcessorInterface"):
-        self.processor = processor
-        
-    def set_resolver(self, resolver: "NetworkResolver"):
         self.resolver = resolver
-        
-    def set_action_context(self, action_context: "ActionContext"):
+        self.kobj_queue = kobj_queue
         self.action_context = action_context
-        
+        self._action_table = self.__class__._action_table.copy()
+    
     @classmethod
     def register_default_action(cls, rid_type: RIDType):
         def decorator(func: Callable) -> Callable:
@@ -59,6 +51,16 @@ class Effector:
         return decorator
         
     def register_action(self, rid_type: RIDType):
+        """Registers a new dereference action for an RID type.
+        
+        Example:
+            This function should be used as a decorator on an action function::
+            
+                @node.register_action(KoiNetNode)
+                def deref_koi_net_node(ctx: ActionContext, rid: KoiNetNode):
+                    # return a Bundle or None
+                    return
+        """
         def decorator(func: Callable) -> Callable:
             self._action_table[rid_type] = func
             return func
@@ -112,6 +114,19 @@ class Effector:
         use_network: bool = False,
         handle_result: bool = True
     ) -> Bundle | None:
+        """Dereferences an RID.
+        
+        Attempts to dereference an RID by (in order) reading the cache, 
+        calling a bound action, or fetching from other nodes in the 
+        newtork.
+        
+        Args:
+            rid: RID to dereference
+            refresh_cache: skips cache read when `True` 
+            use_network: enables fetching from other nodes when `True`
+            handle_result: handles resulting bundle with knowledge pipeline when `True`
+        """
+        
         logger.debug(f"Dereferencing {rid!r}")
         
         bundle, source = (
@@ -128,7 +143,7 @@ class Effector:
             and bundle is not None 
             and source != BundleSource.CACHE
         ):            
-            self.processor.handle(
+            self.kobj_queue.put_kobj(
                 bundle=bundle, 
                 source=source if type(source) is KoiNetNode else None
             )

koi_net/handshaker.py

@@ -0,0 +1,39 @@
+from logging import getLogger
+from rid_lib.ext import Cache
+from rid_lib.types import KoiNetNode
+from koi_net.identity import NodeIdentity
+from koi_net.network.event_queue import EventQueue
+from .protocol.event import Event, EventType
+
+logger = getLogger(__name__)
+
+
+class Handshaker:
+    def __init__(
+        self, 
+        cache: Cache, 
+        identity: NodeIdentity, 
+        event_queue: EventQueue
+    ):
+        self.cache = cache
+        self.identity = identity
+        self.event_queue = event_queue
+        
+    def handshake_with(self, target: KoiNetNode):
+        """Initiates a handshake with target node.
+        Pushes successive `FORGET` and `NEW` events to target node to
+        reset the target's cache in case it already knew this node. 
+        """
+        logger.debug(f"Initiating handshake with {target}")
+        self.event_queue.push_event_to(
+            Event.from_rid(
+                event_type=EventType.FORGET, 
+                rid=self.identity.rid),
+            target=target
+        )
+        self.event_queue.push_event_to(
+            event=Event.from_bundle(
+                event_type=EventType.NEW, 
+                bundle=self.cache.read(self.identity.rid)),
+            target=target
+        )

koi_net/kobj_worker.py

@@ -0,0 +1,45 @@
+import queue
+import traceback
+import logging
+
+from koi_net.models import END
+from koi_net.processor.knowledge_pipeline import KnowledgePipeline
+from koi_net.processor.kobj_queue import KobjQueue
+from koi_net.worker import ThreadWorker
+
+logger = logging.getLogger(__name__)
+
+
+class KnowledgeProcessingWorker(ThreadWorker):
+    def __init__(
+        self,
+        kobj_queue: KobjQueue,
+        pipeline: KnowledgePipeline,
+        timeout: float = 0.1
+    ):
+        self.kobj_queue = kobj_queue
+        self.pipeline = pipeline
+        self.timeout = timeout
+        super().__init__()
+        
+    def run(self):
+        logger.info("Started kobj worker")
+        while True:
+            try:
+                item = self.kobj_queue.q.get(timeout=self.timeout)
+                try:
+                    if item is END:
+                        logger.info("Received 'END' signal, shutting down...")
+                        return
+                    
+                    logger.info(f"Dequeued {item!r}")
+                    
+                    self.pipeline.process(item)
+                finally:
+                    self.kobj_queue.q.task_done()
+                    
+            except queue.Empty:
+                pass
+            
+            except Exception as e:
+                traceback.print_exc()