moved actor to a different filie name, fixed issue with duplicate state providers returning, added behavior to lifecycle start to catch up with coordinators after being offline

Author: lukvmil

src/koi_net/actor.py

@@ -0,0 +1,60 @@
+from logging import getLogger
+from rid_lib.types import KoiNetNode
+from rid_lib import RIDType
+from koi_net.context import HandlerContext
+from koi_net.protocol.api_models import ErrorResponse
+from .protocol.event import Event, EventType
+
+
+logger = getLogger(__name__)
+
+
+class Actor:
+    ctx: HandlerContext
+    
+    def __init__(self):
+        pass
+    
+    def set_ctx(self, ctx: HandlerContext):
+        self.ctx = ctx
+    
+    def handshake_with(self, target: KoiNetNode):
+        logger.debug(f"Initiating handshake with {target}")
+        self.ctx.event_queue.push_event_to(
+            Event.from_rid(
+                event_type=EventType.FORGET, 
+                rid=self.ctx.identity.rid),
+            node=target
+        )
+            
+        self.ctx.event_queue.push_event_to(
+            event=Event.from_bundle(
+                event_type=EventType.NEW, 
+                bundle=self.ctx.effector.deref(self.ctx.identity.rid)),
+            node=target
+        )
+        
+        self.ctx.event_queue.flush_webhook_queue(target)
+        
+    def identify_coordinators(self):
+        return self.ctx.resolver.get_state_providers(KoiNetNode)
+        
+    def catch_up_with(self, target: KoiNetNode, rid_types: list[RIDType] = []):
+        logger.debug(f"catching up with {target} on {rid_types or 'all types'}")
+        
+        payload = self.ctx.request_handler.fetch_manifests(
+            node=target,
+            rid_types=rid_types
+        )
+        if type(payload) == ErrorResponse:
+            logger.debug("failed to reach node")
+            return
+        
+        for manifest in payload.manifests:
+            if manifest.rid == self.ctx.identity.rid:
+                continue
+            
+            self.ctx.handle(
+                manifest=manifest,
+                source=target
+            )

src/koi_net/context.py

@@ -1,4 +1,6 @@
 from rid_lib.ext import Cache
+
+from koi_net.network.resolver import NetworkResolver
 from .config import NodeConfig
 from .effector import Effector
 from .network.graph import NetworkGraph
@@ -28,6 +30,7 @@ class HandlerContext:
     event_queue: NetworkEventQueue
     graph: NetworkGraph
     request_handler: RequestHandler
+    resolver: NetworkResolver
     effector: Effector
     _processor: ProcessorInterface | None
 
@@ -39,6 +42,7 @@ def __init__(
         event_queue: NetworkEventQueue,
         graph: NetworkGraph,
         request_handler: RequestHandler,
+        resolver: NetworkResolver,
         effector: Effector
     ):
         self.identity = identity
@@ -47,6 +51,7 @@ def __init__(
         self.event_queue = event_queue
         self.graph = graph
         self.request_handler = request_handler
+        self.resolver = resolver
         self.effector = effector
         self._processor = None
 

src/koi_net/core.py

@@ -7,7 +7,7 @@
 from .network.request_handler import RequestHandler
 from .network.response_handler import ResponseHandler
 from .network.error_handler import ErrorHandler
-from .network.behavior import Actor
+from .actor import Actor
 from .processor.interface import ProcessorInterface
 from .processor import default_handlers
 from .processor.handler import KnowledgeHandler
@@ -110,11 +110,7 @@ def __init__(
             effector=self.effector
         )
 
-        self.actor = (ActorOverride or Actor)(
-            identity=self.identity,
-            effector=self.effector,
-            event_queue=self.event_queue
-        )
+        self.actor = (ActorOverride or Actor)()
 
         # pull all handlers defined in default_handlers module
         if handlers is None:
@@ -137,6 +133,7 @@ def __init__(
             event_queue=self.event_queue,
             graph=self.graph,
             request_handler=self.request_handler,
+            resolver=self.resolver,
             effector=self.effector
         )
 
@@ -167,14 +164,15 @@ def __init__(
         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,
-            handler_context=self.handler_context,
             use_kobj_processor_thread=use_kobj_processor_thread
         )
 

src/koi_net/lifecycle.py

@@ -1,9 +1,9 @@
 import logging
 from contextlib import contextmanager, asynccontextmanager
 
-from koi_net.context import HandlerContext
+from rid_lib.types import KoiNetNode
 
-from .network.behavior import Actor
+from .actor import Actor
 from .effector import Effector
 from .config import NodeConfig
 from .processor.interface import ProcessorInterface
@@ -28,7 +28,6 @@ def __init__(
         processor: ProcessorInterface,
         effector: Effector,
         actor: Actor,
-        handler_context: HandlerContext,
         use_kobj_processor_thread: bool
     ):
         self.config = config
@@ -37,7 +36,6 @@ def __init__(
         self.processor = processor
         self.effector = effector
         self.actor = actor
-        self.handler_context = handler_context
         self.use_kobj_processor_thread = use_kobj_processor_thread
 
     @contextmanager
@@ -89,8 +87,11 @@ def start(self):
             logger.debug(f"I don't have any neighbors, reaching out to first contact {self.config.koi_net.first_contact.rid!r}")
 
             self.actor.handshake_with(self.config.koi_net.first_contact.rid)
-            
-                        
+        
+        for coordinator in self.actor.identify_coordinators():
+            self.actor.catch_up_with(coordinator, rid_types=[KoiNetNode])
+        
+
     def stop(self):
         """Stops a node, call this method last.
         

src/koi_net/network/behavior.py

@@ -3,7 +3,7 @@
 from koi_net.protocol.event import EventType
 from rid_lib.types import KoiNetNode
 from ..processor.interface import ProcessorInterface
-from ..network.behavior import Actor
+from ..actor import Actor
 
 logger = getLogger(__name__)
 

src/koi_net/network/error_handler.py

@@ -57,15 +57,15 @@ def get_edges(
         """Returns edges this node belongs to.
         
         All edges returned by default, specify `direction` to restrict to incoming or outgoing edges only."""
-                
+                        
         edges = []
         if direction != "in" and self.dg.out_edges:
             out_edges = self.dg.out_edges(self.identity.rid)
-            edges.extend([e for e in out_edges])
+            edges.extend(out_edges)
 
         if direction != "out" and self.dg.in_edges:
             in_edges = self.dg.in_edges(self.identity.rid)
-            edges.extend([e for e in in_edges])
+            edges.extend(in_edges)
 
         edge_rids = []
         for edge in edges:
@@ -87,7 +87,7 @@ def get_neighbors(
         
         All neighboring nodes returned by default, specify `direction` to restrict to neighbors connected by incoming or outgoing edges only."""
 
-        neighbors = []
+        neighbors = set()
         for edge_rid in self.get_edges(direction):
             edge_bundle = self.cache.read(edge_rid)
 
@@ -96,17 +96,17 @@ def get_neighbors(
                 continue
 
             edge_profile = edge_bundle.validate_contents(EdgeProfile)
-            
+                        
             if status and edge_profile.status != status:
                 continue
 
             if allowed_type and allowed_type not in edge_profile.rid_types:
                 continue
 
             if edge_profile.target == self.identity.rid:
-                neighbors.append(edge_profile.source)
+                neighbors.add(edge_profile.source)
             elif edge_profile.source == self.identity.rid:
-                neighbors.append(edge_profile.target)
+                neighbors.add(edge_profile.target)
 
         return list(neighbors)
 

src/koi_net/network/graph.py

@@ -49,7 +49,7 @@ def __init__(
     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}'")
+        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: