fleetmesh-node 0.2.0__py3-none-any.whl

node/protocols/p2panda/identity.py

@@ -0,0 +1,19 @@
+"""p2panda identity adapter for Fleetmesh.
+
+Maps the node's Ed25519 transport key to a p2panda author identity.
+Conforms to ProtocolIdentityAdapter (fleetmesh_core.wire.interfaces).
+"""
+from __future__ import annotations
+
+from node.protocols.base import Ed25519IdentityAdapter
+
+__all__ = [
+    'P2PandaIdentityAdapter',
+]
+
+
+class P2PandaIdentityAdapter(Ed25519IdentityAdapter):
+    """Translates between Fleetmesh keys and p2panda author identities."""
+
+    uri_prefixes: tuple[str, ...] = ("p2panda:", "panda:")
+

node/protocols/p2panda/package.py

@@ -0,0 +1,236 @@
+"""fleetmesh-protocol-p2panda: p2panda protocol package for Fleetmesh.
+
+Conforms to ProtocolPackage (fleetmesh_core.wire.interfaces.ProtocolPackage).
+Mounts p2panda operation log ingress onto ProtocolHostRouter, provides
+P2PandaRung for TransportRouter ladder, and manages append-only SQLite persistence.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import urllib.parse
+from typing import Any, Mapping, Optional
+
+from fleetmesh_core.wire.interfaces import (
+    ProtocolHealth,
+    ProtocolHostRouter,
+    ProtocolIdentityAdapter,
+)
+from fleetmesh_core.wire.p2panda import P2PandaOperation, P2PandaOperationDict
+from node.protocols.base import BaseProtocolPackage
+from .identity import P2PandaIdentityAdapter
+from .rung import P2PandaRung
+from .store import P2PandaLogStore, P2PandaStoreError
+
+__all__ = [
+    'P2PandaProtocolPackage',
+]
+
+log = logging.getLogger(__name__)
+
+
+class P2PandaProtocolPackage(BaseProtocolPackage):
+    """The p2panda protocol suite for Fleetmesh."""
+
+    name: str = 'p2panda'
+    version: str = '0.4.0'
+    standards: tuple[str, ...] = (
+        'p2panda-v0.4.0',
+        'cbor-rfc8949',
+        'ed25519-chain',
+    )
+
+    def __init__(
+        self,
+        node_dir: Optional[str] = None,
+        keystore: Optional[Any] = None,
+        blob_store: Optional[Any] = None,
+        store: Optional[P2PandaLogStore] = None,
+        **kwargs: Any,
+    ) -> None:
+        self.node_dir = node_dir
+        self.keystore = keystore
+        self.blob_store = blob_store
+        self.config: Mapping[str, Any] = {}
+        self._enabled: bool = True
+        self._running: bool = False
+        self._messages_in: int = 0
+        self._messages_out: int = 0
+
+        # Identity Adapter
+        if keystore is not None:
+            self.identity: Optional[P2PandaIdentityAdapter] = P2PandaIdentityAdapter.from_keystore(keystore)
+        else:
+            self.identity = None
+
+        # Persistent Log Store
+        if store is not None:
+            self.store: P2PandaLogStore = store
+        elif node_dir:
+            import os
+            db_path = os.path.join(node_dir, "p2panda.db")
+            self.store = P2PandaLogStore(db_path)
+        else:
+            self.store = P2PandaLogStore(":memory:")
+
+        # Outbound Transport Rung
+        self.rung: P2PandaRung = P2PandaRung(
+            store=self.store,
+            identity=self.identity,
+            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', True))
+        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 /p2panda/status
+        def _handle_status(conn: Any, req: Any) -> bool:
+            body_dict = {
+                'status': 'online' if self._running else 'configured',
+                'name': self.name,
+                'version': self.version,
+                'author': self.identity.author_id if self.identity else '',
+                'operations_count': self.store.count_operations(),
+                'authors_count': len(self.store.list_authors()),
+            }
+            body = json.dumps(body_dict, indent=2).encode('utf-8')
+            ws.http_response(conn, "200 OK", body, "application/json")
+            return True
+
+        # 2. GET & POST /p2panda/operations
+        def _op_to_json_dict(op: P2PandaOperation) -> P2PandaOperationDict:
+            return op.to_dict(json_safe=True)
+
+        def _handle_operations(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)
+                author = qparams.get('author', [None])[0]
+                target_route = parsed.path
+                if not author and target_route.startswith('/p2panda/operations/'):
+                    tail = target_route[len('/p2panda/operations/'):].strip('/')
+                    if tail:
+                        single_op = self.store.get_operation(tail)
+                        if single_op is not None:
+                            ws.http_response(
+                                conn,
+                                "200 OK",
+                                json.dumps(_op_to_json_dict(single_op)).encode('utf-8'),
+                                "application/json",
+                            )
+                            return True
+                        author = tail
+
+                if author:
+                    from_seq = int(qparams.get('from_seq', [0])[0])
+                    limit = int(qparams.get('limit', [100])[0])
+                    ops = self.store.get_log(author, from_seq=from_seq, limit=limit)
+                    ops_data = [_op_to_json_dict(op) for op in ops]
+                    body = json.dumps({'author': author, 'operations': ops_data}).encode('utf-8')
+                    ws.http_response(conn, "200 OK", body, "application/json")
+                    return True
+                else:
+                    authors = self.store.list_authors()
+                    body = json.dumps({'authors': authors, 'total_operations': self.store.count_operations()}).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()
+
+                try:
+                    if 'cbor' in content_type:
+                        op = P2PandaOperation.from_cbor(payload)
+                    else:
+                        op_dict = json.loads(payload.decode('utf-8'))
+                        op = P2PandaOperation.from_dict(op_dict)
+
+                    inserted = self.store.append_operation(op, verify_chain=True)
+                    self._messages_in += 1
+                    status = "201 Created" if inserted else "200 OK"
+                    ws.http_response(
+                        conn,
+                        status,
+                        json.dumps({'op_id': op.id, 'inserted': inserted, 'seq_num': op.seq_num}).encode('utf-8'),
+                        "application/json",
+                    )
+                    return True
+                except P2PandaStoreError as e:
+                    ws.http_response(conn, "422 Unprocessable Entity", json.dumps({'error': str(e)}).encode('utf-8'))
+                    return True
+                except Exception as e:
+                    ws.http_response(conn, "400 Bad Request", json.dumps({'error': str(e)}).encode('utf-8'))
+                    return True
+
+            return False
+
+        host.mount_route('/p2panda/status', _handle_status, methods=('GET',), owner=self.name)
+        host.mount_route('/p2panda/operations', _handle_operations, methods=('GET', 'POST'), 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
+        self._running = True
+
+    def stop(self) -> None:
+        self._running = False
+        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', 'p2panda'), ('c', 'cbor'))

node/protocols/p2panda/rung.py

@@ -0,0 +1,152 @@
+"""p2panda transport rung for TransportRouter ladder.
+
+Standard library only. Delivers messages wrapped as append-only p2panda operations
+to local log and sync peers.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable, Mapping, Optional
+
+from fleetmesh_core.wire.cbor import cbor_encode
+from fleetmesh_core.wire.p2panda import P2PandaOperation
+from node.transport.const import TransportError
+from node.transport.ladder import FaultLog
+from node.transport.rung import Rung, Verdict, endpoints_of
+from .identity import P2PandaIdentityAdapter
+from .store import P2PandaLogStore
+
+__all__ = [
+    'P2PandaRung',
+]
+
+log = logging.getLogger(__name__)
+
+
+class P2PandaRung(Rung):
+    """Outbound transport rung delivering through p2panda append-only operation chains."""
+
+    name = 'p2panda'
+    rank = 15
+
+    def __init__(
+        self,
+        store: Optional[P2PandaLogStore] = None,
+        identity: Optional[P2PandaIdentityAdapter] = None,
+        enabled: bool = True,
+        clock: Optional[Callable[[], int]] = None,
+    ) -> None:
+        self.store = store
+        self.identity = identity
+        self.enabled = enabled
+        self.clock = clock
+        self.faults = FaultLog(rung=self.name, clock=clock)
+
+    def available(self) -> bool:
+        """The local side of this rung is up and an identity is configured."""
+        return (
+            self.enabled
+            and self.identity is not None
+            and bool(self.identity.author_id)
+            and self.store is not None
+        )
+
+    def target_of(self, desc: Optional[Mapping[str, Any]], theirs: Mapping[str, int]) -> Optional[str]:
+        """Where this rung would reach the peer that published desc."""
+        if desc is not None:
+            _, where = endpoints_of(desc)
+            if 'p2panda' in where:
+                return where['p2panda']
+            for t in desc.get('tags', []):
+                if not t:
+                    continue
+                if t[0] == 'c' and len(t) > 1 and t[1] == 'p2panda':
+                    return ''
+        if 'p2panda' in theirs:
+            return ''
+        return None
+
+    def deliver(self, message: Mapping[str, Any], to_pubkey: str, target: str, anonymous: bool) -> Verdict:
+        """Deliver message by signing and appending a p2panda operation to the log."""
+        if not self.available():
+            raise TransportError('p2panda rung unavailable or not configured with signing identity and store')
+
+        assert self.identity is not None
+        assert self.store is not None
+
+        if self.identity._private_key is None:
+            raise TransportError('p2panda identity does not have private signing key configured')
+
+        author_id = self.identity.author_id
+        try:
+            latest_seq = self.store.get_latest_seq(author_id)
+            next_seq = latest_seq + 1
+            backlink = None
+            if latest_seq >= 0:
+                latest_op = self.store.get_latest_operation(author_id)
+                if latest_op is not None:
+                    backlink = latest_op.id
+
+            # Canonical CBOR serialization of the payload
+            payload_bytes = cbor_encode(dict(message), canonical=True)
+
+            extensions = {
+                'target': to_pubkey,
+                'anonymous': bool(anonymous),
+            }
+
+            op = P2PandaOperation.create(
+                public_key=author_id,
+                body=payload_bytes,
+                seq_num=next_seq,
+                backlink=backlink,
+                private_key=self.identity._private_key,
+                extensions=extensions,
+            )
+
+            self.store.append_operation(op, verify_chain=True)
+
+            # If target specifies an HTTP/HTTPS endpoint, push operation
+            if target and (target.startswith('http://') or target.startswith('https://')):
+                self._push_http(target, op)
+
+            return {self.name: (True, f'delivered via operation {op.id[:16]} seq={op.seq_num}')}
+
+        except Exception as e:
+            self.faults.record(f'deliver failed: {e}', ident=to_pubkey[:16] if to_pubkey else None)
+            raise TransportError(f'p2panda delivery failed: {e}') from e
+
+    def _push_http(self, target_url: str, op: P2PandaOperation) -> None:
+        import urllib.error
+        import urllib.request
+
+        url = target_url
+        if not url.endswith('/p2panda/operations') and not url.endswith('/operations'):
+            url = f"{url.rstrip('/')}/p2panda/operations"
+
+        data = op.to_cbor()
+        req = urllib.request.Request(
+            url,
+            data=data,
+            headers={
+                'Content-Type': 'application/cbor',
+                'User-Agent': 'Fleetmesh-p2panda/0.4.0',
+            },
+            method='POST',
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=5.0) as resp:
+                if resp.status not in (200, 201, 202):
+                    raise TransportError(f"HTTP upstream returned status {resp.status}")
+        except urllib.error.URLError as e:
+            raise TransportError(f"Failed to push operation to {url}: {e}") from e
+
+    def health(self) -> Optional[Mapping[str, Any]]:
+        return {
+            'available': self.available(),
+            'author_id': self.identity.author_id if self.identity else '',
+            'ops_stored': self.store.count_operations() if self.store else 0,
+        }
+
+    def fault_log(self) -> Optional[FaultLog]:
+        return self.faults

