config_cls -> config_schema, switched assembler functions back to chain calls, implemented cache directly with config dependency (necessary for new config system), moved all code execution out of init functions, lifecycle start now calls config loader, and loads priv key to secure manager, removed lifespan from fastapi app, now done using lifecycle context manager in server class to allow for config loading before uvicorn starts, added kobj worker config

Author: lukvmil

examples/coordinator.py

@@ -61,7 +61,7 @@ def handshake_handler(ctx: HandlerContext, kobj: KnowledgeObject):
     ctx.kobj_queue.push(bundle=edge_bundle)
 
 class CoordinatorNode(FullNode):
-    config_cls = CoordinatorConfig
+    config_schema = CoordinatorConfig
     knowledge_handlers = FullNode.knowledge_handlers + [handshake_handler]
 
 if __name__ == "__main__":

examples/partial.py

@@ -9,7 +9,7 @@ class MyPartialNodeConfig(PartialNodeConfig):
     )
 
 class MyPartialNode(PartialNode):
-    config_cls = MyPartialNodeConfig
+    config_schema = MyPartialNodeConfig
 
 if __name__ == "__main__":
     node = MyPartialNode()

src/koi_net/assembler.py

@@ -45,13 +45,10 @@ class NodeAssembler(metaclass=BuildOrderer):
     # Self annotation lying to type checker to reflect typing set in node blueprints
     def __new__(self) -> Self:
         """Returns assembled node container."""
-        return self._build()
+        return self._build_node()
 
     @classmethod
-    def _build_deps(
-        cls, 
-        build_order: list[str]
-    ) -> dict[str, tuple[CompType, list[str]]]:
+    def _build_deps(cls) -> dict[str, tuple[CompType, list[str]]]:
         """Returns dependency graph for components defined in `cls_build_order`.
         
         Graph representation is a dict where each key is a component name,
@@ -60,7 +57,7 @@ def _build_deps(
         """
 
         dep_graph = {}
-        for comp_name in build_order:
+        for comp_name in cls._build_order:
             try:
                 comp = getattr(cls, comp_name)
             except AttributeError:
