fleetmesh-node 0.2.0__py3-none-any.whl

node/planes/services/gossip/envelope.py

@@ -0,0 +1,154 @@
+"""gossip/1.0 wire vocabulary: PIURI, message types, and the GossipError.
+
+Separate from core.py because the vocabulary is what validate.py, the tests,
+and the subsystem all need, and it has no dependency on the mesh/seen-store
+machinery that acts on it.
+"""
+from __future__ import annotations
+
+import uuid
+from typing import Any, Mapping, Optional, Sequence
+
+from fleetmesh_core.wire.wire_types import GossipGraftBody, GossipIdsBody, GossipPruneBody, GossipPublishBody, Message
+
+PIURI: str = 'https://fleetmesh.org/gossip/1.0'
+GRAFT_TYPE: str = PIURI + '/graft'
+PRUNE_TYPE: str = PIURI + '/prune'
+IHAVE_TYPE: str = PIURI + '/ihave'
+IWANT_TYPE: str = PIURI + '/iwant'
+PUBLISH_TYPE: str = PIURI + '/publish'
+
+MESSAGES: tuple[str, ...] = ('graft', 'prune', 'ihave', 'iwant', 'publish')
+
+# Target mesh degree per topic, the gossipsub D parameter. A node grafts up to
+# this many peers per topic and regrafts on tick when it falls below.
+DEFAULT_MESH_DEGREE: int = 6
+
+MEMBERSHIP_KIND: int = 30804
+
+
+class GossipError(Exception):
+    """Raised when a gossip/1.0 wire message or mesh transition is invalid."""
+
+
+def make_graft(
+    from_did: str,
+    to_did: str,
+    topic: str,
+    membership_id: str,
+    created_time: Optional[int] = None,
+    msg_id: Optional[str] = None,
+) -> Message[GossipGraftBody]:
+    """Construct a DIDComm gossip/1.0/graft message.
+
+    `membership_id` is the id of the kind 30804 membership event the sender
+    holds naming its own pubkey for this topic: the receiver checks it names
+    the sender before adding them to its mesh, rather than trusting the ask.
+    """
+    msg: Message[GossipGraftBody] = {
+        'id': msg_id or str(uuid.uuid4()),
+        'type': GRAFT_TYPE,
+        'from': from_did,
+        'to': [to_did],
+        'body': GossipGraftBody(topic=topic, membership=membership_id),
+    }
+    if created_time is not None:
+        msg['created_time'] = int(created_time)
+    return msg
+
+
+def make_prune(
+    from_did: str,
+    to_did: str,
+    topic: str,
+    reason: str = 'degree',
+    created_time: Optional[int] = None,
+    msg_id: Optional[str] = None,
+) -> Message[GossipPruneBody]:
+    """Construct a DIDComm gossip/1.0/prune message."""
+    msg: Message[GossipPruneBody] = {
+        'id': msg_id or str(uuid.uuid4()),
+        'type': PRUNE_TYPE,
+        'from': from_did,
+        'to': [to_did],
+        'body': GossipPruneBody(topic=topic, reason=reason),
+    }
+    if created_time is not None:
+        msg['created_time'] = int(created_time)
+    return msg
+
+
+def make_ihave(
+    from_did: str,
+    to_did: str,
+    topic: str,
+    ids: Sequence[str],
+    created_time: Optional[int] = None,
+    msg_id: Optional[str] = None,
+) -> Message[GossipIdsBody]:
+    """Construct a DIDComm gossip/1.0/ihave message: ids only, no payload."""
+    msg: Message[GossipIdsBody] = {
+        'id': msg_id or str(uuid.uuid4()),
+        'type': IHAVE_TYPE,
+        'from': from_did,
+        'to': [to_did],
+        'body': GossipIdsBody(topic=topic, ids=list(ids)),
+    }
+    if created_time is not None:
+        msg['created_time'] = int(created_time)
+    return msg
+
+
+def make_iwant(
+    from_did: str,
+    to_did: str,
+    topic: str,
+    ids: Sequence[str],
+    created_time: Optional[int] = None,
+    msg_id: Optional[str] = None,
+) -> Message[GossipIdsBody]:
+    """Construct a DIDComm gossip/1.0/iwant message: ids being asked for."""
+    msg: Message[GossipIdsBody] = {
+        'id': msg_id or str(uuid.uuid4()),
+        'type': IWANT_TYPE,
+        'from': from_did,
+        'to': [to_did],
+        'body': GossipIdsBody(topic=topic, ids=list(ids)),
+    }
+    if created_time is not None:
+        msg['created_time'] = int(created_time)
+    return msg
+
+
+def make_publish(
+    from_did: str,
+    to_did: str,
+    topic: str,
+    event_id: str,
+    envelope: Mapping[str, Any],
+    created_time: Optional[int] = None,
+    msg_id: Optional[str] = None,
+) -> Message[GossipPublishBody]:
+    """Construct a DIDComm gossip/1.0/publish message.
+
+    `envelope` is the already-sealed NIP-59 seal+wrap this node floods: gossip
+    never sees plaintext, only the per-member sealed bytes keyed by `event_id`
+    (the wrap's own id, which is what the seen-id store dedupes on).
+    """
+    msg: Message[GossipPublishBody] = {
+        'id': msg_id or str(uuid.uuid4()),
+        'type': PUBLISH_TYPE,
+        'from': from_did,
+        'to': [to_did],
+        'body': GossipPublishBody(topic=topic, event_id=event_id, envelope=dict(envelope)),
+    }
+    if created_time is not None:
+        msg['created_time'] = int(created_time)
+    return msg
+
+
+__all__ = [
+    'PIURI', 'GRAFT_TYPE', 'PRUNE_TYPE', 'IHAVE_TYPE', 'IWANT_TYPE', 'PUBLISH_TYPE',
+    'MESSAGES', 'DEFAULT_MESH_DEGREE', 'MEMBERSHIP_KIND', 'GossipError',
+    'make_graft', 'make_prune', 'make_ihave', 'make_iwant', 'make_publish',
+]