node/protocols/p2panda/store.py

@@ -0,0 +1,273 @@
+"""p2panda SQLite persistent operation log store.
+
+Standard library only. Manages persistence and chain verification for:
+- Append-only cryptographic operation logs.
+- Monotonic sequence numbers and backlink verification.
+- Author log indexing and query pagination.
+"""
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Optional, Sequence
+
+from fleetmesh_core.conformance.errors import FleetmeshError
+from fleetmesh_core.wire.p2panda import P2PandaHeader, P2PandaOperation
+from node.compartment.schema import Column, Index, Table
+from node.storage import SqliteStore, store_errors
+
+__all__ = [
+    'P2PandaStoreError',
+    'P2PandaLogStore',
+]
+
+
+class P2PandaStoreError(FleetmeshError):
+    """Base error for p2panda storage operations."""
+    pass
+
+
+from node.protocols.isotime import now_iso as _now_iso  # noqa: E402
+
+
+_COLS = ('op_id, author, seq_num, backlink, previous_seq_num, payload_size, payload_hash, '
+         'timestamp, signature, version, body, extensions_json, created_at')
+"""The column order `_row_to_op` reads positionally.
+
+The selects said `SELECT *` and the rows were indexed by name through a
+`sqlite3.Row` factory. The base hands back plain tuples, so the order is
+written down once here and every select names it - which is sturdier anyway:
+`SELECT *` plus positional indexing would break on the next column added.
+"""
+
+
+class P2PandaLogStore(SqliteStore):
+    """Append-only p2panda operation logs, one row per operation.
+
+    A `SqliteStore` rather than a hand-rolled connection: the base owns the
+    connection, the lock, the per-store schema version, transaction control and
+    the dialect that rewrites placeholders and upserts for another backend.
+    This store opened its own connection per call and declared its schema as a
+    SQL string, so it was SQLite-only and invisible to the locator - see
+    docs/storage-backends.md.
+    """
+
+    SCHEMA = (
+        Table('p2panda_operations', (
+            Column('op_id', 'TEXT', primary_key=True),
+            Column('author', 'TEXT', not_null=True),
+            Column('seq_num', 'INTEGER', not_null=True),
+            Column('backlink', 'TEXT'),
+            Column('previous_seq_num', 'INTEGER'),
+            Column('payload_size', 'INTEGER', not_null=True),
+            Column('payload_hash', 'TEXT', not_null=True),
+            Column('timestamp', 'INTEGER', not_null=True),
+            Column('signature', 'TEXT', not_null=True),
+            Column('version', 'INTEGER', not_null=True, default='1'),
+            Column('body', 'BLOB'),
+            Column('extensions_json', 'TEXT'),
+            Column('created_at', 'TEXT', not_null=True),
+        ), indices=(
+            # The log's real constraint: one operation per (author, seq_num).
+            # It was a table-level UNIQUE in the SQL; a unique index is the
+            # typed layer's way of saying it, and it also serves the lookup
+            # the old non-unique index on the same columns existed for.
+            Index('idx_p2p_ops_author_seq', ('author', 'seq_num'), unique=True),
+            Index('idx_p2p_ops_backlink', ('backlink',)),
+        )),
+    )
+
+    def __init__(self, db_path: str = ":memory:"):
+        if db_path != ":memory:":
+            os.makedirs(os.path.dirname(os.path.abspath(db_path)), exist_ok=True)
+        super().__init__(db_path)
+
+    def _row_to_op(self, row: Sequence[Any]) -> P2PandaOperation:
+        ext = None
+        if row[11]:
+            try:
+                ext = json.loads(row[11])
+            except Exception:
+                ext = None
+
+        header = P2PandaHeader(
+            version=int(row[9]),
+            public_key=str(row[1]),
+            signature=str(row[8]) if row[8] else None,
+            payload_size=int(row[5]),
+            payload_hash=str(row[6]),
+            timestamp=int(row[7]),
+            seq_num=int(row[2]),
+            backlink=str(row[3]) if row[3] else None,
+            previous_seq_num=int(row[4]) if row[4] is not None else None,
+            extensions=ext,
+        )
+        body = bytes(row[10]) if row[10] is not None else None
+        return P2PandaOperation(header=header, body=body)
+
+    def append_operation(self, op: P2PandaOperation, verify_chain: bool = True) -> bool:
+        """Append an operation to the author's log.
+
+        Validates cryptographic integrity and chain monotonicity if verify_chain is True.
+        Returns True if newly inserted, False if idempotent duplicate.
+        """
+        if verify_chain:
+            if not op.verify_signature():
+                raise P2PandaStoreError(f"Signature verification failed for operation {op.id}")
+            if not op.verify_payload():
+                raise P2PandaStoreError(f"Payload integrity verification failed for operation {op.id}")
+
+        author = op.author.lower()
+        op_id = op.id.lower()
+
+        with self._lock:
+            try:
+              with self.transaction() as cur:
+
+                # Check if identical op_id already exists
+                cur.execute("SELECT op_id FROM p2panda_operations WHERE op_id = ?", (op_id,))
+                if cur.fetchone() is not None:
+                    return False
+
+                if verify_chain:
+                    # Query latest operation for author
+                    cur.execute(
+                        "SELECT op_id, seq_num, timestamp FROM p2panda_operations WHERE author = ? ORDER BY seq_num DESC LIMIT 1",
+                        (author,),
+                    )
+                    latest_row = cur.fetchone()
+
+                    if latest_row is None:
+                        # Genesis operation for author
+                        if op.seq_num != 0:
+                            raise P2PandaStoreError(
+                                f"Genesis operation for author {author} must have seq_num 0, got {op.seq_num}"
+                            )
+                        if op.backlink is not None and op.backlink != '':
+                            raise P2PandaStoreError(
+                                f"Genesis operation for author {author} must have null backlink, got {op.backlink}"
+                            )
+                    else:
+                        latest_op_id = str(latest_row[0]).lower()
+                        latest_seq = int(latest_row[1])
+                        latest_ts = int(latest_row[2])
+
+                        expected_seq = latest_seq + 1
+                        if op.seq_num != expected_seq:
+                            if op.seq_num <= latest_seq:
+                                raise P2PandaStoreError(
+                                    f"Fork or duplicate sequence conflict at seq_num={op.seq_num} for author {author}"
+                                )
+                            raise P2PandaStoreError(
+                                f"Missing predecessor operation: author {author} is at seq_num {latest_seq}, got {op.seq_num}"
+                            )
+
+                        if op.backlink is None or op.backlink.lower() != latest_op_id:
+                            raise P2PandaStoreError(
+                                f"Backlink mismatch: expected {latest_op_id}, got {op.backlink}"
+                            )
+
+                        if op.header.timestamp < latest_ts:
+                            raise P2PandaStoreError(
+                                f"Operation timestamp ({op.header.timestamp}) is earlier than predecessor ({latest_ts})"
+                            )
+
+                ext_json = json.dumps(op.header.extensions) if op.header.extensions is not None else None
+
+                cur.execute(
+                    """
+                    INSERT INTO p2panda_operations (
+                        op_id, author, seq_num, backlink, previous_seq_num,
+                        payload_size, payload_hash, timestamp, signature,
+                        version, body, extensions_json, created_at
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        op_id,
+                        author,
+                        op.seq_num,
+                        op.backlink.lower() if op.backlink else None,
+                        op.header.previous_seq_num,
+                        op.header.payload_size,
+                        op.header.payload_hash.lower(),
+                        op.header.timestamp,
+                        op.header.signature.lower() if op.header.signature else '',
+                        op.header.version,
+                        op.body,
+                        ext_json,
+                        _now_iso(),
+                    ),
+                )
+                return True
+            except store_errors() as e:
+                # A sequence collision or the author-seq uniqueness violation.
+                # `store_errors()` rather than `sqlite3.IntegrityError`: the
+                # narrow catch stays narrow and stays correct for a second
+                # driver with its own exception hierarchy.
+                raise P2PandaStoreError(f"Database integrity conflict: {e}") from e
+
+    def get_operation(self, op_id: str) -> Optional[P2PandaOperation]:
+        """Fetch an operation by its op_id."""
+        clean_id = op_id.lower().strip()
+        with self._lock:
+            row = self._one("SELECT " + _COLS + " FROM p2panda_operations WHERE op_id = ?", (clean_id,))
+            return self._row_to_op(row) if row else None
+
+    def get_operation_by_seq(self, author: str, seq_num: int) -> Optional[P2PandaOperation]:
+        """Fetch an operation by author public key and sequence number."""
+        clean_author = author.lower().strip()
+        with self._lock:
+            row = self._one(
+            "SELECT " + _COLS + " FROM p2panda_operations WHERE author = ? AND seq_num = ?",
+                (clean_author, int(seq_num)),
+            )
+            return self._row_to_op(row) if row else None
+
+    def get_latest_operation(self, author: str) -> Optional[P2PandaOperation]:
+        """Fetch the latest operation in an author's log."""
+        clean_author = author.lower().strip()
+        with self._lock:
+            row = self._one(
+                "SELECT " + _COLS + " FROM p2panda_operations "
+                "WHERE author = ? ORDER BY seq_num DESC LIMIT 1",
+                (clean_author,),
+            )
+            return self._row_to_op(row) if row else None
+
+    def get_latest_seq(self, author: str) -> int:
+        """Return the highest seq_num for author, or -1 if no operations exist."""
+        clean_author = author.lower().strip()
+        with self._lock:
+            row = self._one(
+                "SELECT MAX(seq_num) FROM p2panda_operations WHERE author = ?",
+                (clean_author,),
+            )
+            if row and row[0] is not None:
+                return int(row[0])
+            return -1
+
+    def get_log(self, author: str, from_seq: int = 0, limit: int = 100) -> list[P2PandaOperation]:
+        """Return ordered operations for an author from from_seq onwards."""
+        clean_author = author.lower().strip()
+        with self._lock:
+            rows = self._all(
+                "SELECT " + _COLS + " FROM p2panda_operations "
+                "WHERE author = ? AND seq_num >= ? ORDER BY seq_num ASC LIMIT ?",
+                (clean_author, int(from_seq), max(1, min(int(limit), 100_000))),
+            )
+            return [self._row_to_op(r) for r in rows]
+
+    def count_operations(self) -> int:
+        """Return total count of operations across all authors."""
+        with self._lock:
+            row = self._one("SELECT COUNT(*) AS total FROM p2panda_operations")
+            return int(row[0]) if row else 0
+
+    def list_authors(self) -> list[str]:
+        """Return a sorted list of unique authors with operations in store."""
+        with self._lock:
+            return [str(r[0]) for r in
+                    self._all("SELECT DISTINCT author FROM p2panda_operations ORDER BY author ASC")]
+
+    def close(self) -> None:
+        super().close()