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

koi_net/config.py

@@ -1,32 +1,42 @@
 import os
-from typing import TypeVar
 from ruamel.yaml import YAML
-from koi_net.protocol.node import NodeProfile
-from rid_lib.types import KoiNetNode
 from pydantic import BaseModel, Field, PrivateAttr
 from dotenv import load_dotenv
+from rid_lib.ext.utils import sha256_hash
+from rid_lib.types import KoiNetNode
+from .protocol.secure import PrivateKey
+from .protocol.node import NodeProfile, NodeType
 
 
 class ServerConfig(BaseModel):
-    host: str | None = "127.0.0.1"
-    port: int | None = 8000
+    host: str = "127.0.0.1"
+    port: int = 8000
     path: str | None = "/koi-net"
     
     @property
     def url(self) -> str:
         return f"http://{self.host}:{self.port}{self.path or ''}"
 
+class NodeContact(BaseModel):
+    rid: KoiNetNode | None = None
+    url: str | None = None
+
 class KoiNetConfig(BaseModel):
     node_name: str
     node_rid: KoiNetNode | None = None
     node_profile: NodeProfile
     
-    cache_directory_path: str | None = ".rid_cache"
-    event_queues_path: str | None = "event_queues.json"
-
-    first_contact: str | None = None
+    cache_directory_path: str = ".rid_cache"
+    event_queues_path: str = "event_queues.json"
+    private_key_pem_path: str = "priv_key.pem"
+    
+    first_contact: NodeContact = Field(default_factory=NodeContact)
+    
+    _priv_key: PrivateKey | None = PrivateAttr(default=None)
 
 class EnvConfig(BaseModel):
+    priv_key_password: str | None = "PRIV_KEY_PASSWORD"
+    
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         load_dotenv()
@@ -41,8 +51,10 @@ class EnvConfig(BaseModel):
         return value
 
 class NodeConfig(BaseModel):
-    server: ServerConfig | None = Field(default_factory=ServerConfig)
+    server: ServerConfig = Field(default_factory=ServerConfig)
     koi_net: KoiNetConfig
+    env: EnvConfig = Field(default_factory=EnvConfig)
+    
     _file_path: str = PrivateAttr(default="config.yaml")
     _file_content: str | None = PrivateAttr(default=None)
     
@@ -72,13 +84,27 @@ class NodeConfig(BaseModel):
             
         config._file_path = file_path
         
-        if generate_missing:            
-            config.koi_net.node_rid = (
-                config.koi_net.node_rid or KoiNetNode.generate(config.koi_net.node_name)
-            )   
-            config.koi_net.node_profile.base_url = (
-                config.koi_net.node_profile.base_url or config.server.url
-            )
+        if generate_missing:
+            if not config.koi_net.node_rid:
+                priv_key = PrivateKey.generate()
+                pub_key = priv_key.public_key()
+                
+                config.koi_net.node_rid = KoiNetNode(
+                    config.koi_net.node_name,
+                    sha256_hash(pub_key.to_der())
+                )
+                
+                with open(config.koi_net.private_key_pem_path, "w") as f:
+                    f.write(
+                        priv_key.to_pem(config.env.priv_key_password)
+                    )
+                
+                config.koi_net.node_profile.public_key = pub_key.to_der()
+            
+            if config.koi_net.node_profile.node_type == NodeType.FULL:
+                config.koi_net.node_profile.base_url = (
+                    config.koi_net.node_profile.base_url or config.server.url
+                )
                 
             config.save_to_yaml()
                     
@@ -98,4 +124,3 @@ class NodeConfig(BaseModel):
                     f.write(self._file_content)
                 raise e
                 
-ConfigType = TypeVar("ConfigType", bound=NodeConfig)

koi_net/context.py

