move_detect/edge/config.py

import math
from dataclasses import dataclass

from edge.detectors.fall import FallConfig
from edge.detectors.immobility import ImmobilityConfig
from edge.detectors.ghost import GhostConfig
from edge.detectors.zone import ZoneConfig
from edge.engine import EngineConfig


@dataclass
class Config:
    device_id: str
    camera_id: str
    cafe24_url: str
    secret: str
    fall: FallConfig
    immobility: ImmobilityConfig
    ghost: GhostConfig
    zone: ZoneConfig
    engine: EngineConfig
    # Tier-2 degradation knob: run pose on every Nth tick (1 = every tick, the T1 target).
    # Raise this when a device cannot sustain full-rate inference across all its cameras —
    # it trades reaction granularity for keeping every camera online, which beats going blind
    # on one. See docs/hardware-bringup.md.
    infer_every: int = 1


def _f(env: dict, key: str, default: float) -> float:
    return float(env[key]) if key in env else default


def _positive(env: dict, key: str, default: float) -> float:
    """A timer/threshold knob that must be a finite positive number.

    Every one of these feeds a `now - started >= limit` comparison. NaN makes that comparison
    ALWAYS False and 0/negative makes it ALWAYS True, so a typo in edge.env does not crash —
    it silently turns a detector off, or turns it into a permanent alarm. COOLDOWN_S=nan is the
    worst case: dedup stops suppressing and every tick re-fires the same event. Reject at
    startup, where the operator still sees the message, rather than in the field.
    """
    val = _f(env, key, default)
    if not math.isfinite(val) or val <= 0:
        raise ValueError(f"{key} must be a finite positive number, got {val!r}")
    return val


def frame_interval_from_env(env: dict) -> float:
    """Seconds per frame from TARGET_FPS, validated. TARGET_FPS=0 (ZeroDivisionError) or a
    non-numeric value (ValueError) would otherwise crash at every startup into an infinite
    systemd restart loop (Restart=always + StartLimitIntervalSec=0)."""
    raw = env.get("TARGET_FPS", "12")
    try:
        fps = float(raw)
    except (TypeError, ValueError):
        raise ValueError(f"TARGET_FPS={raw!r} is not a number")
    if fps <= 0:
        raise ValueError(f"TARGET_FPS={raw!r} must be > 0")
    return 1.0 / fps


def queue_db_path(env: dict) -> str:
    """Absolute sqlite path for the offline queue. A relative 'queue.db' resolves against the
    unit's read-only WorkingDirectory under ProtectSystem=strict and cannot be created ->
    crash loop. Default to the systemd StateDirectory, the one writable path."""
    return env.get("QUEUE_DB") or "/var/lib/move-detect/queue.db"


# Ship-time placeholders that are non-empty (so they pass a blank check) yet are never a real
# provisioned value. A unit left at any of these uploads nothing while looking healthy.
_PLACEHOLDER_MARKERS = ("changeme", "your-domain.example", "example.com", "todo", "xxxx")
# Per-device secrets issued by the server are HMAC-derived (long hex); anything shorter is a
# stub left in the template, not a real key.
_MIN_SECRET_LEN = 16


def require_upload_config(cfg: Config) -> None:
    """Fail LOUD at startup when the daemon cannot possibly deliver events.

    load_config defaults cafe24_url and secret to '' so unit tests can build a Config from a
    minimal env — but a real daemon with either blank, left at a ship-time placeholder, or on
    plaintext http runs perfectly green while every upload fails (a bad/empty URL makes requests
    raise, which PostClient catches and returns False; http is refused by allow_redirects=False),
    and the offline queue grows until the SD card is full. The operator sees a healthy unit and
    an empty dashboard, or worker snapshots leave the Pi in plaintext. Refuse to start instead.
    """
    problems: list[str] = []
    url = cfg.cafe24_url.strip()
    secret = cfg.secret.strip()

    if not url:
        problems.append("CAFE24_URL not set")
    elif not url.lower().startswith("https://"):
        problems.append(f"CAFE24_URL must be https:// (got {url!r}) — plaintext would leak "
                        "worker snapshots and the .htaccess redirect is not followed")
    elif any(m in url.lower() for m in _PLACEHOLDER_MARKERS):
        problems.append(f"CAFE24_URL is still a template placeholder ({url!r})")

    if not secret:
        problems.append("DEVICE_SECRET not set")
    elif any(m in secret.lower() for m in _PLACEHOLDER_MARKERS):
        problems.append("DEVICE_SECRET is still a template placeholder (e.g. CHANGEME)")
    elif len(secret) < _MIN_SECRET_LEN:
        problems.append(f"DEVICE_SECRET is too short (<{_MIN_SECRET_LEN} chars) — use the "
                        "per-device secret issued by the server, not a stub")

    if problems:
        raise ValueError(
            "FATAL /etc/move-detect/edge.env: " + "; ".join(problems) + ". The daemon would run "
            "but upload nothing. CAFE24_URL must include the app path, e.g. "
            "https://<domain>/move_detect ; DEVICE_SECRET is the per-device secret from the server."
        )


def load_config(env: dict) -> Config:
    camera_id = env.get("CAMERA_ID", "cam-01")
    # Per-second stillness threshold (units/second), shared by fall no-motion and immobility.
    # track_displacement is now frame-rate-normalized, so this must be tuned per device — expose
    # it via env instead of forcing a code edit + redeploy. Reject a non-finite or non-positive
    # value at startup (a 0 or NaN would make everything read as "still" -> constant no_motion).
    motion_thr = _positive(env, "MOTION_THR", 0.25)
    fall = FallConfig(
        prone_confirm_s=_positive(env, "FALL_PRONE_S", 3.0),
        no_motion_s=_positive(env, "FALL_NO_MOTION_S", 10.0),
        motion_thr=motion_thr,
    )
    immobility = ImmobilityConfig(immobile_s=_positive(env, "IMMOBILE_S", 120.0),
                                  motion_thr=motion_thr)
    ghost = GhostConfig(reappear_s=_positive(env, "GHOST_REAPPEAR_S", 10.0))
    zone = ZoneConfig(debounce_s=_positive(env, "ZONE_DEBOUNCE_S", 0.75))
    engine = EngineConfig(camera_id=camera_id, cooldown_s=_positive(env, "COOLDOWN_S", 30.0))
    infer_every = int(_positive(env, "INFER_EVERY", 1.0))
    return Config(
        infer_every=infer_every,
        device_id=env.get("DEVICE_ID", "pi-unknown"),
        camera_id=camera_id,
        cafe24_url=env.get("CAFE24_URL", ""),
        secret=env.get("DEVICE_SECRET", ""),
        fall=fall, immobility=immobility, ghost=ghost, zone=zone, engine=engine,
    )