Refactor backend to use request-scoped SQLite connections

backend/app/tasks/blocklist_import.py

@@ -17,9 +17,13 @@ from typing import TYPE_CHECKING, Any
 
 import structlog
 
+from app.db import open_db
 from app.models.blocklist import ScheduleFrequency
 from app.services import blocklist_service
 
+if TYPE_CHECKING:
+    import aiosqlite
+
 if TYPE_CHECKING:
     from fastapi import FastAPI
 
@@ -29,6 +33,15 @@ log: structlog.stdlib.BoundLogger = structlog.get_logger()
 JOB_ID: str = "blocklist_import"
 
 
+async def _get_db(app: Any) -> tuple[aiosqlite.Connection, bool]:
+    existing_db = getattr(app.state, "db", None)
+    if existing_db is not None:
+        return existing_db, False
+
+    db = await open_db(app.state.settings.database_path)
+    return db, True
+
+
 async def _run_import(app: Any) -> None:
     """APScheduler callback that imports all enabled blocklist sources.
 
@@ -39,12 +52,10 @@ async def _run_import(app: Any) -> None:
         app: The :class:`fastapi.FastAPI` application instance passed via
             APScheduler ``kwargs``.
     """
-    db = app.state.db
+    db, close_db = await _get_db(app)
     http_session = app.state.http_session
     socket_path: str = app.state.settings.fail2ban_socket
 
-    from app.services import jail_service
-
     log.info("blocklist_import_starting")
     try:
         result = await blocklist_service.import_all(
@@ -60,6 +71,9 @@ async def _run_import(app: Any) -> None:
         )
     except Exception:
         log.exception("blocklist_import_unexpected_error")
+    finally:
+        if close_db:
+            await db.close()
 
 
 def register(app: FastAPI) -> None:
@@ -78,7 +92,12 @@ def register(app: FastAPI) -> None:
     import asyncio  # noqa: PLC0415
 
     async def _do_register() -> None:
-        config = await blocklist_service.get_schedule(app.state.db)
+        db, close_db = await _get_db(app)
+        try:
+            config = await blocklist_service.get_schedule(db)
+        finally:
+            if close_db:
+                await db.close()
         _apply_schedule(app, config)
 
     # APScheduler is synchronous at registration time; use asyncio to read
@@ -104,7 +123,12 @@ def reschedule(app: FastAPI) -> None:
     import asyncio  # noqa: PLC0415
 
     async def _do_reschedule() -> None:
-        config = await blocklist_service.get_schedule(app.state.db)
+        db, close_db = await _get_db(app)
+        try:
+            config = await blocklist_service.get_schedule(db)
+        finally:
+            if close_db:
+                await db.close()
         _apply_schedule(app, config)
 
     asyncio.ensure_future(_do_reschedule())

backend/app/tasks/geo_cache_flush.py

@@ -15,6 +15,10 @@ from typing import TYPE_CHECKING, Any
 
 import structlog
 
+from app.db import open_db
+
+if TYPE_CHECKING:
+    import aiosqlite
 from app.services import geo_service
 
 if TYPE_CHECKING:
@@ -29,6 +33,15 @@ GEO_FLUSH_INTERVAL: int = 60
 JOB_ID: str = "geo_cache_flush"
 
 
+async def _get_db(app: Any) -> tuple[aiosqlite.Connection, bool]:
+    existing_db = getattr(app.state, "db", None)
+    if existing_db is not None:
+        return existing_db, False
+
+    db = await open_db(app.state.settings.database_path)
+    return db, True
+
+
 async def _run_flush(app: Any) -> None:
     """Flush the geo service dirty set to the application database.
 
@@ -39,8 +52,13 @@ async def _run_flush(app: Any) -> None:
         app: The :class:`fastapi.FastAPI` application instance passed via
             APScheduler ``kwargs``.
     """
-    db = app.state.db
-    count = await geo_service.flush_dirty(db)
+    db, close_db = await _get_db(app)
+    try:
+        count = await geo_service.flush_dirty(db)
+    finally:
+        if close_db:
+            await db.close()
+
     if count > 0:
         log.debug("geo_cache_flush_ran", flushed=count)
 

backend/app/tasks/geo_re_resolve.py

@@ -21,6 +21,10 @@ from typing import TYPE_CHECKING
 
 import structlog
 
+from app.db import open_db
+
+if TYPE_CHECKING:
+    import aiosqlite
 from app.services import geo_service
 
 if TYPE_CHECKING:
