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

brawny/db/sqlite/repos/jobs.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from typing import Any
+
+from brawny.db.sqlite import mappers, tx
+from brawny.model.types import JobConfig
+
+
+def get_job(db: Any, job_id: str) -> JobConfig | None:
+    row = db.execute_one("SELECT * FROM jobs WHERE job_id = ?", (job_id,))
+    if not row:
+        return None
+    return mappers._row_to_job_config(row)
+
+
+def get_enabled_jobs(db: Any) -> list[JobConfig]:
+    rows = db.execute_returning(
+        """
+        SELECT * FROM jobs
+        WHERE enabled = 1
+          AND (drain_until IS NULL OR drain_until <= CURRENT_TIMESTAMP)
+        ORDER BY job_id
+        """
+    )
+    return [mappers._row_to_job_config(row) for row in rows]
+
+
+def list_all_jobs(db: Any) -> list[JobConfig]:
+    rows = db.execute_returning("SELECT * FROM jobs ORDER BY job_id")
+    return [mappers._row_to_job_config(row) for row in rows]
+
+
+def upsert_job(
+    db: Any,
+    job_id: str,
+    job_name: str,
+    check_interval_blocks: int,
+    enabled: bool = True,
+) -> None:
+    db.execute(
+        """
+        INSERT INTO jobs (job_id, job_name, check_interval_blocks, enabled)
+        VALUES (?, ?, ?, ?)
+        ON CONFLICT(job_id) DO UPDATE SET
+            job_name = excluded.job_name,
+            check_interval_blocks = excluded.check_interval_blocks,
+            updated_at = CURRENT_TIMESTAMP
+        """,
+        (job_id, job_name, check_interval_blocks, enabled),
+    )
+
+
+def update_job_checked(db: Any, job_id: str, block_number: int, triggered: bool = False) -> None:
+    if triggered:
+        db.execute(
+            """
+            UPDATE jobs SET
+                last_checked_block_number = ?,
+                last_triggered_block_number = ?,
+                updated_at = CURRENT_TIMESTAMP
+            WHERE job_id = ?
+            """,
+            (block_number, block_number, job_id),
+        )
+        return
+
+    db.execute(
+        """
+        UPDATE jobs SET
+            last_checked_block_number = ?,
+            updated_at = CURRENT_TIMESTAMP
+        WHERE job_id = ?
+        """,
+        (block_number, job_id),
+    )
+
+
+def set_job_enabled(db: Any, job_id: str, enabled: bool) -> bool:
+    rowcount = db.execute_returning_rowcount(
+        "UPDATE jobs SET enabled = ?, updated_at = CURRENT_TIMESTAMP WHERE job_id = ?",
+        (enabled, job_id),
+    )
+    return rowcount > 0
+
+
+def set_job_drain(
+    db: Any,
+    job_id: str,
+    drain_until: datetime,
+    reason: str | None = None,
+    actor: str | None = None,
+    source: str | None = None,
+) -> bool:
+    with tx.transaction_conn(db) as conn:
+        cursor = conn.cursor()
+        try:
+            cursor.execute(
+                """
+                UPDATE jobs
+                SET drain_until = ?,
+                    drain_reason = ?,
+                    updated_at = CURRENT_TIMESTAMP
+                WHERE job_id = ?
+                """,
+                (drain_until.isoformat(), reason, job_id),
+            )
+            updated = cursor.rowcount > 0
+        finally:
+            cursor.close()
+    if updated:
+        db.record_mutation_audit(
+            entity_type="job",
+            entity_id=job_id,
+            action="drain",
+            actor=actor,
+            reason=reason,
+            source=source,
+            metadata={"drain_until": drain_until.isoformat()},
+        )
+    return updated
+
+
+def clear_job_drain(
+    db: Any,
+    job_id: str,
+    actor: str | None = None,
+    source: str | None = None,
+) -> bool:
+    with tx.transaction_conn(db) as conn:
+        cursor = conn.cursor()
+        try:
+            cursor.execute(
+                """
+                UPDATE jobs
+                SET drain_until = NULL,
+                    drain_reason = NULL,
+                    updated_at = CURRENT_TIMESTAMP
+                WHERE job_id = ?
+                """,
+                (job_id,),
+            )
+            updated = cursor.rowcount > 0
+        finally:
+            cursor.close()
+    if updated:
+        db.record_mutation_audit(
+            entity_type="job",
+            entity_id=job_id,
+            action="undrain",
+            actor=actor,
+            reason=None,
+            source=source,
+        )
+    return updated
+
+
+def delete_job(db: Any, job_id: str) -> bool:
+    with tx.transaction_conn(db) as conn:
+        cursor = conn.cursor()
+        try:
+            cursor.execute("DELETE FROM job_kv WHERE job_id = ?", (job_id,))
+            cursor.execute("DELETE FROM jobs WHERE job_id = ?", (job_id,))
+            deleted = cursor.rowcount > 0
+        finally:
+            cursor.close()
+        return deleted
+
+
+def get_job_kv(db: Any, job_id: str, key: str) -> Any | None:
+    row = db.execute_one(
+        "SELECT value_json FROM job_kv WHERE job_id = ? AND key = ?",
+        (job_id, key),
+    )
+    if not row:
+        return None
+    return mappers.parse_json(row["value_json"])
+
+
+def set_job_kv(db: Any, job_id: str, key: str, value: Any) -> None:
+    value_json = json.dumps(value)
+    db.execute(
+        """
+        INSERT INTO job_kv (job_id, key, value_json)
+        VALUES (?, ?, ?)
+        ON CONFLICT(job_id, key) DO UPDATE SET
+            value_json = excluded.value_json,
+            updated_at = CURRENT_TIMESTAMP
+        """,
+        (job_id, key, value_json),
+    )
+
+
+def delete_job_kv(db: Any, job_id: str, key: str) -> bool:
+    rowcount = db.execute_returning_rowcount(
+        "DELETE FROM job_kv WHERE job_id = ? AND key = ?",
+        (job_id, key),
+    )
+    return rowcount > 0