@@ -0,0 +1,55 @@
+
+from koi_net.effector import Effector
+from rid_lib.ext import Cache
+from .network.graph import NetworkGraph
+from .network.event_queue import NetworkEventQueue
+from .network.request_handler import RequestHandler
+from .identity import NodeIdentity
+from .processor.interface import ProcessorInterface
+
+
+class ActionContext:
+    identity: NodeIdentity
+    effector: Effector
+
+    def __init__(
+        self,
+        identity: NodeIdentity,
+        effector: Effector
+    ):
+        self.identity = identity
+        self.effector = effector
+    
+
+class HandlerContext:
+    identity: NodeIdentity
+    cache: Cache
+    event_queue: NetworkEventQueue
+    graph: NetworkGraph
+    request_handler: RequestHandler
+    effector: Effector
+    _processor: ProcessorInterface | None
+    
+    def __init__(
+        self,
+        identity: NodeIdentity,
+        cache: Cache,
+        event_queue: NetworkEventQueue,
+        graph: NetworkGraph,
+        request_handler: RequestHandler,
+        effector: Effector
+    ):
+        self.identity = identity
+        self.cache = cache
+        self.event_queue = event_queue
+        self.graph = graph
+        self.request_handler = request_handler
+        self.effector = effector
+        self._processor = None
+        
+    def set_processor(self, processor: ProcessorInterface):
+        self._processor = processor
+        
+    @property
+    def handle(self):
+        return self._processor.handle

koi_net/core.py

@@ -1,51 +1,100 @@
 import logging
-from typing import Generic
 import httpx
-from rid_lib.ext import Cache, Bundle
-from .network import NetworkInterface
-from .processor import ProcessorInterface
+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 .network.behavior 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 .protocol.event import Event, EventType
-from .config import ConfigType
+from .secure import Secure
+from .config import NodeConfig
+from .context import HandlerContext, ActionContext
+from .effector import Effector
+from . import default_actions
 
 logger = logging.getLogger(__name__)
 
 
 
-class NodeInterface(Generic[ConfigType]):
-    config: ConfigType
+class NodeInterface:
+    config: NodeConfig
     cache: Cache
     identity: NodeIdentity
-    network: NetworkInterface
+    resolver: NetworkResolver
+    event_queue: NetworkEventQueue
+    graph: NetworkGraph
     processor: ProcessorInterface
+    secure: Secure
     
     use_kobj_processor_thread: bool
     
     def __init__(
         self, 
-        config: ConfigType,
+        config: NodeConfig,
         use_kobj_processor_thread: bool = False,
         
         handlers: list[KnowledgeHandler] | None = None,
         
         cache: Cache | None = None,
-        network: NetworkInterface | None = None,
         processor: ProcessorInterface | None = None
     ):
-        self.config: ConfigType = config
+        self.config = config
         self.cache = cache or Cache(
-            self.config.koi_net.cache_directory_path)
+            directory_path=self.config.koi_net.cache_directory_path
+        )
+        
+        self.identity = NodeIdentity(config=self.config)
         
-        self.identity = NodeIdentity(
+        self.effector = Effector(cache=self.cache)
+
+        self.graph = NetworkGraph(
+            cache=self.cache, 
+            identity=self.identity
+        )
+        
+        self.secure = Secure(
+            identity=self.identity, 
+            effector=self.effector, 
+            config=self.config
+        )
+        
+        self.request_handler = RequestHandler(
+            effector=self.effector, 
+            identity=self.identity,
+            secure=self.secure
+        )
+        
+        self.response_handler = ResponseHandler(self.cache, self.effector)
+        
+        self.resolver = NetworkResolver(
             config=self.config,
-            cache=self.cache)
+            cache=self.cache, 
+            identity=self.identity,
+            graph=self.graph,
+            request_handler=self.request_handler,
+            effector=self.effector
+        )
         
