mcp-hangar 0.2.0__py3-none-any.whl

mcp_hangar/infrastructure/persistence/recovery_service.py

@@ -0,0 +1,312 @@
+"""Recovery service for system startup.
+
+Responsible for loading persisted provider configurations and
+restoring system state after restart.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+from ...domain.contracts.persistence import AuditAction, AuditEntry, ProviderConfigSnapshot
+from ...domain.model import Provider
+from ...domain.repository import IProviderRepository
+from ...logging_config import get_logger
+from .audit_repository import SQLiteAuditRepository
+from .config_repository import SQLiteProviderConfigRepository
+from .database import Database
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class RecoveryResult:
+    """Result of a recovery operation."""
+
+    recovered_count: int = 0
+    failed_count: int = 0
+    skipped_count: int = 0
+    recovered_ids: List[str] = field(default_factory=list)
+    failed_ids: List[str] = field(default_factory=list)
+    errors: Dict[str, str] = field(default_factory=dict)
+    duration_ms: float = 0.0
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+
+
+class RecoveryService:
+    """Service for recovering system state on startup.
+
+    Loads persisted provider configurations from the database
+    and registers them with the provider repository.
+    """
+
+    def __init__(
+        self,
+        database: Database,
+        provider_repository: IProviderRepository,
+        config_repository: Optional[SQLiteProviderConfigRepository] = None,
+        audit_repository: Optional[SQLiteAuditRepository] = None,
+        auto_start: bool = False,
+    ):
+        """Initialize recovery service.
+
+        Args:
+            database: Database instance
+            provider_repository: Repository for registering recovered providers
+            config_repository: Optional config repository (created if not provided)
+            audit_repository: Optional audit repository for logging recovery
+            auto_start: Whether to auto-start recovered providers
+        """
+        self._db = database
+        self._provider_repo = provider_repository
+        self._config_repo = config_repository or SQLiteProviderConfigRepository(database)
+        self._audit_repo = audit_repository or SQLiteAuditRepository(database)
+        self._auto_start = auto_start
+        self._last_recovery: Optional[RecoveryResult] = None
+
+    async def recover_providers(self) -> List[str]:
+        """Recover all provider configurations from storage.
+
+        Loads saved configurations and registers Provider aggregates
+        with the provider repository.
+
+        Returns:
+            List of recovered provider IDs
+        """
+        result = RecoveryResult(started_at=datetime.now(timezone.utc))
+        start_time = datetime.now(timezone.utc)
+
+        try:
+            # Ensure database is initialized
+            await self._db.initialize()
+
+            # Load all enabled configurations
+            configs = await self._config_repo.get_all()
+
+            logger.info(f"Recovery: Found {len(configs)} provider configurations")
+
+            for config in configs:
+                try:
+                    # Create Provider aggregate from config
+                    provider = self._create_provider_from_config(config)
+
+                    # Register with repository
+                    self._provider_repo.add(config.provider_id, provider)
+
+                    result.recovered_count += 1
+                    result.recovered_ids.append(config.provider_id)
+
+                    logger.debug(f"Recovery: Restored provider {config.provider_id}")
+
+                except Exception as e:
+                    result.failed_count += 1
+                    result.failed_ids.append(config.provider_id)
+                    result.errors[config.provider_id] = str(e)
+                    logger.error(f"Recovery: Failed to restore provider {config.provider_id}: {e}")
+
+            # Record recovery in audit log
+            await self._record_recovery_audit(result)
+
+        except Exception as e:
+            logger.error(f"Recovery: Critical failure: {e}")
+            result.errors["_critical"] = str(e)
+
+        finally:
+            result.completed_at = datetime.now(timezone.utc)
+            result.duration_ms = (result.completed_at - start_time).total_seconds() * 1000
+            self._last_recovery = result
+
+        logger.info(
+            f"Recovery completed: {result.recovered_count} recovered, "
+            f"{result.failed_count} failed, {result.duration_ms:.2f}ms"
+        )
+
+        return result.recovered_ids
+
+    def _create_provider_from_config(self, config: ProviderConfigSnapshot) -> Provider:
+        """Create Provider aggregate from configuration snapshot.
+
+        Args:
+            config: Provider configuration snapshot
+
+        Returns:
+            Provider aggregate instance
+        """
+        return Provider(
+            provider_id=config.provider_id,
+            mode=config.mode,
+            command=config.command,
+            image=config.image,
+            endpoint=config.endpoint,
+            env=config.env,
+            idle_ttl_s=config.idle_ttl_s,
+            health_check_interval_s=config.health_check_interval_s,
+            max_consecutive_failures=config.max_consecutive_failures,
+            description=config.description,
+            volumes=config.volumes,
+            build=config.build,
+            resources=config.resources,
+            network=config.network,
+            read_only=config.read_only,
+            user=config.user,
+            tools=config.tools,
+        )
+
+    async def _record_recovery_audit(self, result: RecoveryResult) -> None:
+        """Record recovery operation in audit log.
+
+        Args:
+            result: Recovery result to record
+        """
+        try:
+            await self._audit_repo.append(
+                AuditEntry(
+                    entity_id="_system",
+                    entity_type="recovery",
+                    action=AuditAction.RECOVERED,
+                    timestamp=result.completed_at or datetime.now(timezone.utc),
+                    actor="system",
+                    metadata={
+                        "recovered_count": result.recovered_count,
+                        "failed_count": result.failed_count,
+                        "duration_ms": result.duration_ms,
+                        "recovered_ids": result.recovered_ids,
+                        "failed_ids": result.failed_ids,
+                        "errors": result.errors,
+                    },
+                )
+            )
+        except Exception as e:
+            logger.warning(f"Failed to record recovery audit: {e}")
+
+    async def get_recovery_status(self) -> Dict[str, Any]:
+        """Get status of last recovery operation.
+
+        Returns:
+            Dictionary with recovery metrics and status
+        """
+        if self._last_recovery is None:
+            return {
+                "status": "not_run",
+                "message": "No recovery has been performed",
+            }
+
+        result = self._last_recovery
+
+        return {
+            "status": "completed" if not result.errors else "completed_with_errors",
+            "recovered_count": result.recovered_count,
+            "failed_count": result.failed_count,
+            "skipped_count": result.skipped_count,
+            "duration_ms": result.duration_ms,
+            "started_at": result.started_at.isoformat() if result.started_at else None,
+            "completed_at": (result.completed_at.isoformat() if result.completed_at else None),
+            "recovered_ids": result.recovered_ids,
+            "failed_ids": result.failed_ids,
+            "errors": result.errors,
+        }
+
+    async def recover_single_provider(self, provider_id: str) -> bool:
+        """Recover a single provider from storage.
+
+        Useful for re-loading a specific provider without full recovery.
+
+        Args:
+            provider_id: Provider identifier to recover
+
+        Returns:
+            True if recovered successfully, False otherwise
+        """
+        try:
+            config = await self._config_repo.get(provider_id)
+
+            if config is None:
+                logger.warning(f"Recovery: No config found for {provider_id}")
+                return False
+
+            provider = self._create_provider_from_config(config)
+            self._provider_repo.add(provider_id, provider)
+
+            logger.info(f"Recovery: Single provider {provider_id} restored")
+            return True
+
+        except Exception as e:
+            logger.error(f"Recovery: Failed to restore {provider_id}: {e}")
+            return False
+
+    async def save_provider_config(self, provider: Provider) -> None:
+        """Save a provider's configuration to persistent storage.
+
+        Creates a snapshot of the current provider configuration
+        and persists it for future recovery.
+
+        Args:
+            provider: Provider to save configuration for
+        """
+        config = ProviderConfigSnapshot(
+            provider_id=provider.provider_id,
+            mode=provider.mode_str,
+            command=provider._command,
+            image=provider._image,
+            endpoint=provider._endpoint,
+            env=provider._env,
+            idle_ttl_s=provider._idle_ttl.seconds,
+            health_check_interval_s=provider._health_check_interval.seconds,
+            max_consecutive_failures=provider._health.max_consecutive_failures,
+            description=provider.description,
+            volumes=provider._volumes,
+            build=provider._build,
+            resources=provider._resources,
+            network=provider._network,
+            read_only=provider._read_only,
+            user=provider._user,
+            tools=([t.to_dict() for t in provider.tools] if provider._tools_predefined else None),
+            enabled=True,
+        )
+
+        await self._config_repo.save(config)
+
+        # Record in audit log
+        await self._audit_repo.append(
+            AuditEntry(
+                entity_id=provider.provider_id,
+                entity_type="provider",
+                action=AuditAction.UPDATED,
+                timestamp=datetime.now(timezone.utc),
+                actor="system",
+                new_state=config.to_dict(),
+            )
+        )
+
+        logger.debug(f"Saved config for provider: {provider.provider_id}")
+
+    async def delete_provider_config(self, provider_id: str) -> bool:
+        """Delete a provider's configuration from storage.
+
+        Soft-deletes the configuration (marks as disabled).
+
+        Args:
+            provider_id: Provider identifier
+
+        Returns:
+            True if deleted, False if not found
+        """
+        # Get current config for audit
+        old_config = await self._config_repo.get(provider_id)
+
+        deleted = await self._config_repo.delete(provider_id)
+
+        if deleted and old_config:
+            await self._audit_repo.append(
+                AuditEntry(
+                    entity_id=provider_id,
+                    entity_type="provider",
+                    action=AuditAction.DELETED,
+                    timestamp=datetime.now(timezone.utc),
+                    actor="system",
+                    old_state=old_config.to_dict(),
+                )
+            )
+
+        return deleted

mcp_hangar/infrastructure/persistence/sqlite_event_store.py

@@ -0,0 +1,386 @@
+"""SQLite-based Event Store implementation.
+
+Provides durable event persistence suitable for single-node deployments.
+For distributed systems, consider PostgreSQL or EventStoreDB.
+"""
+
+from datetime import datetime, timezone
+from pathlib import Path
+import sqlite3
+import threading
+from typing import Iterator
+
+from mcp_hangar.domain.contracts.event_store import ConcurrencyError, IEventStore
+from mcp_hangar.domain.events import DomainEvent
+from mcp_hangar.logging_config import get_logger
+
+from .event_serializer import EventSerializer
+
+logger = get_logger(__name__)
+
+
+class SQLiteEventStore(IEventStore):
+    """SQLite-based event store with optimistic concurrency.
+
+    Thread-safe implementation suitable for single-node deployments.
+
+    Features:
+    - Append-only event storage
+    - Optimistic concurrency control via version checks
+    - Global ordering across all streams
+    - Efficient stream reads with indexing
+
+    Schema:
+    - events: Main event table with global ordering
+    - streams: Track stream versions for concurrency control
+    """
+
+    def __init__(self, db_path: str | Path = ":memory:", *, serializer: EventSerializer | None = None):
+        """Initialize SQLite event store.
+
+        Args:
+            db_path: Path to SQLite database file.
+                Use ":memory:" for in-memory store (testing).
+            serializer: Optional EventSerializer instance. Allows injecting an upcaster-aware serializer.
+        """
+        self._db_path = str(db_path)
+        self._serializer = serializer or EventSerializer()
+        self._lock = threading.Lock()
+        self._is_memory = self._db_path == ":memory:"
+
+        # For in-memory database, keep a persistent connection
+        # (each new connection to :memory: creates a NEW database)
+        self._persistent_conn: sqlite3.Connection | None = None
+        if self._is_memory:
+            self._persistent_conn = self._create_connection()
+
+        self._init_schema()
+
+        logger.info(
+            "sqlite_event_store_initialized",
+            db_path=self._db_path,
+            in_memory=self._is_memory,
+        )
+
+    def _create_connection(self) -> sqlite3.Connection:
+        """Create a new database connection."""
+        conn = sqlite3.connect(self._db_path, check_same_thread=False)
+        conn.row_factory = sqlite3.Row
+        conn.execute("PRAGMA foreign_keys = ON")
+        if not self._is_memory:
+            conn.execute("PRAGMA journal_mode = WAL")
+        return conn
+
+    def _init_schema(self) -> None:
+        """Initialize database schema."""
+        conn = self._connect()
+        try:
+            conn.executescript(
+                """
+                -- Main events table
+                CREATE TABLE IF NOT EXISTS events (
+                    global_position INTEGER PRIMARY KEY AUTOINCREMENT,
+                    stream_id TEXT NOT NULL,
+                    stream_version INTEGER NOT NULL,
+                    event_type TEXT NOT NULL,
+                    data TEXT NOT NULL,
+                    metadata TEXT,
+                    created_at TEXT NOT NULL,
+                    UNIQUE(stream_id, stream_version)
+                );
+
+                -- Index for efficient stream reads
+                CREATE INDEX IF NOT EXISTS idx_events_stream
+                ON events(stream_id, stream_version);
+
+                -- Index for global reads (projections)
+                CREATE INDEX IF NOT EXISTS idx_events_global
+                ON events(global_position);
+
+                -- Stream version tracking for optimistic concurrency
+                CREATE TABLE IF NOT EXISTS streams (
+                    stream_id TEXT PRIMARY KEY,
+                    version INTEGER NOT NULL DEFAULT -1,
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                );
+            """
+            )
+        finally:
+            if not self._is_memory:
+                conn.close()
+
+    def _connect(self) -> sqlite3.Connection:
+        """Get database connection.
+
+        For in-memory databases, returns the persistent connection.
+        For file-based databases, creates a new connection.
+        """
+        if self._is_memory and self._persistent_conn:
+            return self._persistent_conn
+        return self._create_connection()
+
+    def append(
+        self,
+        stream_id: str,
+        events: list[DomainEvent],
+        expected_version: int,
+    ) -> int:
+        """Append events to a stream with optimistic concurrency.
+
+        Args:
+            stream_id: Stream identifier (e.g., "provider:math").
+            events: Events to append.
+            expected_version: Expected current version (-1 for new stream).
+
+        Returns:
+            New stream version after append.
+
+        Raises:
+            ConcurrencyError: If version mismatch.
+        """
+        if not events:
+            return expected_version
+
+        with self._lock:
+            conn = self._connect()
+            try:
+                cursor = conn.cursor()
+                timestamp = datetime.now(timezone.utc).isoformat()
+
+                # Check current version
+                cursor.execute(
+                    "SELECT version FROM streams WHERE stream_id = ?",
+                    (stream_id,),
+                )
+                row = cursor.fetchone()
+                current_version = row["version"] if row else -1
+
+                if current_version != expected_version:
+                    raise ConcurrencyError(stream_id, expected_version, current_version)
+
+                # Append events
+                new_version = current_version
+                for event in events:
+                    new_version += 1
+                    event_type, data = self._serializer.serialize(event)
+
+                    cursor.execute(
+                        """
+                        INSERT INTO events
+                        (stream_id, stream_version, event_type, data, created_at)
+                        VALUES (?, ?, ?, ?, ?)
+                        """,
+                        (stream_id, new_version, event_type, data, timestamp),
+                    )
+
+                # Update or insert stream version
+                if current_version == -1:
+                    cursor.execute(
+                        """
+                        INSERT INTO streams (stream_id, version, created_at, updated_at)
+                        VALUES (?, ?, ?, ?)
+                        """,
+                        (stream_id, new_version, timestamp, timestamp),
+                    )
+                else:
+                    cursor.execute(
+                        """
+                        UPDATE streams SET version = ?, updated_at = ?
+                        WHERE stream_id = ?
+                        """,
+                        (new_version, timestamp, stream_id),
+                    )
+
+                conn.commit()
+
+                logger.debug(
+                    "events_appended",
+                    stream_id=stream_id,
+                    events_count=len(events),
+                    new_version=new_version,
+                )
+
+                return new_version
+
+            except ConcurrencyError:
+                conn.rollback()
+                raise
+            except Exception as e:
+                conn.rollback()
+                logger.error(
+                    "event_append_failed",
+                    stream_id=stream_id,
+                    error=str(e),
+                )
+                raise
+            finally:
+                if not self._is_memory:
+                    conn.close()
+
+    def read_stream(
+        self,
+        stream_id: str,
+        from_version: int = 0,
+    ) -> list[DomainEvent]:
+        """Read events from a stream.
+
+        Args:
+            stream_id: Stream identifier.
+            from_version: Start version (inclusive).
+
+        Returns:
+            List of events in order. Empty if stream doesn't exist.
+        """
+        conn = self._connect()
+        try:
+            cursor = conn.execute(
+                """
+                SELECT event_type, data FROM events
+                WHERE stream_id = ? AND stream_version >= ?
+                ORDER BY stream_version ASC
+                """,
+                (stream_id, from_version),
+            )
+
+            events = []
+            for row in cursor.fetchall():
+                event = self._serializer.deserialize(row["event_type"], row["data"])
+                events.append(event)
+
+            logger.debug(
+                "stream_read",
+                stream_id=stream_id,
+                from_version=from_version,
+                events_count=len(events),
+            )
+
+            return events
+        finally:
+            if not self._is_memory:
+                conn.close()
+
+    def read_all(
+        self,
+        from_position: int = 0,
+        limit: int = 1000,
+    ) -> Iterator[tuple[int, str, DomainEvent]]:
+        """Read all events across streams (for projections).
+
+        Args:
+            from_position: Start position (exclusive).
+            limit: Maximum events to return.
+
+        Yields:
+            Tuples of (global_position, stream_id, event).
+        """
+        conn = self._connect()
+        try:
+            cursor = conn.execute(
+                """
+                SELECT global_position, stream_id, event_type, data
+                FROM events
+                WHERE global_position > ?
+                ORDER BY global_position ASC
+                LIMIT ?
+                """,
+                (from_position, limit),
+            )
+
+            # Fetch all rows first to allow closing connection
+            rows = cursor.fetchall()
+        finally:
+            if not self._is_memory:
+                conn.close()
+
+        for row in rows:
+            event = self._serializer.deserialize(row["event_type"], row["data"])
+            yield row["global_position"], row["stream_id"], event
+
+    def get_stream_version(self, stream_id: str) -> int:
+        """Get current version of a stream.
+
+        Args:
+            stream_id: Stream identifier.
+
+        Returns:
+            Current version, or -1 if stream doesn't exist.
+        """
+        conn = self._connect()
+        try:
+            cursor = conn.execute(
+                "SELECT version FROM streams WHERE stream_id = ?",
+                (stream_id,),
+            )
+            row = cursor.fetchone()
+            return row["version"] if row else -1
+        finally:
+            if not self._is_memory:
+                conn.close()
+
+    def get_all_stream_ids(self) -> list[str]:
+        """Get all stream IDs in the store.
+
+        Returns:
+            List of stream identifiers.
+        """
+        conn = self._connect()
+        try:
+            cursor = conn.execute("SELECT stream_id FROM streams ORDER BY stream_id")
+            return [row["stream_id"] for row in cursor.fetchall()]
+        finally:
+            if not self._is_memory:
+                conn.close()
+
+    def get_event_count(self) -> int:
+        """Get total number of events in the store.
+
+        Returns:
+            Total event count.
+        """
+        conn = self._connect()
+        try:
+            cursor = conn.execute("SELECT COUNT(*) as count FROM events")
+            row = cursor.fetchone()
+            return row["count"] if row else 0
+        finally:
+            if not self._is_memory:
+                conn.close()
+
+    def get_stream_count(self) -> int:
+        """Get total number of streams.
+
+        Returns:
+            Total stream count.
+        """
+        conn = self._connect()
+        try:
+            cursor = conn.execute("SELECT COUNT(*) as count FROM streams")
+            row = cursor.fetchone()
+            return row["count"] if row else 0
+        finally:
+            if not self._is_memory:
+                conn.close()
+
+    def list_streams(self, prefix: str = "") -> list[str]:
+        """List all stream IDs, optionally filtered by prefix.
+
+        Args:
+            prefix: Optional prefix to filter streams.
+
+        Returns:
+            List of stream IDs matching the prefix.
+        """
+        conn = self._connect()
+        try:
+            if prefix:
+                cursor = conn.execute(
+                    "SELECT stream_id FROM streams WHERE stream_id LIKE ? ORDER BY stream_id",
+                    (f"{prefix}%",),
+                )
+            else:
+                cursor = conn.execute("SELECT stream_id FROM streams ORDER BY stream_id")
+            return [row["stream_id"] for row in cursor.fetchall()]
+        finally:
+            if not self._is_memory:
+                conn.close()