karldns.de/router_dyndns/store/schema.py

from __future__ import annotations

import secrets
import sqlite3
from pathlib import Path

from ..ddns_security import hash_lookup_token

BUSY_TIMEOUT_MS = 10_000
CACHE_SIZE_KIB = 20_000
MMAP_SIZE_BYTES = 256 * 1024 * 1024
WAL_AUTOCHECKPOINT_PAGES = 1_000
SCHEMA_VERSION = 1


def connect_database(database_path: Path) -> sqlite3.Connection:
    if str(database_path) != ":memory:":
        database_path.parent.mkdir(parents=True, exist_ok=True)
    conn = sqlite3.connect(database_path, check_same_thread=False)
    configure_connection(conn)
    return conn


def configure_connection(conn: sqlite3.Connection) -> None:
    conn.execute("PRAGMA foreign_keys = ON")
    conn.execute(f"PRAGMA busy_timeout = {BUSY_TIMEOUT_MS}")
    conn.execute("PRAGMA temp_store = MEMORY")
    conn.execute(f"PRAGMA cache_size = -{CACHE_SIZE_KIB}")
    conn.execute(f"PRAGMA mmap_size = {MMAP_SIZE_BYTES}")
    conn.execute("PRAGMA synchronous = NORMAL")
    conn.execute(f"PRAGMA wal_autocheckpoint = {WAL_AUTOCHECKPOINT_PAGES}")