node/planes/services/gossip/mesh.py

@@ -0,0 +1,127 @@
+"""The seen-id store: sqlite-backed, bounded by TTL and size, durable across
+restarts.
+
+A node that forgets an id the moment it restarts re-floods everything it has
+already seen back out to its whole mesh, which is indistinguishable from an
+attacker replaying a topic's history at every peer. Durability is what keeps
+a restart from being an amplification event. Unbounded growth is the other
+failure: a long-lived topic would otherwise make this table the largest
+thing on disk for a compartment whose whole job is "have I seen this once
+already" - so entries expire (SEEN_TTL_SECONDS) and the table is swept to
+MAX_SEEN_ROWS on insert pressure, oldest first by `first_seen_at`, which is the
+LRU reading of when a topic first carried an event.
+"""
+from __future__ import annotations
+
+import json
+import time
+from typing import Any, Mapping, Optional
+
+from node.compartment.schema import Column, Index, Table
+from node.storage import SqliteStore
+
+DEFAULT_SEEN_TTL_SECONDS: int = 24 * 3600
+DEFAULT_MAX_SEEN_ROWS: int = 200_000
+
+
+class SeenStore(SqliteStore):
+    """(topic, event_id) -> first_seen_at, for gossip loop prevention."""
+
+    SCHEMA = (
+        Table('seen', (
+            Column('topic', 'TEXT', not_null=True),
+            Column('event_id', 'TEXT', not_null=True),
+            Column('first_seen_at', 'INTEGER', not_null=True),
+        ), primary_key=('topic', 'event_id'), indices=(
+            Index('seen_at', ('first_seen_at',)),
+        )),
+    )
+
+    def __init__(self, path: str = ':memory:', ttl_seconds: int = DEFAULT_SEEN_TTL_SECONDS,
+                 max_rows: int = DEFAULT_MAX_SEEN_ROWS, **kw: Any) -> None:
+        super().__init__(path, **kw)
+        self.ttl_seconds: int = ttl_seconds
+        self.max_rows: int = max_rows
+
+    def seen(self, topic: str, event_id: str) -> bool:
+        return self._one('SELECT 1 FROM seen WHERE topic=? AND event_id=?', (topic, event_id)) is not None
+
+    def mark(self, topic: str, event_id: str, now: Optional[int] = None) -> bool:
+        """Record (topic, event_id) as seen. Returns True if this was new."""
+        at = int(now if now is not None else time.time())
+        with self._lock:
+            try:
+                self.execute('INSERT INTO seen VALUES (?,?,?)', (topic, event_id, at))
+                self.db.commit()
+            except Exception:
+                # Already present: the INSERT on the primary key failed. Roll
+                # the implicit transaction back, or this connection holds a
+                # write lock on the file until the next commit.
+                self.db.rollback()
+                return False
+            n = self._one('SELECT COUNT(*) FROM seen')
+            if n and n[0] > self.max_rows:
+                self._sweep_oldest(n[0] - self.max_rows)
+        return True
+
+    def _sweep_oldest(self, excess: int) -> None:
+        with self._lock:
+            # Named by the declared key, not by SQLite's implicit rowid: the
+            # ordering was always `first_seen_at`, and rowid was only how the
+            # selected rows were identified. `(topic, event_id)` is the table's
+            # own PRIMARY KEY and says the same thing on any backend.
+            self.execute(
+                'DELETE FROM seen WHERE (topic, event_id) IN '
+                '(SELECT topic, event_id FROM seen ORDER BY first_seen_at ASC LIMIT ?)', (excess,))
+            self.db.commit()
+
+    def expire(self, now: Optional[int] = None) -> int:
+        """Drop rows older than the TTL. Returns the count removed."""
+        cut = int(now if now is not None else time.time()) - self.ttl_seconds
+        with self._lock:
+            cur = self.execute('DELETE FROM seen WHERE first_seen_at < ?', (cut,))
+            self.db.commit()
+            return cur.rowcount if cur.rowcount is not None else 0
+
+    def count(self, topic: Optional[str] = None) -> int:
+        if topic is None:
+            row = self._one('SELECT COUNT(*) FROM seen')
+        else:
+            row = self._one('SELECT COUNT(*) FROM seen WHERE topic=?', (topic,))
+        return int(row[0]) if row else 0
+
+
+class RosterStore(SqliteStore):
+    """topic -> the current admin-signed kind 30804 roster, durable across restarts.
+
+    A topic the operator created and then lost on the next restart is a topic
+    that silently stopped gossiping: no peer would graft to a node with no
+    membership event, and nothing would say why. The roster is the whole of
+    what makes a node a member, so it lives on disk next to the seen-ids.
+    """
+
+    SCHEMA = (
+        Table('rosters', (
+            Column('topic', 'TEXT', primary_key=True),
+            Column('event', 'TEXT', not_null=True),
+            Column('created_at', 'INTEGER', not_null=True),
+        )),
+    )
+
+    def put(self, topic: str, event: Mapping[str, Any]) -> None:
+        with self._lock:
+            self.execute('INSERT OR REPLACE INTO rosters VALUES (?,?,?)',
+                            (topic, json.dumps(event, separators=(',', ':'), sort_keys=True),
+                             int(event.get('created_at', 0))))
+            self.db.commit()
+
+    def delete(self, topic: str) -> None:
+        with self._lock:
+            self.execute('DELETE FROM rosters WHERE topic=?', (topic,))
+            self.db.commit()
+
+    def all(self) -> dict[str, Mapping[str, Any]]:
+        return {topic: json.loads(raw) for topic, raw in self._all('SELECT topic, event FROM rosters')}
+
+
+__all__ = ['SeenStore', 'RosterStore', 'DEFAULT_SEEN_TTL_SECONDS', 'DEFAULT_MAX_SEEN_ROWS']