-        self.network = network or NetworkInterface(
+        self.event_queue = NetworkEventQueue(
             config=self.config,
             cache=self.cache, 
-            identity=self.identity
+            identity=self.identity,
+            graph=self.graph,
+            request_handler=self.request_handler,
+            effector=self.effector
+        )
+        
+        self.actor = Actor(
+            identity=self.identity,
+            effector=self.effector,
+            event_queue=self.event_queue
         )
         
         # pull all handlers defined in default_handlers module
@@ -56,14 +105,48 @@ class NodeInterface(Generic[ConfigType]):
             ]
 
         self.use_kobj_processor_thread = use_kobj_processor_thread
-        self.processor = processor or ProcessorInterface(
-            config=self.config,
-            cache=self.cache, 
-            network=self.network, 
-            identity=self.identity, 
-            use_kobj_processor_thread=self.use_kobj_processor_thread,
+        
+        self.action_context = ActionContext(
+            identity=self.identity,
+            effector=self.effector
+        )
+        
+        self.handler_context = HandlerContext(
+            identity=self.identity,
+            cache=self.cache,
+            event_queue=self.event_queue,
+            graph=self.graph,
+            request_handler=self.request_handler,
+            effector=self.effector
+        )
+        
+        self.pipeline = 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
         )
+        
+        self.processor = processor or ProcessorInterface(
+            pipeline=self.pipeline,
+            use_kobj_processor_thread=self.use_kobj_processor_thread
+        )
+        
+        self.error_handler = ErrorHandler(
+            processor=self.processor,
+            actor=self.actor
+        )
+        
+        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)
+         
             
     def start(self) -> None:
         """Starts a node, call this method first.
@@ -74,16 +157,12 @@ class NodeInterface(Generic[ConfigType]):
             logger.info("Starting processor worker thread")
             self.processor.worker_thread.start()
         
-        self.network._load_event_queues()
-        self.network.graph.generate()
-        
-        self.processor.handle(
-            bundle=Bundle.generate(
-                rid=self.identity.rid, 
-                contents=self.identity.profile.model_dump()
-            )
-        )
+        # self.network._load_event_queues()
+        self.graph.generate()
         
+        # refresh to reflect changes (if any) in config.yaml
+        self.effector.deref(self.identity.rid, refresh_cache=True)
+                
         logger.debug("Waiting for kobj queue to empty")
         if self.use_kobj_processor_thread:
             self.processor.kobj_queue.join()
@@ -91,23 +170,10 @@ class NodeInterface(Generic[ConfigType]):
             self.processor.flush_kobj_queue()
         logger.debug("Done")
     
-        if not self.network.graph.get_neighbors() and self.config.koi_net.first_contact:
-            logger.debug(f"I don't have any neighbors, reaching out to first contact {self.config.koi_net.first_contact}")
+        if not self.graph.get_neighbors() and self.config.koi_net.first_contact.rid:
+            logger.debug(f"I don't have any neighbors, reaching out to first contact {self.config.koi_net.first_contact.rid!r}")
             
-            events = [
-                Event.from_rid(EventType.FORGET, self.identity.rid),
-                Event.from_bundle(EventType.NEW, self.identity.bundle)
-            ]
-            
-            try:
-                self.network.request_handler.broadcast_events(
-                    url=self.config.koi_net.first_contact,
-                    events=events
-                )
-                
-            except httpx.ConnectError:
-                logger.warning("Failed to reach first contact")
-                return
+            self.actor.handshake_with(self.config.koi_net.first_contact.rid)
             
                         
     def stop(self):
@@ -123,4 +189,4 @@ class NodeInterface(Generic[ConfigType]):
         else:
             self.processor.flush_kobj_queue()
         
-        self.network._save_event_queues()
+        # self.network._save_event_queues()

koi_net/default_actions.py

@@ -0,0 +1,15 @@
+from .context import ActionContext
+from rid_lib.types import KoiNetNode
+from rid_lib.ext import Bundle
+from .effector import Effector
+
+
+@Effector.register_default_action(KoiNetNode)
+def dereference_koi_node(ctx: ActionContext, rid: KoiNetNode) -> Bundle:
+    if rid != ctx.identity.rid:
+        return
+    
+    return Bundle.generate(
+        rid=ctx.identity.rid,
+        contents=ctx.identity.profile.model_dump()
+    )

koi_net/effector.py

@@ -0,0 +1,139 @@
+import logging
+from typing import Callable
+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
+
+logger = logging.getLogger(__name__)
+
+
+class BundleSource(StrEnum):
+    CACHE = "CACHE"
+    ACTION = "ACTION"
+
+class Effector:
+    cache: Cache
+    resolver: "NetworkResolver | None"
+    processor: "ProcessorInterface | None"
+    action_context: "ActionContext | None"
+    _action_table: dict[
+        type[RID], 
+        Callable[
+            ["ActionContext", RID], 
+            Bundle | None
+        ]
+    ] = dict()
+    
+    def __init__(
+        self, 
+        cache: Cache,
+    ):
+        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.action_context = action_context
+        
+    @classmethod
+    def register_default_action(cls, rid_type: RIDType):
+        def decorator(func: Callable) -> Callable:
+            cls._action_table[rid_type] = func
+            return func
+        return decorator
+        
+    def register_action(self, rid_type: RIDType):
+        def decorator(func: Callable) -> Callable:
+            self._action_table[rid_type] = func
+            return func
+        return decorator
+    
+    def _try_cache(self, rid: RID) -> tuple[Bundle, BundleSource] | None:
+        bundle = self.cache.read(rid)
+        
+        if bundle:
+            logger.debug("Cache hit")
+            return bundle, BundleSource.CACHE
+        else:
+            logger.debug("Cache miss")
+            return None
+                    
+    def _try_action(self, rid: RID) -> tuple[Bundle, BundleSource] | None:
+        if type(rid) not in self._action_table:
+            logger.debug("No action available")
+            return None
+        
+        logger.debug("Action available")
+        func = self._action_table[type(rid)]
+        bundle = func(
+            ctx=self.action_context, 
+            rid=rid
+        )
+        
+        if bundle:
+            logger.debug("Action hit")
+            return bundle, BundleSource.ACTION
+        else:
+            logger.debug("Action miss")
+            return None
+
+        
+    def _try_network(self, rid: RID) -> tuple[Bundle, KoiNetNode] | None:
+        bundle, source = self.resolver.fetch_remote_bundle(rid)
+        
+        if bundle:
+            logger.debug("Network hit")
+            return bundle, source
+        else:
+            logger.debug("Network miss")
+            return None
+        
+    
+    def deref(
+        self, 
+        rid: RID,
+        refresh_cache: bool = False,
+        use_network: bool = False,
+        handle_result: bool = True
+    ) -> Bundle | None:
+        logger.debug(f"Dereferencing {rid!r}")
+        
+        bundle, source = (
+            # if `refresh_cache`, skip try cache
+            not refresh_cache and self._try_cache(rid) or 
+            self._try_action(rid) or
+            use_network and self._try_network(rid) or
+            # if not found, bundle and source set to None
+            (None, None) 
+        )
+        
+        if (
+            handle_result 
+            and bundle is not None 
+            and source != BundleSource.CACHE
+        ):            
+            self.processor.handle(
+                bundle=bundle, 
+                source=source if type(source) is KoiNetNode else None
+            )
+
+            # TODO: refactor for general solution, param to write through to cache before continuing
+            # like `self.processor.kobj_queue.join()``
+
+        return bundle

koi_net/identity.py

@@ -1,33 +1,19 @@
 import logging
-from rid_lib.ext.bundle import Bundle
-from rid_lib.ext.cache import Cache
 from rid_lib.types.koi_net_node import KoiNetNode
-
 from .config import NodeConfig
 from .protocol.node import NodeProfile
 
+
 logger = logging.getLogger(__name__)
 
     
 class NodeIdentity:
-    """Represents a node's identity (RID, profile, bundle)."""
+    """Represents a node's identity (RID, profile)."""
     
     config: NodeConfig    