brawny/db/sqlite/repos/maintenance.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def cleanup_old_intents(
+    db: Any,
+    older_than_days: int,
+    statuses: list[str] | None = None,
+) -> int:
+    if statuses is None:
+        statuses = ["confirmed", "failed", "abandoned"]
+
+    placeholders = ",".join("?" * len(statuses))
+    return db.execute_returning_rowcount(
+        f"""
+        DELETE FROM tx_intents
+        WHERE status IN ({placeholders})
+        AND created_at < datetime('now', ? || ' days')
+        """,
+        (*statuses, f"-{older_than_days}"),
+    )
+
+
+def get_database_stats(db: Any) -> dict[str, Any]:
+    stats: dict[str, Any] = {"type": "sqlite", "path": db._database_path}
+
+    rows = db.execute_returning(
+        "SELECT status, COUNT(*) as count FROM tx_intents GROUP BY status"
+    )
+    stats["intents_by_status"] = {row["status"]: row["count"] for row in rows}
+
+    row = db.execute_one("SELECT COUNT(*) as count FROM jobs")
+    stats["total_jobs"] = row["count"] if row else 0
+
+    row = db.execute_one("SELECT COUNT(*) as count FROM jobs WHERE enabled = 1")
+    stats["enabled_jobs"] = row["count"] if row else 0
+
+    rows = db.execute_returning("SELECT * FROM block_state")
+    stats["block_states"] = [
+        {
+            "chain_id": row["chain_id"],
+            "last_block": row["last_processed_block_number"],
+        }
+        for row in rows
+    ]
+
+    return stats
+
+
+def clear_orphaned_claims(db: Any, chain_id: int, older_than_minutes: int = 2) -> int:
+    return db.execute_returning_rowcount(
+        """
+        UPDATE tx_intents
+        SET claim_token = NULL,
+            claimed_at = NULL,
+            claimed_by = NULL,
+            lease_expires_at = NULL,
+            updated_at = CURRENT_TIMESTAMP
+        WHERE chain_id = ?
+          AND status != 'claimed'
+          AND claim_token IS NOT NULL
+          AND claimed_at IS NOT NULL
+          AND claimed_at < datetime('now', ? || ' minutes')
+        """,
+        (chain_id, f"-{older_than_minutes}"),
+    )
+
+
+def release_orphaned_nonces(db: Any, chain_id: int, older_than_minutes: int = 5) -> int:
+    return db.execute_returning_rowcount(
+        """
+        UPDATE nonce_reservations
+        SET status = 'released',
+            updated_at = CURRENT_TIMESTAMP
+        WHERE chain_id = ?
+          AND status = 'reserved'
+          AND updated_at < datetime('now', ? || ' minutes')
+          AND intent_id IN (
+              SELECT intent_id FROM tx_intents
+              WHERE status IN ('failed', 'abandoned', 'reverted')
+              AND updated_at < datetime('now', ? || ' minutes')
+          )
+        """,
+        (chain_id, f"-{older_than_minutes}", f"-{older_than_minutes}"),
+    )
+
+
+def count_pending_without_attempts(db: Any, chain_id: int) -> int:
+    result = db.execute_one(
+        """
+        SELECT COUNT(*) as count
+        FROM tx_intents ti
+        LEFT JOIN tx_attempts ta ON ti.intent_id = ta.intent_id
+        WHERE ti.chain_id = ?
+          AND ti.status = 'pending'
+          AND ta.attempt_id IS NULL
+        """,
+        (chain_id,),
+    )
+    return result["count"] if result else 0
+
+
+def count_stale_claims(db: Any, chain_id: int, older_than_minutes: int = 10) -> int:
+    result = db.execute_one(
+        """
+        SELECT COUNT(*) as count
+        FROM tx_intents
+        WHERE chain_id = ?
+          AND status = 'claimed'
+          AND claimed_at IS NOT NULL
+          AND COALESCE(lease_expires_at, datetime(claimed_at, ? || ' minutes')) < CURRENT_TIMESTAMP
+        """,
+        (chain_id, f"+{older_than_minutes}"),
+    )
+    return result["count"] if result else 0
+
+
+def count_stuck_claimed(db: Any, chain_id: int, older_than_minutes: int = 10) -> int:
+    result = db.execute_one(
+        """
+        SELECT COUNT(*) as count
+        FROM tx_intents
+        WHERE chain_id = ?
+          AND status = 'claimed'
+          AND COALESCE(lease_expires_at, datetime(claimed_at, ? || ' minutes')) < CURRENT_TIMESTAMP
+        """,
+        (chain_id, f"+{older_than_minutes}"),
+    )
+    return result["count"] if result else 0
+
+
+def count_orphaned_claims(db: Any, chain_id: int) -> int:
+    result = db.execute_one(
+        """
+        SELECT COUNT(*) as count
+        FROM tx_intents
+        WHERE chain_id = ?
+          AND status != 'claimed'
+          AND claim_token IS NOT NULL
+        """,
+        (chain_id,),
+    )
+    return result["count"] if result else 0
+
+
+def count_orphaned_nonces(db: Any, chain_id: int) -> int:
+    result = db.execute_one(
+        """
+        SELECT COUNT(*) as count
+        FROM nonce_reservations nr
+        JOIN tx_intents ti ON nr.intent_id = ti.intent_id
+        WHERE nr.chain_id = ?
+          AND nr.status IN ('reserved', 'in_flight')
+          AND ti.status IN ('failed', 'abandoned', 'reverted')
+        """,
+        (chain_id,),
+    )
+    return result["count"] if result else 0
+
+
+def get_oldest_nonce_gap_age_seconds(db: Any, chain_id: int) -> float:
+    result = db.execute_one(
+        """
+        SELECT COALESCE(
+            (julianday('now') - julianday(datetime(MIN(nr.created_at)))) * 86400,
+            0
+        ) AS oldest_gap_seconds
+        FROM signers s
+        JOIN nonce_reservations nr
+          ON nr.chain_id = s.chain_id
+         AND nr.signer_address = s.signer_address
+        WHERE s.chain_id = ?
+          AND s.last_synced_chain_nonce IS NOT NULL
+          AND nr.status IN ('reserved', 'in_flight')
+          AND nr.nonce < s.last_synced_chain_nonce
+        """,
+        (chain_id,),
+    )
+    if not result:
+        return 0.0
+    return float(result["oldest_gap_seconds"])