def initialize_schema(conn: sqlite3.Connection) -> None:
    configure_connection(conn)
    conn.execute("PRAGMA journal_mode = WAL")
    conn.execute(
        """
        CREATE TABLE IF NOT EXISTS records (
          hostname TEXT PRIMARY KEY,
          ipv4 TEXT,
          ipv6 TEXT,
          updated_at TEXT NOT NULL
        )
        """
    )
    conn.execute(
        """
        CREATE TABLE IF NOT EXISTS update_events (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          hostname TEXT NOT NULL,
          ipv4 TEXT,
          ipv6 TEXT,
          status TEXT NOT NULL,
          detail TEXT NOT NULL,
          source_ip TEXT NOT NULL,
          created_at TEXT NOT NULL
        )
        """
    )
    conn.execute("CREATE INDEX IF NOT EXISTS idx_update_events_created_at ON update_events(created_at)")
    conn.execute("CREATE INDEX IF NOT EXISTS idx_update_events_hostname_created_at ON update_events(hostname, created_at DESC)")
    conn.execute(
        """
        CREATE TABLE IF NOT EXISTS update_event_rollups (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          hostname TEXT NOT NULL,
          ipv4 TEXT,
          ipv6 TEXT,
          status TEXT NOT NULL,
          detail TEXT NOT NULL,
          source_ip TEXT NOT NULL,
          first_seen_at TEXT NOT NULL,
          last_seen_at TEXT NOT NULL,
          count INTEGER NOT NULL,
          UNIQUE(hostname, ipv4, ipv6, status, detail, source_ip)
        )
        """
    )
    conn.execute("CREATE INDEX IF NOT EXISTS idx_update_event_rollups_last_seen_at ON update_event_rollups(last_seen_at)")
    conn.execute(
        """
        CREATE INDEX IF NOT EXISTS idx_update_event_rollups_hostname_last_seen_at
        ON update_event_rollups(hostname, last_seen_at DESC)
        """
    )
    conn.execute(
        """
        CREATE TABLE IF NOT EXISTS cleanup_runs (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          created_at TEXT NOT NULL,
          domain_challenges_deleted INTEGER NOT NULL,
          unused_accounts_deleted INTEGER NOT NULL
        )
        """
    )
    conn.execute("CREATE INDEX IF NOT EXISTS idx_cleanup_runs_created_at ON cleanup_runs(created_at)")
    conn.execute(
        """
        CREATE TABLE IF NOT EXISTS scheduled_tasks (
          name TEXT PRIMARY KEY,
          interval_seconds INTEGER NOT NULL,
          next_run_at TEXT NOT NULL,
          lease_owner TEXT,
          lease_expires_at TEXT,
          last_started_at TEXT,
          last_finished_at TEXT,
          last_status TEXT NOT NULL DEFAULT 'pending',
          last_error TEXT NOT NULL DEFAULT '',
          updated_at TEXT NOT NULL
        )
        """
    )
    conn.execute("CREATE INDEX IF NOT EXISTS idx_scheduled_tasks_next_run_at ON scheduled_tasks(next_run_at)")
    conn.execute(
        """
        CREATE INDEX IF NOT EXISTS idx_scheduled_tasks_due
        ON scheduled_tasks(next_run_at, lease_expires_at)
        """
    )
    conn.execute(
        """
        CREATE TABLE IF NOT EXISTS rate_limits (
          key TEXT NOT NULL,
          window INTEGER NOT NULL,
          count INTEGER NOT NULL,
          PRIMARY KEY(key, window)
        )
        """
    )
    conn.execute("CREATE INDEX IF NOT EXISTS idx_rate_limits_window ON rate_limits(window)")
    conn.execute(
        """
        CREATE TABLE IF NOT EXISTS accounts (
          hostname TEXT PRIMARY KEY,
          username TEXT NOT NULL,
          token_hash TEXT NOT NULL,
          update_slug TEXT NOT NULL UNIQUE,
          management_hash TEXT UNIQUE,
          dashboard_password_hash TEXT,
          created_at TEXT NOT NULL,
          disabled INTEGER NOT NULL DEFAULT 0
        )
        """
    )
    _ensure_column(conn, "accounts", "update_slug", "TEXT")
    _ensure_column(conn, "accounts", "management_hash", "TEXT")
    _ensure_column(conn, "accounts", "dashboard_password_hash", "TEXT")
    for row in conn.execute("SELECT hostname FROM accounts WHERE update_slug IS NULL OR update_slug = ''"):
        conn.execute("UPDATE accounts SET update_slug = ? WHERE hostname = ?", (secrets.token_urlsafe(32), row[0]))
    for row in conn.execute("SELECT hostname FROM accounts WHERE management_hash IS NULL OR management_hash = ''"):
        conn.execute(
            "UPDATE accounts SET management_hash = ? WHERE hostname = ?",
            (hash_lookup_token(secrets.token_urlsafe(32)), row[0]),
        )
    conn.execute("CREATE UNIQUE INDEX IF NOT EXISTS idx_accounts_update_slug ON accounts(update_slug)")
    conn.execute("CREATE UNIQUE INDEX IF NOT EXISTS idx_accounts_management_hash ON accounts(management_hash)")
    conn.execute("CREATE INDEX IF NOT EXISTS idx_accounts_created_at ON accounts(created_at)")
    conn.execute("CREATE INDEX IF NOT EXISTS idx_accounts_hostname_username ON accounts(hostname, username)")
    conn.execute(
        """
        CREATE TABLE IF NOT EXISTS domain_challenges (
          domain TEXT PRIMARY KEY,
          token TEXT NOT NULL,
          claim_hash TEXT,
          owner_hostname TEXT,
          created_at TEXT NOT NULL,
          verified_at TEXT
        )
        """
    )
    _ensure_column(conn, "domain_challenges", "claim_hash", "TEXT")
    _ensure_column(conn, "domain_challenges", "owner_hostname", "TEXT")
    conn.execute("CREATE INDEX IF NOT EXISTS idx_domain_challenges_owner_hostname ON domain_challenges(owner_hostname)")
    conn.execute("CREATE INDEX IF NOT EXISTS idx_domain_challenges_owner_verified ON domain_challenges(owner_hostname, verified_at)")
    conn.execute("CREATE INDEX IF NOT EXISTS idx_domain_challenges_claim_hash ON domain_challenges(claim_hash)")
    conn.execute("CREATE INDEX IF NOT EXISTS idx_domain_challenges_created_at ON domain_challenges(created_at)")
    conn.execute(
        """
        CREATE INDEX IF NOT EXISTS idx_domain_challenges_unverified_created
        ON domain_challenges(created_at)
        WHERE verified_at IS NULL
        """
    )
    if conn.execute("PRAGMA user_version").fetchone()[0] < SCHEMA_VERSION:
        conn.execute(f"PRAGMA user_version = {SCHEMA_VERSION}")
    conn.execute("PRAGMA optimize")


def _ensure_column(conn: sqlite3.Connection, table: str, column: str, definition: str) -> None:
    columns = {row[1] for row in conn.execute(f"PRAGMA table_info({table})")}
    if column not in columns:
        conn.execute(f"ALTER TABLE {table} ADD COLUMN {column} {definition}")