node/planes/services/gossip/types.py

@@ -0,0 +1,50 @@
+"""Types and records for the Gossip compartment."""
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional, TypedDict
+
+
+class GossipTotals(TypedDict):
+    """Every gossip event this node took part in, counted since it started."""
+    published: int
+    delivered: int
+    offered: int
+    wanted: int
+    served: int
+    auto_admitted: int
+
+
+class TopicView(TypedDict):
+    topic: str
+    admin: Optional[str]
+    members: list[str]
+    mesh: list[str]
+    expires: int
+    roster_id: Optional[str]
+
+
+class TopicCreationResult(TypedDict):
+    topic: str
+    event: Mapping[str, Any]
+    relays: dict[str, list[Any]]
+
+
+class OriginateResult(TypedDict):
+    topic: str
+    event_id: str
+    sent_to: list[str]
+    mesh: int
+
+
+class GossipStateReport(TypedDict):
+    topics: list[str]
+    mesh: dict[str, int]
+    seen: int
+    published: int
+    auto_admitted: int
+    delivered: int
+    offered: int
+    wanted: int
+    served: int
+    mcache: int
+    refused: int

node/planes/services/nsite/__init__.py

@@ -0,0 +1,7 @@
+"""nsite: the node as a NIP-5A static-site host, reachable from the plain web.
+
+One-module compartment: everything is in compartment.py.
+"""
+from .compartment import NsiteGateway
+
+__all__ = ['NsiteGateway']

