Source code for fleetmesh_node.planes.transport.mediation.compartment

"""The Mediation compartment: the operator commands and the inbound door
for the three mediation PIURIs, acting for the proven sender."""
from __future__ import annotations

import json
from typing import Any, Callable, Mapping, Optional

from fleetmesh_node import channels as ch_mod
from fleetmesh_node import metrics as mx_mod
from fleetmesh_node.compartment import stores as st
from fleetmesh_node.compartment import Command, Handler, Need, Outbound, WireProtocol
from fleetmesh_node.config import MediationConfig
from fleetmesh_node.config.parameter import Parameter
from .messages import (KEYLIST_UPDATE, MEDIATE_REQUEST, PICKUP_DELIVERY_REQUEST, PICKUP_MESSAGES_RECEIVED,
                       PIURIS, ROUTING_FORWARD, make_mediate_request, make_pickup_delivery_request)
from .service import MediatorService
from .store import MediationStore


[docs]class Mediation(WireProtocol): """The mediation compartment of meshnode (routing/2.0 & coordinate-mediation/2.0).""" name = 'mediation' piuris: tuple[str, ...] = tuple(PIURIS) OUTBOUND = ( Outbound('mediate-grant', doc='grant coordinate-mediation admission and routing keys to leaf'), Outbound('mediate-deny', doc='deny coordinate-mediation admission to leaf'), Outbound('keylist-update-response', doc='acknowledge leaf routing keys updates'), Outbound('delivery', doc='drain queued messages to leaf'), Outbound('status', doc='deliver queue status to leaf'), ) reads = ('mediation', 'endpoints', 'relays') config_cls = MediationConfig SCHEMA = MediationStore.SCHEMA STORES = ( st.Store(key='handled', description='messages handled by protocol message type', kind=st.TABLE, shape=int, bound=64, keyed_by='msg_type', evict=st.LRU), ) CHANNELS = ( ch_mod.Channel('message_forwarded', 'Mediation forward message queued for leaf', level=ch_mod.INFO, say='forward message queued for recipient {recipient}', tags=('mediation', 'forward')), ch_mod.Channel('forward_refused', 'Mediation forward message refused or dropped', level=ch_mod.TROUBLE, say='forward message refused for recipient {recipient}', tags=('mediation', 'forward')), ch_mod.Channel('mediation_granted', 'Mediation admission granted to leaf', level=ch_mod.INFO, say='mediation admission granted to {leaf}', tags=('mediation', 'admission')), ch_mod.Channel('messages_drained', 'Queued messages picked up by leaf', level=ch_mod.INFO, say='picked up {count} messages for {leaf}', tags=('mediation', 'pickup')), ch_mod.Channel('sender_unauthenticated', 'Mediation message sender not authenticated', level=ch_mod.TROUBLE, say='mediation request refused: sender not authenticated', tags=('mediation', 'security')), ) METRICS = ( mx_mod.Metric(name='mediation_messages_forwarded', description='Messages buffered for mediated leaves.', kind=mx_mod.COUNTER, counts='message_forwarded', tags=('mediation', 'forward')), mx_mod.Metric(name='mediation_forward_refused', description='Forward messages refused or dropped.', kind=mx_mod.COUNTER, counts='forward_refused', tags=('mediation', 'forward')), mx_mod.Metric(name='mediation_admissions_granted', description='Leaves admitted into mediation.', kind=mx_mod.COUNTER, counts='mediation_granted', tags=('mediation', 'admission')), mx_mod.Metric(name='mediation_messages_drained', description='Batches of messages drained by leaves.', kind=mx_mod.COUNTER, counts='messages_drained', tags=('mediation', 'pickup')), mx_mod.Metric(name='mediation_unauthenticated', description='Mediation messages from unauthenticated senders.', kind=mx_mod.COUNTER, counts='sender_unauthenticated', tags=('mediation', 'security')), ) HANDLERS = ( Handler('forward', run='handle_forward', doc='buffer inbound routing/2.0 forward envelope for mobile leaf'), Handler('mediate-request', run='handle_mediate_request', writes=('mediation',), doc='grant coordinate-mediation admission'), Handler('keylist-update', run='handle_keylist_update', writes=('mediation',), doc='update leaf routing keys'), Handler('delivery-request', run='handle_pickup_delivery_request', reads=('mediation',), doc='drain queued messages for leaf'), Handler('messages-received', run='handle_pickup_messages_received', writes=('mediation',), doc='acknowledge and purge delivered messages'), ) COMMANDS = ( Command( key='show', name='Mediation Status', description='display active mediated leaves and queue depth', tags=('mediation', 'status'), permission='mediation/show', run='show_cmd', reply='dict', ), Command( key='grant', name='Grant Mediation', description='admit leaf into mediation and grant routing keys', tags=('mediation', 'grant'), parameters=( Parameter(key='leaf', name='leaf', description='did of the leaf to admit', type=str, default='', required=True), ), permission='mediation/grant', run='grant_cmd', reply='dict', ), Command( key='forward', name='Forward Message', description='buffer inbound routing/2.0 forward envelope for mobile leaf', tags=('mediation', 'forward'), parameters=( Parameter(key='message', name='message', description='forward envelope (dict or json string)', type=object, default=dict, required=True), ), permission='mediation/forward', run='forward_cmd', reply='bool', ), Command( key='pickup', name='Pickup Messages', description='drain queued forwarded envelopes for mobile leaf', tags=('mediation', 'pickup'), parameters=( Parameter(key='leaf', name='leaf', description='did of the leaf to drain for', type=str, default='', required=True), Parameter(key='limit', name='limit', description='max envelopes to drain', type=int, default=10, required=False), ), permission='mediation/pickup', run='pickup_cmd', reply='dict', ), ) DB: str = 'mediation.sqlite' NEEDS = ( Need('db_path', path='DB'), Need('mediator_did', 'did'), Need('transport', 'transport'), )
[docs] def __init__(self, node: Any = None, db_path: Optional[str] = None, mediator_did: Optional[str] = None, clock: Optional[Callable[[], int]] = None, transport: Optional[Any] = None, db: Optional[Any] = None) -> None: """Built by `from_context` in a node. The bare `Mediation()` and `Mediation(node=fake)` forms the tests use still work: with no path the store is in memory, and with no DID the one on `node.ks` is used if there is one.""" if db is None and db_path is not None: from fleetmesh_node.storage.adapter import SqliteAdapter db = SqliteAdapter(db_path, schema=self.SCHEMA, clock=clock) super().__init__(node, clock, db=db) # The transport a reply goes back over; off the fake node in the suites. self.transport: Optional[Any] = transport if transport is not None else getattr(node, 'transport', None) self.handled: st.Table[str, int] if mediator_did is None: ks = getattr(node, 'ks', None) if node is not None else None actual_did = 'did:nostr:%s' % ks.node_pk if ks is not None else '' else: actual_did = str(mediator_did) if db_path is not None: self.service: MediatorService = MediatorService(db_path=db_path, mediator_did=actual_did, clock=clock, db=self.db) else: self.service = MediatorService(mediator_did=actual_did, clock=clock, db=self.db)
[docs] def show_cmd(self) -> Mapping[str, Any]: return { 'mediator_did': self.service.mediator_did, 'routing_keys': self.service.routing_keys, }
[docs] def grant_cmd(self, args: Mapping[str, Any]) -> Any: req = make_mediate_request(from_did=str(args['leaf']), to_did=self.service.mediator_did) return self.service.handle_mediate_request(req)
[docs] def forward_cmd(self, args: Mapping[str, Any]) -> bool: raw = args['message'] msg = raw if isinstance(raw, dict) else json.loads(raw) return bool(self.service.handle_forward(msg))
[docs] def pickup_cmd(self, args: Mapping[str, Any]) -> Any: pick = make_pickup_delivery_request( from_did=str(args['leaf']), to_did=self.service.mediator_did, limit=int(args.get('limit') or 10), ) return self.service.handle_pickup_delivery_request(pick)
# ---- the wire ---------------------------------------------------------
[docs] def handle_forward(self, inbound: Any, sender: str) -> Optional[tuple[Any, ...]]: msg = getattr(inbound, 'message', inbound) if not isinstance(msg, dict) or not isinstance(sender, str) or not sender: return None queued = self.service.handle_forward(msg) self._count(ROUTING_FORWARD) recipient = str(msg.get('body', {}).get('next', ''))[:24] if queued: self.say('message_forwarded', recipient=recipient) else: self.say('forward_refused', recipient=recipient) return ('mediation forward', 'queued' if queued else 'refused', recipient)
def _handle_authenticated(self, inbound: Any, sender_pk: str, mtype: str, action: Callable[..., Any]) -> Optional[tuple[Any, ...]]: msg = getattr(inbound, 'message', inbound) if not isinstance(msg, dict) or not isinstance(sender_pk, str) or not sender_pk: return None if not getattr(inbound, 'authenticated', False): self._count('unauthenticated') self.say('sender_unauthenticated') return ('mediation refused', mtype.rsplit('/', 1)[-1], 'sender not authenticated') sender = 'did:nostr:' + sender_pk try: reply = action(msg, sender=sender) except PermissionError as e: self._count('impersonation') return ('mediation refused', mtype.rsplit('/', 1)[-1], str(e)) self._count(mtype) if mtype == MEDIATE_REQUEST and isinstance(reply, dict) and reply.get('type', '').endswith('mediate-grant'): self.say('mediation_granted', leaf=sender) elif mtype == PICKUP_DELIVERY_REQUEST and isinstance(reply, dict): msgs = reply.get('body', {}).get('messages', []) self.say('messages_drained', count=len(msgs), leaf=sender) if mtype == PICKUP_MESSAGES_RECEIVED: return ('mediation received', sender_pk[:16], reply) if self.transport is not None and isinstance(reply, dict): self.wire_client.send(sender_pk, reply) return ('mediation', mtype.rsplit('/', 1)[-1], sender_pk[:16], str(reply.get('type', ''))[-30:] if isinstance(reply, dict) else '')
[docs] def handle_mediate_request(self, inbound: Any, sender: str) -> Optional[tuple[Any, ...]]: return self._handle_authenticated(inbound, sender, MEDIATE_REQUEST, self.service.handle_mediate_request)
[docs] def handle_keylist_update(self, inbound: Any, sender: str) -> Optional[tuple[Any, ...]]: return self._handle_authenticated(inbound, sender, KEYLIST_UPDATE, self.service.handle_keylist_update)
[docs] def handle_pickup_delivery_request(self, inbound: Any, sender: str) -> Optional[tuple[Any, ...]]: return self._handle_authenticated(inbound, sender, PICKUP_DELIVERY_REQUEST, self.service.handle_pickup_delivery_request)
[docs] def handle_pickup_messages_received(self, inbound: Any, sender: str) -> Optional[tuple[Any, ...]]: return self._handle_authenticated(inbound, sender, PICKUP_MESSAGES_RECEIVED, self.service.handle_messages_received)
def _count(self, key: str) -> None: self.handled[key] = self.handled.get(key, 0) + 1
[docs] def stop(self) -> None: """Safely close mediation persistence and worker state on shutdown.""" if hasattr(self, 'service') and self.service: self.service.close() super().stop()