brawny 0.1.13__py3-none-any.whl → 0.1.22__py3-none-any.whl

brawny/db/sqlite/connection.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+import os
+import socket
+import sqlite3
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+try:
+    import fcntl
+except ImportError:  # pragma: no cover - non-Unix platforms
+    fcntl = None  # type: ignore
+
+import threading
+
+from brawny.logging import get_logger
+from brawny.model.errors import DatabaseError
+
+logger = get_logger("brawny.db.sqlite")
+
+
+def connect(db: Any) -> None:
+    if db._closed:
+        raise DatabaseError("Database is closed")
+    if db._connected:
+        return
+
+    lock_acquired = False
+    conn = None
+    try:
+        if db._database_path != ":memory:":
+            path = Path(db._database_path)
+            path.parent.mkdir(parents=True, exist_ok=True)
+            _assert_local_filesystem(path)
+            _acquire_db_lock(db, path)
+            lock_acquired = True
+
+        db._closed = False
+        conn = _open_connection(db)
+        db._connected = True
+        journal_mode_row = conn.execute("PRAGMA journal_mode").fetchone()
+        journal_mode = journal_mode_row[0] if journal_mode_row else "unknown"
+        logger.info("sqlite.journal_mode", mode=str(journal_mode).lower())
+    except Exception:
+        if conn is not None:
+            try:
+                conn.close()
+            except Exception:
+                pass
+            with db._conns_lock:
+                db._conns.discard(conn)
+            _clear_thread_local_conn(db)
+        db._connected = False
+        if lock_acquired and db._lock_handle is not None:
+            try:
+                if fcntl is not None:
+                    fcntl.flock(db._lock_handle.fileno(), fcntl.LOCK_UN)
+            finally:
+                db._lock_handle.close()
+                db._lock_handle = None
+                if db._lock_path is not None:
+                    try:
+                        db._lock_path.unlink(missing_ok=True)
+                    except OSError:
+                        pass
+                    db._lock_path = None
+        raise
+
+
+def close(db: Any) -> None:
+    db._closed = True
+    db._connected = False
+    with db._conns_lock:
+        for conn in list(db._conns):
+            try:
+                conn.close()
+            except Exception:
+                pass
+        db._conns.clear()
+        db._conn_generation += 1
+        db._memory_owner_thread_id = None
+    _clear_thread_local_conn(db)
+
+    if db._lock_handle is not None:
+        try:
+            if fcntl is not None:
+                fcntl.flock(db._lock_handle.fileno(), fcntl.LOCK_UN)
+        finally:
+            db._lock_handle.close()
+            db._lock_handle = None
+            if db._lock_path is not None:
+                try:
+                    db._lock_path.unlink(missing_ok=True)
+                except OSError:
+                    pass
+                db._lock_path = None
+
+
+def is_connected(db: Any) -> bool:
+    return db._connected and not db._closed
+
+
+def ensure_connected(db: Any) -> sqlite3.Connection:
+    if db._closed:
+        raise DatabaseError("Database is closed")
+    if not db._connected:
+        raise DatabaseError("Database not connected. Call connect() first.")
+    conn = getattr(db._thread_local, "conn", None)
+    generation = getattr(db._thread_local, "generation", None)
+    if conn is not None and generation == db._conn_generation:
+        return conn
+    return _open_connection(db)
+
+
+def _open_connection(db: Any) -> sqlite3.Connection:
+    if db._database_path == ":memory:":
+        current_thread_id = threading.get_ident()
+        owner_thread_id = db._memory_owner_thread_id
+        if owner_thread_id is None:
+            db._memory_owner_thread_id = current_thread_id
+        elif owner_thread_id != current_thread_id:
+            raise DatabaseError(
+                "SQLite in-memory databases cannot be shared across threads. "
+                f"path={db._database_path} owner_thread_id={owner_thread_id} "
+                f"current_thread_id={current_thread_id}"
+            )
+    conn = sqlite3.connect(
+        db._database_path,
+        detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES,
+        check_same_thread=True,
+        timeout=30.0,
+    )
+    conn.row_factory = sqlite3.Row
+    _assert_minimum_sqlite_version(db)
+    conn.execute("PRAGMA foreign_keys = ON")
+    conn.execute("PRAGMA journal_mode = WAL")
+    conn.execute("PRAGMA synchronous = NORMAL")
+    conn.execute("PRAGMA busy_timeout = 5000")
+    conn.execute("PRAGMA temp_store = MEMORY")
+    db._thread_local.conn = conn
+    db._thread_local.generation = db._conn_generation
+    with db._conns_lock:
+        db._conns.add(conn)
+    return conn
+
+
+def _clear_thread_local_conn(db: Any) -> None:
+    if isinstance(db._thread_local, threading.local):
+        if hasattr(db._thread_local, "conn"):
+            try:
+                del db._thread_local.conn
+            except Exception:
+                pass
+        if hasattr(db._thread_local, "generation"):
+            try:
+                del db._thread_local.generation
+            except Exception:
+                pass
+
+
+def _assert_minimum_sqlite_version(db: Any) -> None:
+    if db._version_checked:
+        return
+    minimum = (3, 35, 0)
+    current = sqlite3.sqlite_version_info
+    if current < minimum:
+        raise DatabaseError(
+            "SQLite >= 3.35 is required (for RETURNING support); "
+            f"found {sqlite3.sqlite_version}"
+        )
+    db._version_checked = True
+
+
+def _acquire_db_lock(db: Any, db_path: Path) -> None:
+    if fcntl is None:
+        raise DatabaseError("SQLite runner lock requires fcntl (Unix-only).")
+
+    lock_path = db_path.with_suffix(db_path.suffix + ".lock")
+    lock_handle = lock_path.open("a+")
+    try:
+        fcntl.flock(lock_handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except OSError as exc:
+        lock_handle.seek(0)
+        existing = lock_handle.read().strip()
+        lock_handle.close()
+        detail = f" Existing lock: {existing}" if existing else ""
+        raise DatabaseError(
+            f"Database lock already held for {db_path}.{detail}"
+        ) from exc
+
+    lock_handle.seek(0)
+    lock_handle.truncate()
+    lock_handle.write(f"{socket.gethostname()}:{os.getpid()}\n")
+    lock_handle.flush()
+    db._lock_handle = lock_handle
+    db._lock_path = lock_path
+
+
+def _assert_local_filesystem(db_path: Path) -> None:
+    fs_type = _detect_fs_type(db_path)
+    if fs_type is None:
+        logger.warning(
+            "sqlite.fs_type_unknown",
+            path=str(db_path),
+            hint="Ensure the database is on a local filesystem (no NFS/SMB).",
+        )
+        return
+
+    fs_type_lower = fs_type.lower()
+    network_fs = {"nfs", "nfs4", "smbfs", "cifs", "afpfs", "fuse.sshfs", "sshfs"}
+    if fs_type_lower in network_fs:
+        raise DatabaseError(
+            f"SQLite database must be on a local filesystem; detected {fs_type} at {db_path}"
+        )
+
+
+def _detect_fs_type(db_path: Path) -> str | None:
+    try:
+        if sys.platform == "darwin":
+            output = subprocess.check_output(["stat", "-f", "%T", str(db_path)])
+            return output.decode().strip()
+        if sys.platform.startswith("linux"):
+            output = subprocess.check_output(
+                ["stat", "-f", "-c", "%T", str(db_path)]
+            )
+            return output.decode().strip()
+    except Exception:
+        return None
+    return None

brawny/db/sqlite/execute.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import sqlite3
+import time
+from typing import Any, Literal
+
+from brawny.logging import get_logger
+from brawny.model.errors import DatabaseError
+
+
+FetchMode = Literal["none", "all", "one", "rowcount"]
+logger = get_logger("brawny.db.sqlite")
+
+
+def _run(
+    db: Any,
+    query: str,
+    params: tuple[Any, ...] | dict[str, Any] | None,
+    *,
+    fetch: FetchMode,
+    commit: bool,
+) -> Any:
+    max_retries = 5
+    backoff = 0.05
+    attempt = 0
+
+    while True:
+        conn = db._ensure_connected()
+        db._circuit_breaker.before_call()
+
+        locked_error: sqlite3.OperationalError | None = None
+        with db._locked():
+            cursor = conn.cursor()
+            try:
+                if params is None:
+                    cursor.execute(query)
+                elif isinstance(params, dict):
+                    cursor.execute(query, params)
+                else:
+                    cursor.execute(query, params)
+
+                if fetch == "all":
+                    rows = cursor.fetchall()
+                    result: Any = [dict(row) for row in rows] if rows else []
+                elif fetch == "one":
+                    row = cursor.fetchone()
+                    result = dict(row) if row else None
+                elif fetch == "rowcount":
+                    result = cursor.rowcount
+                else:
+                    result = None
+
+                if commit and db._tx_depth == 0:
+                    conn.commit()
+                db._circuit_breaker.record_success()
+                return result
+            except sqlite3.OperationalError as e:
+                if "database is locked" in str(e).lower():
+                    locked_error = e
+                else:
+                    db._circuit_breaker.record_failure(e)
+                    raise DatabaseError(f"SQLite query failed: {e}") from e
+            except sqlite3.Error as e:
+                db._circuit_breaker.record_failure(e)
+                raise DatabaseError(f"SQLite query failed: {e}") from e
+            finally:
+                cursor.close()
+
+        if locked_error is not None:
+            if db._tx_depth > 0:
+                db._circuit_breaker.record_failure(locked_error)
+                raise DatabaseError(f"SQLite query failed: {locked_error}") from locked_error
+            attempt += 1
+            if attempt <= max_retries:
+                logger.debug(
+                    "sqlite.lock_retry",
+                    attempt=attempt,
+                    backoff_seconds=backoff,
+                )
+                time.sleep(backoff)
+                backoff = min(backoff * 2, 0.2)
+                continue
+            db._circuit_breaker.record_failure(locked_error)
+            raise DatabaseError(f"SQLite query failed: {locked_error}") from locked_error
+
+
+def execute(
+    db: Any,
+    query: str,
+    params: tuple[Any, ...] | dict[str, Any] | None = None,
+) -> None:
+    _run(db, query, params, fetch="none", commit=True)
+
+
+def execute_returning(
+    db: Any,
+    query: str,
+    params: tuple[Any, ...] | dict[str, Any] | None = None,
+) -> list[dict[str, Any]]:
+    return _run(db, query, params, fetch="all", commit=False)
+
+
+def execute_one(
+    db: Any,
+    query: str,
+    params: tuple[Any, ...] | dict[str, Any] | None = None,
+) -> dict[str, Any] | None:
+    return _run(db, query, params, fetch="one", commit=False)
+
+
+def execute_returning_rowcount(
+    db: Any,
+    query: str,
+    params: tuple[Any, ...] | dict[str, Any] | None = None,
+) -> int:
+    return _run(db, query, params, fetch="rowcount", commit=True)

brawny/db/sqlite/mappers.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from typing import Any
+from uuid import UUID
+
+from brawny.model.enums import AttemptStatus, IntentStatus, NonceStatus
+from brawny.model.types import (
+    GasParams,
+    JobConfig,
+    NonceReservation,
+    RuntimeControl,
+    SignerState,
+    TxAttempt,
+    TxIntent,
+)
+from brawny.types import ClaimedIntent
+from brawny.utils import db_address
+
+
+def adapt_datetime(dt: datetime) -> str:
+    """Adapt datetime to ISO format string for SQLite."""
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt.isoformat()
+
+
+def convert_datetime(val: bytes) -> datetime:
+    """Convert ISO format string from SQLite to datetime."""
+    s = val.decode("utf-8")
+    try:
+        return datetime.fromisoformat(s)
+    except ValueError:
+        return datetime.strptime(s, "%Y-%m-%d %H:%M:%S").replace(tzinfo=timezone.utc)
+
+
+def parse_uuid(value: str | UUID | None) -> UUID | None:
+    if value is None:
+        return None
+    if isinstance(value, UUID):
+        return value
+    return UUID(value)
+
+
+def dump_uuid(value: UUID | None) -> str | None:
+    if value is None:
+        return None
+    return str(value)
+
+
+def parse_json(raw: Any, default: Any | None = None) -> Any:
+    if raw is None:
+        return default
+    if isinstance(raw, str):
+        return json.loads(raw)
+    return raw
+
+
+def parse_datetime(value: datetime | str | None) -> datetime | None:
+    if value is None:
+        return None
+    if isinstance(value, datetime):
+        return value
+    return datetime.fromisoformat(value)
+
+
+def canonicalize_address(address: str) -> str:
+    return db_address(address)
+
+
+def _row_to_job_config(row: dict[str, Any]) -> JobConfig:
+    return JobConfig(
+        job_id=row["job_id"],
+        job_name=row["job_name"],
+        enabled=bool(row["enabled"]),
+        check_interval_blocks=row["check_interval_blocks"],
+        last_checked_block_number=row["last_checked_block_number"],
+        last_triggered_block_number=row["last_triggered_block_number"],
+        drain_until=row.get("drain_until"),
+        drain_reason=row.get("drain_reason"),
+        created_at=row["created_at"],
+        updated_at=row["updated_at"],
+    )
+
+
+def _row_to_signer_state(row: dict[str, Any]) -> SignerState:
+    return SignerState(
+        chain_id=row["chain_id"],
+        signer_address=row["signer_address"],
+        next_nonce=row["next_nonce"],
+        last_synced_chain_nonce=row["last_synced_chain_nonce"],
+        created_at=row["created_at"],
+        updated_at=row["updated_at"],
+        gap_started_at=row.get("gap_started_at"),
+        alias=row.get("alias"),
+        quarantined_at=row.get("quarantined_at"),
+        quarantine_reason=row.get("quarantine_reason"),
+        replacements_paused=bool(row.get("replacements_paused", 0)),
+    )
+
+
+def _row_to_runtime_control(row: dict[str, Any]) -> RuntimeControl:
+    return RuntimeControl(
+        control=row["control"],
+        active=bool(row["active"]),
+        expires_at=parse_datetime(row.get("expires_at")),
+        reason=row.get("reason"),
+        actor=row.get("actor"),
+        mode=row.get("mode") or "auto",
+        updated_at=row["updated_at"],
+    )
+
+
+def _row_to_nonce_reservation(row: dict[str, Any]) -> NonceReservation:
+    return NonceReservation(
+        id=row["id"],
+        chain_id=row["chain_id"],
+        signer_address=row["signer_address"],
+        nonce=row["nonce"],
+        status=NonceStatus(row["status"]),
+        intent_id=parse_uuid(row["intent_id"]),
+        created_at=row["created_at"],
+        updated_at=row["updated_at"],
+    )
+
+
+def _row_to_intent(row: dict[str, Any]) -> TxIntent:
+    metadata = parse_json(row.get("metadata_json"), default={})
+    return TxIntent(
+        intent_id=parse_uuid(row["intent_id"]),
+        job_id=row["job_id"],
+        chain_id=row["chain_id"],
+        signer_address=row["signer_address"],
+        signer_alias=row.get("signer_alias"),
+        idempotency_key=row["idempotency_key"],
+        to_address=row["to_address"],
+        data=row["data"],
+        value_wei=row["value_wei"],
+        gas_limit=row["gas_limit"],
+        max_fee_per_gas=row["max_fee_per_gas"],
+        max_priority_fee_per_gas=row["max_priority_fee_per_gas"],
+        min_confirmations=row["min_confirmations"],
+        deadline_ts=row["deadline_ts"],
+        retry_after=row["retry_after"],
+        retry_count=row.get("retry_count", 0),
+        status=IntentStatus(row["status"]),
+        claim_token=row["claim_token"],
+        claimed_at=row["claimed_at"],
+        created_at=row["created_at"],
+        updated_at=row["updated_at"],
+        claimed_by=row.get("claimed_by"),
+        lease_expires_at=row.get("lease_expires_at"),
+        broadcast_group=row.get("broadcast_group"),
+        broadcast_endpoints_json=row.get("broadcast_endpoints_json"),
+        broadcast_binding_id=parse_uuid(row.get("broadcast_binding_id")),
+        metadata=metadata,
+    )
+
+
+def _row_to_claimed_intent(row: dict[str, Any]) -> ClaimedIntent:
+    return ClaimedIntent(
+        intent_id=parse_uuid(row["intent_id"]),
+        claim_token=row["claim_token"],
+        claimed_by=row.get("claimed_by"),
+        lease_expires_at=row.get("lease_expires_at"),
+        claimed_at=row["claimed_at"],
+    )
+
+
+def _row_to_attempt(row: dict[str, Any]) -> TxAttempt:
+    return TxAttempt(
+        attempt_id=parse_uuid(row["attempt_id"]),
+        intent_id=parse_uuid(row["intent_id"]),
+        nonce=row["nonce"],
+        tx_hash=row["tx_hash"],
+        gas_params=GasParams.from_json(row["gas_params_json"]),
+        status=AttemptStatus(row["status"]),
+        error_code=row["error_code"],
+        error_detail=row["error_detail"],
+        replaces_attempt_id=parse_uuid(row.get("replaces_attempt_id")),
+        broadcast_block=row["broadcast_block"],
+        broadcast_at=row.get("broadcast_at"),
+        included_block=row.get("included_block"),
+        created_at=row["created_at"],
+        updated_at=row["updated_at"],
+        broadcast_group=row.get("broadcast_group"),
+        endpoint_url=row.get("endpoint_url"),
+        endpoint_binding_id=parse_uuid(row.get("endpoint_binding_id")),
+    )