bvandeusenandClaude Fable 5
7d48eb0b1b
CI & Build / Python lint (push) Successful in 3s
CI & Build / Plugin hooks (push) Successful in 7s
CI & Build / TypeScript typecheck (push) Successful in 12s
CI & Build / integration (push) Successful in 24s
CI & Build / Python tests (push) Successful in 55s
CI & Build / Build & push image (push) Successful in 24s
- background.start_periodic(interval, work, label=) replaces the three hand-rolled while-True/sleep/try loops in logging, auth and notifications. - services/scheduler.ScheduledJob replaces the four private BackgroundScheduler copies in recurrence/version_pinning/trash/db_maintenance schedulers; public start_/stop_/reschedule_ surfaces unchanged. - api_keys.hash_token is the one sha256 helper; auth.py used to inline it 5x. - auth.is_registration_open reads via settings.get_admin_setting; notification prefs read via settings.get_setting; _fire_share_email uses _get_user_email. - projects.get_project_summary / milestones.get_project_milestone_summary are now the one-id view of their batch siblings instead of a second copy of the queries; sharing.best_permission_by (was _deduplicate_by_permission) is the one rank-dedup, now also used by list_projects_for_user. - backup: the row builders for every section both exporters carry are named functions, so a column added to one export cannot silently miss the other. - iso() from models.base replaces the attr.isoformat()-if-attr-else-None idiom and db_maintenance._iso across services; backup keeps its explicit shape. - trash.py hoists the sql_delete/timedelta imports it re-imported per function. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
72 lines
2.6 KiB
Python
72 lines
2.6 KiB
Python
"""Fire-and-forget background tasks that actually run.
|
|
|
|
The event loop holds only a WEAK reference to a task, so a bare
|
|
``create_task`` with no other holder can be garbage-collected mid-flight — a
|
|
write that never errors and never lands (the #2663 GC footgun). This module is
|
|
the one place that gets the pattern right: strong references in ``_pending``,
|
|
discarded on completion, with failures logged at WARNING instead of vanishing.
|
|
|
|
``note_usage`` and ``retrieval_telemetry`` predate this module and carry their
|
|
own copies with bespoke canary semantics; new fire-and-forget callers use this
|
|
instead of writing a fourth copy.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import logging
|
|
from collections.abc import Coroutine
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
_pending: set[asyncio.Task] = set()
|
|
|
|
|
|
def spawn(coro: Coroutine, *, site: str) -> None:
|
|
"""Schedule ``coro`` fire-and-forget; ``site`` names it in failure logs.
|
|
|
|
No running loop (sync context outside the app) closes the coroutine and
|
|
skips — every app path runs on the loop, and blocking would be worse.
|
|
"""
|
|
try:
|
|
task = asyncio.get_running_loop().create_task(coro)
|
|
except RuntimeError:
|
|
coro.close()
|
|
logger.debug("background task %s skipped — no running event loop", site)
|
|
return
|
|
_pending.add(task)
|
|
|
|
def _done(t: asyncio.Task) -> None:
|
|
_pending.discard(t)
|
|
if not t.cancelled() and t.exception() is not None:
|
|
logger.warning(
|
|
"background task %s failed", site, exc_info=t.exception()
|
|
)
|
|
|
|
task.add_done_callback(_done)
|
|
|
|
|
|
def start_periodic(interval_s: float, work, *, label: str) -> asyncio.Task:
|
|
"""A forever loop that sleeps ``interval_s`` then awaits ``work()``, logging
|
|
(never raising) when a tick fails — the one shape the hourly/daily
|
|
retention sweeps share (log retention, notification sweep, auth-token
|
|
purge). Sleeps FIRST so startup isn't a sweep; holds a strong reference
|
|
like spawn() so the loop cannot be garbage-collected mid-flight."""
|
|
async def _loop() -> None:
|
|
while True:
|
|
await asyncio.sleep(interval_s)
|
|
try:
|
|
await work()
|
|
except Exception:
|
|
logger.exception("periodic task %s failed", label)
|
|
|
|
task = asyncio.get_running_loop().create_task(_loop(), name=f"periodic-{label}")
|
|
_pending.add(task)
|
|
task.add_done_callback(_pending.discard)
|
|
return task
|
|
|
|
|
|
async def drain() -> None:
|
|
"""Await everything in flight — for tests that need the writes landed."""
|
|
while _pending:
|
|
await asyncio.gather(*list(_pending), return_exceptions=True)
|