node/planes/services/nsite/client.py

@@ -0,0 +1,62 @@
+"""nsite client-side publishing and site walking workflows."""
+from __future__ import annotations
+
+import mimetypes
+import os
+from typing import Callable, Sequence
+
+MAX_FILES = 5000
+
+
+def walk_site_files(root: str, max_files: int = MAX_FILES) -> list[tuple[str, str]]:
+    """Walk local directory for static site files.
+
+    Returns a list of (rel_path, full_path) tuples.
+    Raises ValueError if invalid directory, empty, or exceeds max_files.
+    """
+    root = os.path.abspath(root)
+    if not os.path.isdir(root):
+        raise ValueError('%s is not a directory' % root)
+    out: list[tuple[str, str]] = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = sorted(d for d in dirnames if not d.startswith('.'))
+        for f in sorted(filenames):
+            if f.startswith('.'):
+                continue
+            full = os.path.join(dirpath, f)
+            rel = '/' + os.path.relpath(full, root).replace(os.sep, '/')
+            out.append((rel, full))
+    if not out:
+        raise ValueError('%s holds no files' % root)
+    if len(out) > max_files:
+        raise ValueError('%d files; a site here is at most %d' % (len(out), max_files))
+    return out
+
+
+def upload_site_blobs(
+    files: Sequence[tuple[str, str]],
+    face_http_url: str,
+    node_sk: str,
+    progress: Callable[[str, str, int], None] | None = None,
+) -> tuple[dict[str, str], int]:
+    """Upload site files to local Blossom face.
+
+    Returns (paths_dict, total_bytes) where paths_dict maps rel_path -> sha256.
+    """
+    from node.protocols.nostr import blossom as blossom_mod
+
+    paths: dict[str, str] = {}
+    total = 0
+    for rel, full in files:
+        with open(full, 'rb') as fh:
+            data = fh.read()
+        ctype = mimetypes.guess_type(rel)[0] or 'application/octet-stream'
+        desc = blossom_mod.BlossomClient.upload_blob(
+            face_http_url, data, content_type=ctype, signer_sk=node_sk, allow_private=True
+        )
+        h = str(desc.get('sha256', '')).lower()
+        paths[rel] = h
+        total += len(data)
+        if progress is not None:
+            progress(rel, h, len(data))
+    return paths, total