Merge pull request #12 from BlockScience/refactor

v1.1.0-beta.1

Author: lukvmil

.gitignore

@@ -1,6 +1,8 @@
 rid-lib
 __pycache__
 *.json
+*.pem
+*.yaml
 venv
 .env
 prototypes

examples/basic_coordinator_node.py

@@ -8,13 +8,7 @@
 from rid_lib.types import KoiNetNode, KoiNetEdge
 from koi_net import NodeInterface
 from koi_net.config import NodeConfig, KoiNetConfig
-from koi_net.processor.handler import HandlerType
-from koi_net.processor.knowledge_object import KnowledgeObject, KnowledgeSource
-from koi_net.protocol.edge import EdgeType
-from koi_net.protocol.event import Event, EventType
-from koi_net.protocol.helpers import generate_edge_bundle
 from koi_net.protocol.node import NodeProfile, NodeType, NodeProvides
-from koi_net.processor import ProcessorInterface
 from koi_net.protocol.api_models import (
     PollEvents,
     FetchRids,
@@ -41,6 +35,8 @@
     handlers=[RichHandler()]
 )
 
+# TODO: UPDATE OR REMOVE, THIS EXAMPLE IS OUT OF DATE
+
 logging.getLogger("koi_net").setLevel(logging.DEBUG)
 
 
@@ -69,32 +65,6 @@ class CoordinatorNodeConfig(NodeConfig):
 logger = logging.getLogger(__name__)
 
 
-@node.processor.register_handler(HandlerType.Network, rid_types=[KoiNetNode])
-def handshake_handler(proc: ProcessorInterface, kobj: KnowledgeObject):    
-    logger.info("Handling node handshake")
-
-    # only respond if node declares itself as NEW
-    if kobj.event_type != EventType.NEW:
-        return
-        
-    logger.info("Sharing this node's bundle with peer")
-    proc.network.push_event_to(
-        event=Event.from_bundle(EventType.NEW, proc.identity.bundle),
-        node=kobj.rid,
-        flush=True
-    )
-    
-    logger.info("Proposing new edge")    
-    # defer handling of proposed edge
-    proc.handle(bundle=generate_edge_bundle(
-        source=kobj.rid,
-        target=proc.identity.rid,
-        edge_type=EdgeType.WEBHOOK,
-        rid_types=[KoiNetNode, KoiNetEdge]
-    ))
-
-
-
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     node.start()
@@ -117,20 +87,20 @@ def broadcast_events(req: EventsPayload):
 @app.post(POLL_EVENTS_PATH)
 def poll_events(req: PollEvents) -> EventsPayload:
     logger.info(f"Request to {POLL_EVENTS_PATH}")
-    events = node.network.flush_poll_queue(req.rid)
+    events = node.event_queue.flush_poll_queue(req.rid)
     return EventsPayload(events=events)
 
 @app.post(FETCH_RIDS_PATH)
 def fetch_rids(req: FetchRids) -> RidsPayload:
-    return node.network.response_handler.fetch_rids(req)
+    return node.response_handler.fetch_rids(req)
 
 @app.post(FETCH_MANIFESTS_PATH)
 def fetch_manifests(req: FetchManifests) -> ManifestsPayload:
-    return node.network.response_handler.fetch_manifests(req)
+    return node.response_handler.fetch_manifests(req)
 
 @app.post(FETCH_BUNDLES_PATH)
 def fetch_bundles(req: FetchBundles) -> BundlesPayload:
-    return node.network.response_handler.fetch_bundles(req)
+    return node.response_handler.fetch_bundles(req)
 
 if __name__ == "__main__":
     openapi_spec = app.openapi()

examples/basic_partial_node.py

@@ -3,9 +3,8 @@
 from pydantic import Field
 from rich.logging import RichHandler
 from koi_net import NodeInterface
-from koi_net.processor.knowledge_object import KnowledgeSource
 from koi_net.protocol.node import NodeProfile, NodeType
-from koi_net.config import NodeConfig, KoiNetConfig
+from koi_net.config import NodeConfig, KoiNetConfig, NodeContact
 
 logging.basicConfig(
     level=logging.INFO,
@@ -18,29 +17,32 @@
 logger = logging.getLogger(__name__)
 
 
-class CoordinatorNodeConfig(NodeConfig):
+class PartialNodeConfig(NodeConfig):
     koi_net: KoiNetConfig | None = Field(default_factory = lambda:
         KoiNetConfig(
             node_name="partial",
             node_profile=NodeProfile(
                 node_type=NodeType.PARTIAL
             ),
             cache_directory_path=".basic_partial_rid_cache",
-            event_queues_path="basic_partial_event_queues.json",
-            first_contact="http://127.0.0.1:8000/koi-net"
+            event_queues_path="basic_partial_event_queues.json"
         )
     )
 
 
 node = NodeInterface(
-    config=CoordinatorNodeConfig.load_from_yaml("basic_partial_config.yaml")
+    config=PartialNodeConfig.load_from_yaml("basic_partial_config.yaml")
 )
 
+
 node.start()
 
 while True:
-    for event in node.network.poll_neighbors():
-        node.processor.handle(event=event, source=KnowledgeSource.External)
+    neighbors = node.resolver.poll_neighbors()
+    for node_rid in neighbors:
+        events = neighbors[node_rid]
+        for event in events:
+            node.processor.handle(event=event, source=node_rid)
     node.processor.flush_kobj_queue()
 
     time.sleep(5)

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "koi-net"
-version = "1.0.0"
+version = "1.1.0-beta.1"
 description = "Implementation of KOI-net protocol in Python"
 authors = [
     {name = "Luke Miller", email = "[email protected]"}
@@ -13,12 +13,13 @@ readme = "README.md"
 requires-python = ">=3.10"
 license = {file = "LICENSE"}
 dependencies = [
-    "rid-lib>=3.2.3",
+    "rid-lib>=3.2.7",
     "networkx>=3.4.2",
     "httpx>=0.28.1",
     "pydantic>=2.10.6",
     "ruamel.yaml>=0.18.10",
-    "python-dotenv>=1.1.0"
+    "python-dotenv>=1.1.0",
+    "cryptography>=45.0.3"
 ]
 
 [project.optional-dependencies]

src/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 @@ def __getattribute__(self, name):
         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 @@ def load_from_yaml(
 
         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 @@ def save_to_yaml(self):
                     f.write(self._file_content)
                 raise e
 
-ConfigType = TypeVar("ConfigType", bound=NodeConfig)

src/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