-    cache: Cache
     
-    def __init__(
-        self,
-        config: NodeConfig,
-        cache: Cache
-    ):
-        """Initializes node identity from a name and profile.
-        
-        Attempts to read identity from storage. If it doesn't already exist, a new RID is generated from the provided name, and that RID and profile are written to storage. Changes to the name or profile will update the stored identity.
-        
-        WARNING: If the name is changed, the RID will be overwritten which will have consequences for the rest of the network.
-        """
+    def __init__(self, config: NodeConfig):
         self.config = config
-        self.cache = cache
         
     @property
     def rid(self) -> KoiNetNode:
@@ -35,8 +21,4 @@ class NodeIdentity:
     
     @property
     def profile(self) -> NodeProfile:
-        return self.config.koi_net.node_profile 
-    
-    @property
-    def bundle(self) -> Bundle:
-        return self.cache.read(self.rid)
+        return self.config.koi_net.node_profile

koi_net/network/__init__.py

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

koi_net/network/behavior.py

@@ -0,0 +1,42 @@
+from logging import getLogger
+from rid_lib.types import KoiNetNode
+from ..protocol.event import Event, EventType
+from ..identity import NodeIdentity
+from ..effector import Effector
+from ..network.event_queue import NetworkEventQueue
+
+logger = getLogger(__name__)
+
+
+class Actor:
+    identity: NodeIdentity
+    effector: Effector
+    event_queue: NetworkEventQueue
+    
+    def __init__(
+        self, 
+        identity: NodeIdentity, 
+        effector: Effector,
+        event_queue: NetworkEventQueue
+    ):
+        self.identity = identity
+        self.effector = effector
+        self.event_queue = event_queue
+    
+    def handshake_with(self, target: KoiNetNode):
+        logger.debug(f"Initiating handshake with {target}")
+        self.event_queue.push_event_to(
+            Event.from_rid(
+                event_type=EventType.FORGET, 
+                rid=self.identity.rid),
+            node=target
+        )
+            
+        self.event_queue.push_event_to(
+            event=Event.from_bundle(
+                event_type=EventType.NEW, 
+                bundle=self.effector.deref(self.identity.rid)),
+            node=target
+        )
+        
+        self.event_queue.flush_webhook_queue(target)