@@ -35,6 +39,15 @@ GEO_RE_RESOLVE_INTERVAL: int = 600
 JOB_ID: str = "geo_re_resolve"
 
 
+async def _get_db(app: FastAPI) -> tuple[aiosqlite.Connection, bool]:
+    existing_db = getattr(app.state, "db", None)
+    if existing_db is not None:
+        return existing_db, False
+
+    db = await open_db(app.state.settings.database_path)
+    return db, True
+
+
 async def _run_re_resolve(app: FastAPI) -> None:
     """Query NULL-country IPs from the database and re-resolve them.
 
@@ -45,33 +58,37 @@ async def _run_re_resolve(app: FastAPI) -> None:
         app: The :class:`fastapi.FastAPI` application instance passed via
             APScheduler ``kwargs``.
     """
-    db = app.state.db
+    db, close_db = await _get_db(app)
     http_session = app.state.http_session
 
-    # Fetch all IPs with NULL country_code from the persistent cache.
-    unresolved_ips = await geo_service.get_unresolved_ips(db)
+    try:
+        # Fetch all IPs with NULL country_code from the persistent cache.
+        unresolved_ips = await geo_service.get_unresolved_ips(db)
 
-    if not unresolved_ips:
-        log.debug("geo_re_resolve_skip", reason="no_unresolved_ips")
-        return
+        if not unresolved_ips:
+            log.debug("geo_re_resolve_skip", reason="no_unresolved_ips")
+            return
 
-    log.info("geo_re_resolve_start", unresolved=len(unresolved_ips))
+        log.info("geo_re_resolve_start", unresolved=len(unresolved_ips))
 
-    # Clear the negative cache so these IPs are eligible for fresh API calls.
-    geo_service.clear_neg_cache()
+        # Clear the negative cache so these IPs are eligible for fresh API calls.
+        geo_service.clear_neg_cache()
 
-    # lookup_batch handles throttling, retries, and persistence when db is
-    # passed.  This is a background task so DB writes are allowed.
-    results = await geo_service.lookup_batch(unresolved_ips, http_session, db=db)
+        # lookup_batch handles throttling, retries, and persistence when db is
+        # passed.  This is a background task so DB writes are allowed.
+        results = await geo_service.lookup_batch(unresolved_ips, http_session, db=db)
 
-    resolved_count: int = sum(
-        1 for info in results.values() if info.country_code is not None
-    )
-    log.info(
-        "geo_re_resolve_complete",
-        retried=len(unresolved_ips),
-        resolved=resolved_count,
-    )
+        resolved_count: int = sum(
+            1 for info in results.values() if info.country_code is not None
+        )
+        log.info(
+            "geo_re_resolve_complete",
+            retried=len(unresolved_ips),
+            resolved=resolved_count,
+        )
+    finally:
+        if close_db:
+            await db.close()
 
 
 def register(app: FastAPI) -> None:

backend/app/tasks/history_sync.py

@@ -9,8 +9,12 @@ from __future__ import annotations
 import datetime
 from typing import TYPE_CHECKING
 
+if TYPE_CHECKING:
+    import aiosqlite
+
 import structlog
 
+from app.db import open_db
 from app.repositories import fail2ban_db_repo
 from app.utils.fail2ban_db_utils import get_fail2ban_db_path
 
@@ -29,6 +33,15 @@ HISTORY_SYNC_INTERVAL: int = 300
 BACKFILL_WINDOW: int = 648000
 
 
+async def _get_db(app: FastAPI) -> tuple[aiosqlite.Connection, bool]:
+    existing_db = getattr(app.state, "db", None)
+    if existing_db is not None:
+        return existing_db, False
+
+    db = await open_db(app.state.settings.database_path)
+    return db, True
+
+
 async def _get_last_archive_ts(db) -> int | None:
     async with db.execute("SELECT MAX(timeofban) FROM history_archive") as cur:
         row = await cur.fetchone()
@@ -38,8 +51,8 @@ async def _get_last_archive_ts(db) -> int | None:
 
 
 async def _run_sync(app: FastAPI) -> None:
-    db = app.state.db
     socket_path: str = app.state.settings.fail2ban_socket
+    db, close_db = await _get_db(app)
 
     try:
         last_ts = await _get_last_archive_ts(db)
@@ -90,6 +103,9 @@ async def _run_sync(app: FastAPI) -> None:
 
     except Exception:
         log.exception("history_sync_failed")
+    finally:
+        if close_db:
+            await db.close()
 
 
 def register(app: FastAPI) -> None: