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()