koi_net/network/error_handler.py

@@ -0,0 +1,50 @@
+from logging import getLogger
+from koi_net.protocol.errors import ErrorTypes
+from koi_net.protocol.event import EventType
+from rid_lib.types import KoiNetNode
+from ..processor.interface import ProcessorInterface
+from ..network.behavior import Actor
+
+logger = getLogger(__name__)
+
+
+class ErrorHandler:
+    timeout_counter: dict[KoiNetNode, int]
+    processor: ProcessorInterface
+    actor: Actor
+    
+    def __init__(
+        self, 
+        processor: ProcessorInterface,
+        actor: Actor
+    ):
+        self.processor = processor
+        self.actor = actor
+        self.timeout_counter = {}
+        
+    def handle_connection_error(self, node: KoiNetNode):
+        self.timeout_counter.setdefault(node, 0)
+        self.timeout_counter[node] += 1
+        
+        logger.debug(f"{node} has timed out {self.timeout_counter[node]} time(s)")
+        
+        if self.timeout_counter[node] > 3:
+            logger.debug(f"Exceeded time out limit, forgetting node")
+            self.processor.handle(rid=node, event_type=EventType.FORGET)
+            # do something
+        
+        
+    def handle_protocol_error(
+        self, 
+        error_type: ErrorTypes, 
+        node: KoiNetNode
+    ):
+        logger.info(f"Handling protocol error {error_type} for node {node!r}")
+        match error_type:
+            case ErrorTypes.UnknownNode:
+                logger.info("Peer doesn't know me, attempting handshake...")
+                self.actor.handshake_with(node)
+                
+            case ErrorTypes.InvalidKey: ...
+            case ErrorTypes.InvalidSignature: ...
+            case ErrorTypes.InvalidTarget: ...