fleetmesh-node 0.2.0__py3-none-any.whl

node/protocols/rhio/__init__.py

@@ -0,0 +1,33 @@
+"""Rhio cluster sync & P2P JetStream protocol suite for Fleetmesh.
+
+Native and sidecar integration for HIRO Rhio:
+- NATS JetStream messaging and stream replication
+- Bao-compatible chunked tree hashing for blob integrity
+- S3 / MinIO cluster storage synchronization
+- Outbound RhioRung for TransportRouter ladder
+"""
+from __future__ import annotations
+
+from .package import RhioProtocolPackage
+from .rung import RhioRung
+from .store import (
+    FiberAccessError,
+    RhioBaoTree,
+    RhioBlobSync,
+    RhioStoreError,
+    binary_http_response,
+    handle_fiber_http,
+    is_fiber_route,
+)
+
+__all__ = [
+    'FiberAccessError',
+    'RhioBaoTree',
+    'RhioBlobSync',
+    'RhioProtocolPackage',
+    'RhioRung',
+    'RhioStoreError',
+    'binary_http_response',
+    'handle_fiber_http',
+    'is_fiber_route',
+]

node/protocols/rhio/package.py

@@ -0,0 +1,275 @@
+"""fleetmesh-protocol-rhio: Rhio cluster sync protocol package for Fleetmesh.
+
+Conforms to ProtocolPackage (fleetmesh_core.wire.interfaces.ProtocolPackage).
+Mounts Rhio cluster blob sync, NATS JetStream bridge, and Bao tree verification
+onto ProtocolHostRouter and provides RhioRung for the TransportRouter ladder.
+"""
+from __future__ import annotations
+
+import base64
+import json
+import logging
+import os
+import urllib.parse
+from typing import Any, Mapping, Optional
+
+from fleetmesh_core.wire.interfaces import (
+    ProtocolHealth,
+    ProtocolHostRouter,
+    ProtocolIdentityAdapter,
+)
+from node.protocols.base import BaseProtocolPackage
+from node.protocols.p2panda.identity import P2PandaIdentityAdapter
+from .rung import RhioRung
+from .store import RhioBlobSync
+
+__all__ = [
+    'RhioProtocolPackage',
+]
+
+log = logging.getLogger(__name__)
+
+
+class RhioProtocolPackage(BaseProtocolPackage):
+    """The Rhio cluster synchronization suite for Fleetmesh."""
+
+    name: str = 'rhio'
+    version: str = '0.1.0'
+    standards: tuple[str, ...] = (
+        'rhio-nats-v1',
+        'p2panda-v0.4.0',
+        'bao-tree-hash',
+    )
+
+    def __init__(
+        self,
+        node_dir: Optional[str] = None,
+        keystore: Optional[Any] = None,
+        blob_store: Optional[Any] = None,
+        store: Optional[RhioBlobSync] = None,
+        sidecar_client: Optional[Any] = None,
+        auto_start_sidecar: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        self.node_dir = node_dir
+        self.keystore = keystore
+        self.blob_store = blob_store
+        self.auto_start_sidecar = auto_start_sidecar
+        self.config: Mapping[str, Any] = {}
+        self._enabled: bool = False
+        self._running: bool = False
+        self._messages_in: int = 0
+        self._messages_out: int = 0
+        self._daemon: Optional[Any] = None
+
+        # Identity adapter (p2panda author identity used by Rhio)
+        if keystore is not None:
+            self.identity: Optional[P2PandaIdentityAdapter] = P2PandaIdentityAdapter.from_keystore(keystore)
+        else:
+            self.identity = None
+
+        # Blob & Tree Hash Store
+        if store is not None:
+            self.store: RhioBlobSync = store
+        elif node_dir:
+            db_path = os.path.join(node_dir, "rhio_blobs.db")
+            cas_dir = os.path.join(node_dir, "rhio_blobs")
+            self.store = RhioBlobSync(db_path=db_path, cas_dir=cas_dir)
+        else:
+            self.store = RhioBlobSync(":memory:")
+
+        # Outbound Transport Rung
+        self.socket_path: Optional[str] = os.path.join(node_dir, "rhio.sock") if node_dir else None
+        self.rung: RhioRung = RhioRung(
+            sidecar_client=sidecar_client,
+            socket_path=self.socket_path,
+            enabled=self._enabled,
+        )
+
+        self._host: Optional[ProtocolHostRouter] = None
+
+    def configure(self, config: Mapping[str, Any]) -> None:
+        self.config = dict(config)
+        self._enabled = bool(self.config.get('enabled', False))
+        if 'auto_start_sidecar' in self.config:
+            self.auto_start_sidecar = bool(self.config['auto_start_sidecar'])
+        if 'socket_path' in self.config and self.config['socket_path']:
+            self.socket_path = str(self.config['socket_path'])
+            self.rung._socket_path = self.socket_path
+        self.rung.enabled = self._enabled
+
+    def identity_adapter(self, keystore: Any) -> Optional[ProtocolIdentityAdapter]:
+        if keystore is not None:
+            return P2PandaIdentityAdapter.from_keystore(keystore)
+        return self.identity
+
+    def mount_ingress(self, host: ProtocolHostRouter) -> None:
+        if not self._enabled:
+            return
+        self._host = host
+
+        from node.transport import ws
+
+        # 1. GET /rhio/status
+        def _handle_status(conn: Any, req: Any) -> bool:
+            body_dict = {
+                'status': 'online' if self._running else 'configured',
+                'name': self.name,
+                'version': self.version,
+                'network_id': self.config.get('network_id', 'rhio-default-network-1'),
+                'nats_endpoint': self.config.get('nats_endpoint', 'localhost:4222'),
+                's3_endpoint': self.config.get('s3_endpoint', 'http://localhost:9000'),
+                'blobs_count': self.store.count_blobs(),
+            }
+            body = json.dumps(body_dict, indent=2).encode('utf-8')
+            ws.http_response(conn, "200 OK", body, "application/json")
+            return True
+
+        # 2. GET & POST /rhio/blobs
+        def _handle_blobs(conn: Any, req: Any) -> bool:
+            method = getattr(req, 'method', 'GET').upper()
+            uri = getattr(req, 'path', '')
+            parsed = urllib.parse.urlparse(uri)
+
+            if method == 'GET':
+                qparams = urllib.parse.parse_qs(parsed.query)
+                blob_hash = qparams.get('hash', [None])[0]
+                target_route = parsed.path
+                if not blob_hash and target_route.startswith('/rhio/blobs/'):
+                    tail = target_route[len('/rhio/blobs/'):].strip('/')
+                    if tail:
+                        blob_hash = tail
+
+                if blob_hash:
+                    blob = self.store.get_blob(blob_hash)
+                    if blob is None and self.blob_store is not None and hasattr(self.blob_store, 'get'):
+                        try:
+                            blob = self.blob_store.get(blob_hash)
+                        except Exception:
+                            blob = None
+                    if blob is None:
+                        ws.http_response(conn, "404 Not Found", b'{"error":"not_found"}', "application/json")
+                        return True
+                    ws.http_response(conn, "200 OK", blob, "application/octet-stream")
+                    return True
+                else:
+                    blobs = self.store.list_blobs(limit=50)
+                    body = json.dumps({'blobs': blobs, 'total': self.store.count_blobs()}).encode('utf-8')
+                    ws.http_response(conn, "200 OK", body, "application/json")
+                    return True
+
+            elif method == 'POST':
+                try:
+                    payload = ws.read_body(conn, req)
+                except Exception as e:
+                    ws.http_response(conn, "400 Bad Request", json.dumps({'error': str(e)}).encode('utf-8'))
+                    return True
+
+                headers = getattr(req, 'headers', {})
+                content_type = headers.get(b'content-type', b'').decode('utf-8', errors='ignore').lower()
+
+                # If JSON payload with data_b64
+                if 'json' in content_type:
+                    try:
+                        obj = json.loads(payload.decode('utf-8'))
+                        blob_bytes = base64.b64decode(obj['data_b64'])
+                    except Exception as e:
+                        ws.http_response(conn, "400 Bad Request", json.dumps({'error': str(e)}).encode('utf-8'))
+                        return True
+                else:
+                    blob_bytes = payload
+
+                blob_hash, tree_root, size = self.store.store_blob(blob_bytes)
+                if self.blob_store is not None and hasattr(self.blob_store, 'put'):
+                    try:
+                        self.blob_store.put(blob_bytes)
+                    except Exception:
+                        pass
+                self._messages_in += 1
+                resp_data = {
+                    'hash': blob_hash,
+                    'tree_root': tree_root,
+                    'size': size,
+                }
+                ws.http_response(conn, "201 Created", json.dumps(resp_data).encode('utf-8'), "application/json")
+                return True
+
+            return False
+
+        # 3. GET /rhio/sync
+        def _handle_sync(conn: Any, req: Any) -> bool:
+            body = json.dumps({
+                'network_id': self.config.get('network_id', 'rhio-default-network-1'),
+                'synced': True,
+                'blobs_stored': self.store.count_blobs(),
+            }).encode('utf-8')
+            ws.http_response(conn, "200 OK", body, "application/json")
+            return True
+
+        host.mount_route('/rhio/status', _handle_status, methods=('GET',), owner=self.name)
+        host.mount_route('/rhio/blobs', _handle_blobs, methods=('GET', 'POST'), owner=self.name)
+        host.mount_route('/rhio/sync', _handle_sync, methods=('GET',), owner=self.name)
+
+    def transport_rung(self, context: Any) -> Optional[Any]:
+        if not self._enabled:
+            return None
+        return self.rung
+
+    def compartments(self) -> tuple[type[Any], ...]:
+        return ()
+
+    def start(self) -> None:
+        if not self._enabled:
+            return
+        if self.auto_start_sidecar and self._daemon is None and self.node_dir:
+            from sidecar.fleetmesh_rhio import RhioSidecarClient, RhioSidecarDaemon
+            self._daemon = RhioSidecarDaemon(
+                node_dir=self.node_dir,
+                uds_path=self.socket_path,
+                network_id=str(self.config.get('network_id', 'rhio-default-network-1')),
+                nats_endpoint=str(self.config.get('nats_endpoint', 'localhost:4222')),
+                s3_endpoint=str(self.config.get('s3_endpoint', 'http://localhost:9000')),
+            )
+            self._daemon.start()
+            client = RhioSidecarClient(self._daemon.uds_path)
+            client.connect()
+            self.rung._client = client
+        self._running = True
+
+    def stop(self) -> None:
+        self._running = False
+        if self._daemon is not None:
+            if self.rung._client is not None:
+                try:
+                    self.rung._client.close()
+                except Exception:
+                    pass
+                self.rung._client = None
+            self._daemon.stop()
+            self._daemon = None
+        if self.store is not None:
+            self.store.close()
+
+    def health(self) -> ProtocolHealth:
+        if not self._enabled:
+            return ProtocolHealth(
+                healthy=True,
+                status="disabled",
+                connections_active=0,
+                messages_in=0,
+                messages_out=0,
+                errors=(),
+            )
+        return ProtocolHealth(
+            healthy=True,
+            status="serving" if self._running else "configured",
+            connections_active=0,
+            messages_in=self._messages_in,
+            messages_out=self._messages_out,
+            errors=(),
+        )
+
+    def descriptor_capabilities(self) -> tuple[tuple[str, str], ...]:
+        if not self._enabled:
+            return ()
+        return (('c', 'rhio'), ('c', 'nats-jetstream'), ('c', 'bao'))

node/protocols/rhio/rung.py

@@ -0,0 +1,136 @@
+"""Rhio cluster transport ladder rung for TransportRouter.
+
+Integrates Rhio NATS JetStream and cluster blob replication into the transport ladder:
+- Checks sidecar availability over local Unix domain socket (rhio.sock).
+- Resolves peer Rhio endpoints from node descriptors (scheme 'rhio').
+- Delivers messages to remote cluster peers via NATS JetStream pub/sub.
+"""
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any, Callable, Mapping, Optional
+
+from node.transport.const import TransportError
+from node.transport.ladder import FaultLog
+from node.transport.rung import Rung, Verdict, endpoints_of
+from sidecar.fleetmesh_rhio import RhioSidecarClient
+
+log = logging.getLogger('rhio_rung')
+
+__all__ = [
+    'RhioRung',
+]
+
+
+class RhioRung(Rung):
+    """Transport rung delegating outbound deliveries to the Rhio cluster sidecar daemon."""
+
+    name: str = 'rhio'
+    rank: int = 12  # Cluster sync tier (below FIPS 5, above P2Panda 15)
+
+    def __init__(
+        self,
+        router: Optional[Any] = None,
+        sidecar_client: Optional[RhioSidecarClient] = None,
+        socket_path: Optional[str] = None,
+        enabled: bool = True,
+        clock: Optional[Callable[[], int]] = None,
+    ):
+        self.router = router
+        self._client = sidecar_client
+        self._socket_path = socket_path
+        self.enabled = enabled
+        clk = clock or (getattr(router, 'clock', None) if router else None)
+        self._faults = FaultLog(self.name, clock=clk)
+
+    @property
+    def faults(self) -> FaultLog:
+        return self._faults
+
+    def fault_log(self) -> Optional[FaultLog]:
+        return self._faults
+
+    def _get_client(self) -> Optional[RhioSidecarClient]:
+        if self._client is not None:
+            return self._client
+        sock_path = self._socket_path
+        if sock_path is None and self.router is not None:
+            node_dir = getattr(self.router, 'dir', None) or getattr(self.router, 'node_dir', None)
+            if node_dir:
+                sock_path = os.path.join(node_dir, 'rhio.sock')
+        if sock_path and os.path.exists(sock_path):
+            self._client = RhioSidecarClient(sock_path)
+        return self._client
+
+    def available(self) -> bool:
+        """Returns True if the Rhio sidecar socket is reachable and healthy."""
+        if not self.enabled:
+            return False
+        client = self._get_client()
+        if client is None:
+            return False
+        try:
+            st = client.status()
+            return bool(st.get('ok'))
+        except Exception:
+            return False
+
+    def target_of(self, desc: Optional[Mapping[str, Any]], theirs: Mapping[str, int]) -> Optional[str]:
+        """Extract Rhio endpoint target from descriptor."""
+        if desc is None:
+            return None
+        _, where = endpoints_of(desc)
+        if 'rhio' in where:
+            return where['rhio']
+
+        # Check raw tags
+        for t in desc.get('tags', []):
+            if len(t) > 2 and t[0] in ('endpoint', 'address') and t[1] == 'rhio':
+                return str(t[2])
+            if len(t) > 1 and t[0] == 'c' and t[1] == 'rhio':
+                return ''
+        if 'rhio' in theirs:
+            return ''
+        return None
+
+    def deliver(
+        self,
+        message: Mapping[str, Any],
+        to_pubkey: str,
+        target: str,
+        anonymous: bool = False,
+    ) -> Verdict:
+        """Attempt delivery of message to target Rhio endpoint via JetStream."""
+        if not self.enabled:
+            raise TransportError("rhio rung is disabled")
+
+        client = self._get_client()
+        if client is None:
+            raise TransportError("rhio sidecar client unavailable")
+
+        subject = f"fleetmesh.{to_pubkey[:16]}" if to_pubkey else "fleetmesh.broadcast"
+        try:
+            res = client.publish(subject, dict(message))
+            if not res.get("ok"):
+                raise TransportError(f"rhio publish failed: {res.get('error', 'unknown error')}")
+            msg_id = res.get("id", "")
+            return {self.name: (True, f"published to {subject} id={msg_id[:16]} via JetStream")}
+        except Exception as e:
+            self._faults.record(f"deliver failed: {e}", ident=to_pubkey[:16] if to_pubkey else None)
+            raise TransportError(f"rhio delivery failed: {e}") from e
+
+    def health(self) -> Optional[Mapping[str, Any]]:
+        client = self._get_client()
+        st = {}
+        if client:
+            try:
+                st = dict(client.status())
+            except Exception:
+                pass
+        return {
+            'available': self.available(),
+            'sidecar_connected': bool(st.get('connected', False)),
+            'messages_count': st.get('messages_count', 0),
+            'blobs_count': st.get('blobs_count', 0),
+        }