@@ -84,9 +81,9 @@ def _build_deps(
         return dep_graph
 
     @classmethod
-    def _visualize(cls, dep_graph) -> str:
+    def _visualize(cls) -> str:
         """Returns representation of dependency graph in Graphviz DOT language."""
-        dep_graph = cls._build_deps(cls._build_order)
+        dep_graph = cls._build_deps()
 
         s = "digraph G {\n"
         for node, (_, neighbors) in dep_graph.items():
@@ -99,11 +96,10 @@ def _visualize(cls, dep_graph) -> str:
         return s
 
     @classmethod
-    def _build_comps(
-        cls,
-        dep_graph: dict[str, tuple[CompType, list[str]]]
-    ) -> dict[str, Any]:
+    def _build_comps(cls) -> dict[str, Any]:
         """Returns assembled components from dependency graph."""
+        dep_graph = cls._build_deps()
+        
         components: dict[str, Any] = {}
         for comp_name, (comp_type, dep_names) in dep_graph.items():
             comp = getattr(cls, comp_name, None)
@@ -119,12 +115,14 @@ def _build_comps(
                         raise Exception(f"Couldn't find required component '{dep_name}'")
                     dependencies[dep_name] = components[dep_name]
                 components[comp_name] = comp(**dependencies)
-        
+                
         return components
 
     @classmethod
-    def _build_node(cls, components: dict[str, Any]) -> NodeContainer:
+    def _build_node(cls) -> NodeContainer:
         """Returns node container from components."""
+        components = cls._build_comps()
+        
         NodeContainer = make_dataclass(
             cls_name="NodeContainer",
             fields=[
@@ -136,11 +134,3 @@ def _build_node(cls, components: dict[str, Any]) -> NodeContainer:
         )
 
         return NodeContainer(**components)
-    
-    @classmethod
-    def _build(cls) -> NodeContainer:
-        """Returns node container after calling full build process."""
-        dep_graph = cls._build_deps(cls._build_order)
-        comps = cls._build_comps(dep_graph)
-        node = cls._build_node(comps)
-        return node

src/koi_net/cache.py

@@ -0,0 +1,81 @@
+import os
+import shutil
+from rid_lib.core import RID, RIDType
+from rid_lib.ext import Bundle
+from rid_lib.ext.utils import b64_encode, b64_decode
+
+from .config.core import NodeConfig
+
+
+class Cache:
+    def __init__(self, config: NodeConfig):
+        self.config = config
+        
+    @property
+    def directory_path(self):
+        return self.config.koi_net.cache_directory_path
+        
+    def file_path_to(self, rid: RID) -> str:
+        encoded_rid_str = b64_encode(str(rid))
+        return f"{self.directory_path}/{encoded_rid_str}.json"
+
+    def write(self, bundle: Bundle) -> Bundle:
+        """Writes bundle to cache, returns a Bundle."""
+        if not os.path.exists(self.directory_path):
+            os.makedirs(self.directory_path)
+            
+        with open(
+            file=self.file_path_to(bundle.manifest.rid), 
+            mode="w", 
+            encoding="utf-8"
+        ) as f:
+            f.write(bundle.model_dump_json(indent=2))
+
+        return bundle
+    
+    def exists(self, rid: RID) -> bool:
+        return os.path.exists(
+            self.file_path_to(rid)
+        )
+
+    def read(self, rid: RID) -> Bundle | None:
+        """Reads and returns CacheEntry from RID cache."""
+        try:
+            with open(
+                file=self.file_path_to(rid), 
+                mode="r",
+                encoding="utf-8"
+            ) as f:
+                return Bundle.model_validate_json(f.read())
+        except FileNotFoundError:
+            return None
+    
+    def list_rids(self, rid_types: list[RIDType] | None = None) -> list[RID]:
+        if not os.path.exists(self.directory_path):
+            return []
+        
+        rids = []
+        for filename in os.listdir(self.directory_path):
+            encoded_rid_str = filename.split(".")[0]
+            rid_str = b64_decode(encoded_rid_str)
+            rid = RID.from_string(rid_str)
+            
+            if not rid_types or type(rid) in rid_types:
+                rids.append(rid)
+            
+        return rids
+                
+    def delete(self, rid: RID) -> None:
+        """Deletes cache bundle."""
+        try:
+            os.remove(self.file_path_to(rid))
+        except FileNotFoundError:
+            return
+
+    def drop(self) -> None:
+        """Deletes all cache bundles."""
+        try:
+            shutil.rmtree(self.directory_path)
+        except FileNotFoundError:
+            return
+

src/koi_net/config/loader.py

@@ -20,8 +20,6 @@ def __init__(
     ):
         self.config_schema = config_schema
         self.proxy = config
-        self.load_from_yaml()
-        self.save_to_yaml()
 
     def load_from_yaml(self):
         """Loads config from YAML file, or generates it if missing."""

src/koi_net/core.py

@@ -1,5 +1,4 @@
-from rid_lib.ext import Cache
-
+from .cache import Cache
 from .log_system import LogSystem
 from .assembler import NodeAssembler
 from .config.core import NodeConfig
@@ -34,7 +33,6 @@
     secure_profile_handler
 )
 
-
 class BaseNode(NodeAssembler):
     log_system: LogSystem = LogSystem
     kobj_queue: KobjQueue = KobjQueue
@@ -54,8 +52,7 @@ class BaseNode(NodeAssembler):
         forget_edge_on_node_deletion
     ]
     deref_handlers: list[DerefHandler] = []
-    cache: Cache = lambda config: Cache(
-        directory_path=config.koi_net.cache_directory_path)
+    cache: Cache = Cache
     identity: NodeIdentity = NodeIdentity
     graph: NetworkGraph = NetworkGraph
     secure_manager: SecureManager = SecureManager

src/koi_net/entrypoints/server.py

@@ -32,9 +32,8 @@ def __init__(
         self.config = config
         self.lifecycle = lifecycle
         self.response_handler = response_handler
-        self._build_app()
-    
-    def _build_endpoints(self, router: APIRouter):
+        
+    def build_endpoints(self, router: APIRouter):
         """Builds endpoints for API router."""
         for path, models in API_MODEL_MAP.items():
             def create_endpoint(path: str):
@@ -56,22 +55,16 @@ async def endpoint(req):
                 response_model_exclude_none=True
             )
 
-    def _build_app(self):
+    def build_app(self):
         """Builds FastAPI app."""
-        @asynccontextmanager
-        async def lifespan(*args, **kwargs):
-            async with self.lifecycle.async_run():
-                yield
-        
         self.app = FastAPI(
-            lifespan=lifespan, 
             title="KOI-net Protocol API",
             version="1.1.0"
         )
 
         self.app.add_exception_handler(ProtocolError, self.protocol_error_handler)
         self.router = APIRouter(prefix="/koi-net")
-        self._build_endpoints(self.router)
+        self.build_endpoints(self.router)
         self.app.include_router(self.router)
 
     def protocol_error_handler(self, request, exc: ProtocolError):
@@ -86,10 +79,14 @@ def protocol_error_handler(self, request, exc: ProtocolError):
 
     def run(self):
         """Starts FastAPI server and event handler."""
-        uvicorn.run(
-            app=self.app,
-            host=self.config.server.host,
-            port=self.config.server.port,
-            log_config=None,
-            access_log=False
-        )
+        
+        with self.lifecycle.run():
+            self.build_app()
+            
+            uvicorn.run(
+                app=self.app,
+                host=self.config.server.host,
+                port=self.config.server.port,
+                log_config=None,
+                access_log=False
+            )

src/koi_net/lifecycle.py

@@ -4,6 +4,9 @@
 from rid_lib.ext import Bundle
 from rid_lib.types import KoiNetNode
 
+from koi_net.config.loader import ConfigLoader
+from koi_net.secure_manager import SecureManager
+
 from .sync_manager import SyncManager
 from .handshaker import Handshaker
 from .workers.kobj_worker import KnowledgeProcessingWorker
@@ -22,6 +25,7 @@ class NodeLifecycle:
     """Manages node startup and shutdown processes."""
 
     config: NodeConfig
+    config_loader: ConfigLoader
     identity: NodeIdentity
     graph: NetworkGraph
     kobj_queue: KobjQueue
@@ -30,20 +34,24 @@ class NodeLifecycle:
     event_worker: EventProcessingWorker
     handshaker: Handshaker
     sync_manager: SyncManager
+    secure_manager: SecureManager
 
     def __init__(
         self,
         config: NodeConfig,
+        config_loader: ConfigLoader,
         identity: NodeIdentity,
         graph: NetworkGraph,
         kobj_queue: KobjQueue,
         kobj_worker: KnowledgeProcessingWorker,
         event_queue: EventQueue,
         event_worker: EventProcessingWorker,
         handshaker: Handshaker,
-        sync_manager: SyncManager
+        sync_manager: SyncManager,
+        secure_manager: SecureManager
     ):
         self.config = config
+        self.config_loader = config_loader
         self.identity = identity
         self.graph = graph
         self.kobj_queue = kobj_queue
@@ -52,6 +60,7 @@ def __init__(
         self.event_worker = event_worker
         self.handshaker = handshaker
         self.sync_manager = sync_manager
+        self.secure_manager = secure_manager
 
     @contextmanager
     def run(self):
@@ -86,7 +95,14 @@ def start(self):
         graph from nodes and edges in cache. Processes any state changes 
         of node bundle. Initiates handshake with first contact if node 
         doesn't have any neighbors. Catches up with coordinator state.
-        """        
+        """
+        
+        # attempt to load config from yaml, and write back changes (if any)
+        self.config_loader.load_from_yaml()
+        self.config_loader.save_to_yaml()
+        
+        self.secure_manager.load_priv_key()
+        
         self.kobj_worker.thread.start()
         self.event_worker.thread.start()
         self.graph.generate()

src/koi_net/secure_manager.py

@@ -37,22 +37,20 @@ def __init__(
         self.identity = identity
         self.cache = cache
         self.config = config
-
-        self.priv_key = self._load_priv_key()
 
-    def _load_priv_key(self) -> PrivateKey:
+    def load_priv_key(self) -> PrivateKey:
         """Loads private key from PEM file path in config."""
 
         # TODO: handle missing private key
         with open(self.config.koi_net.private_key_pem_path, "r") as f:
             priv_key_pem = f.read()
 
-        return PrivateKey.from_pem(
+        self.priv_key = PrivateKey.from_pem(
             priv_key_pem=priv_key_pem,
             password=self.config.env.priv_key_password
         )
 
-    def _handle_unknown_node(self, envelope: SignedEnvelope) -> Bundle | None:
+    def handle_unknown_node(self, envelope: SignedEnvelope) -> Bundle | None:
         """Attempts to find node profile in proided envelope.
         
         If an unknown node sends an envelope, it may still be able to be
@@ -89,7 +87,7 @@ def validate_envelope(self, envelope: SignedEnvelope):
 
         node_bundle = (
             self.cache.read(envelope.source_node) or
-            self._handle_unknown_node(envelope)
+            self.handle_unknown_node(envelope)
         )
 
         if not node_bundle: