Wire ADS-B end to end: secondary-sdr container running dump1090

node-26#9. New secondary-sdr-container claims the node's SECOND physical
SDR (RTL-SDR index 1 — op25 always claims index 0; no serial-based binding
yet, same gap op25 itself has). Its control API (start/stop/status/data,
mirroring op25_controller.py) launches dump1090 in adsb mode and exposes
the decoded aircraft.json snapshot; AIS mode 400s until it's wired next.

edge-node: on_config_push starts/stops it when secondary_sdr_mode changes,
lifespan resumes it after a restart if already configured, and a new
telemetry_uplink_loop polls its /secondary/data every 10s and POSTs
non-empty snapshots to C2's new /telemetry/adsb (same bearer-key pattern
call_recorder.py already uses for audio upload).

UNVERIFIED: this container has not been built or run against real hardware
in this session (sandboxed authoring machine, no docker) — dump1090's
--write-json field names are believed correct from its docs but not
confirmed against a real capture. Build + hardware smoke test before this
reaches a real node.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

secondary-sdr-container/Dockerfile

@@ -0,0 +1,52 @@
+# Secondary-SDR Container — node-26#9
+#
+# Claims the node's SECOND physical SDR (the first is always op25's). Mode is
+# chosen at runtime via the control API, not baked in: dump1090 for ADS-B,
+# AIS-catcher for AIS (op25_2 mode is not handled here yet — see node-26#9).
+#
+# Device claiming is by RTL-SDR index, not serial (op25's DeviceConfig.args
+# has no serial concept either — see op25-container/app/models.py). Index 0
+# is reserved for op25; this container always addresses index 1. That's a
+# real limitation once serial-stable device binding matters (hot-unplug /
+# replug can swap indices) — tracked in node-26#9, not fixed here.
+#
+# UNVERIFIED: this image has not been built or run against real hardware in
+# this session (sandboxed authoring machine, no docker). dump1090 and
+# AIS-catcher's exact CLI flags below are believed correct from their
+# published docs but not confirmed against a real capture — the CTO/QA
+# review before this ships to a real node should build and smoke-test it.
+FROM python:3.14-slim
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && \
+    apt-get upgrade -y && \
+    apt-get install -y --no-install-recommends \
+        git build-essential cmake pkg-config \
+        librtlsdr-dev libusb-1.0-0-dev libssl-dev zlib1g-dev usbutils
+
+# dump1090 (antirez/classic) — ADS-B decoder. --write-json support is a
+# long-standing, well-documented feature of this fork.
+RUN git clone https://github.com/antirez/dump1090 /opt/dump1090 && \
+    cd /opt/dump1090 && make
+
+# AIS-catcher — AIS decoder.
+RUN git clone https://github.com/jvde-github/AIS-catcher /opt/AIS-catcher && \
+    cd /opt/AIS-catcher && mkdir build && cd build && cmake .. && make
+
+EXPOSE 8002
+
+VOLUME ["/configs"]
+
+WORKDIR /app
+COPY ./app /app
+
+COPY docker-entrypoint.sh /usr/local/bin/
+RUN sed -i 's/\r$//' /usr/local/bin/docker-entrypoint.sh && \
+    chmod +x /usr/local/bin/docker-entrypoint.sh
+
+COPY requirements.txt /tmp/requirements.txt
+RUN pip3 install --no-cache-dir -r /tmp/requirements.txt
+
+ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]
+CMD ["python", "main.py"]

secondary-sdr-container/app/config.py

@@ -0,0 +1,20 @@
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    # Same rationale as op25-container's OP25_DEBUG_EXPOSE: both containers
+    # share the host network namespace (network_mode: host), so edge-node
+    # reaches this control API over localhost regardless of this flag. False
+    # (default) binds 127.0.0.1; true exposes unauthenticated start/stop to
+    # the node's LAN and should only ever be set for local development.
+    secondary_sdr_debug_expose: bool = False
+
+    class Config:
+        env_file = ".env"
+
+
+settings = Settings()
+
+
+def bind_host() -> str:
+    return "0.0.0.0" if settings.secondary_sdr_debug_expose else "127.0.0.1"

secondary-sdr-container/app/internal/decoder_control.py

@@ -0,0 +1,147 @@
+import json
+import os
+import signal
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from internal.logger import create_logger
+
+LOGGER = create_logger(__name__)
+
+# The node's SECOND SDR, addressed by RTL-SDR index — not serial. op25 always
+# claims index 0 (its DeviceConfig.args has no serial concept either, see
+# op25-container/app/models.py). No hot-plug re-detection: if the two
+# dongles' USB enumeration order changes, this claims the wrong one. Tracked
+# as a real gap in node-26#9, not fixed here.
+SECONDARY_SDR_DEVICE_INDEX = 1
+
+_PGID_FILE = "/tmp/secondary_sdr.pgid"
+_MODE_FILE = "/tmp/secondary_sdr.mode"
+ADSB_JSON_DIR = Path("/tmp/adsb")
+
+
+def _save_state(pgid: int, mode: str) -> None:
+    Path(_PGID_FILE).write_text(str(pgid))
+    Path(_MODE_FILE).write_text(mode)
+
+
+def _read_pgid() -> Optional[int]:
+    try:
+        return int(Path(_PGID_FILE).read_text().strip())
+    except Exception:
+        return None
+
+
+def _read_mode() -> Optional[str]:
+    try:
+        return Path(_MODE_FILE).read_text().strip()
+    except Exception:
+        return None
+
+
+def is_running() -> bool:
+    pgid = _read_pgid()
+    if pgid is None:
+        return False
+    try:
+        os.killpg(pgid, 0)
+        return True
+    except OSError:
+        return False
+
+
+def _adsb_command() -> List[str]:
+    ADSB_JSON_DIR.mkdir(parents=True, exist_ok=True)
+    return [
+        "/opt/dump1090/dump1090",
+        "--net",
+        "--device-index", str(SECONDARY_SDR_DEVICE_INDEX),
+        "--write-json", str(ADSB_JSON_DIR),
+        "--write-json-every", "1",
+    ]
+
+
+def start(mode: str) -> bool:
+    if is_running():
+        stop()
+
+    if mode == "adsb":
+        cmd = _adsb_command()
+    elif mode == "ais":
+        raise ValueError("AIS mode is not wired yet (node-26#9) — only 'adsb' runs today.")
+    else:
+        raise ValueError(f"Unknown secondary SDR mode: {mode!r}")
+
+    try:
+        proc = subprocess.Popen(cmd, preexec_fn=os.setsid)
+        _save_state(proc.pid, mode)
+        LOGGER.info(f"Started secondary SDR decoder mode={mode!r} pid={proc.pid}")
+        return True
+    except Exception as e:
+        LOGGER.error(f"Failed to start secondary SDR decoder mode={mode!r}: {e}")
+        return False
+
+
+def stop() -> bool:
+    pgid = _read_pgid()
+    if pgid is None:
+        return True
+    try:
+        os.killpg(pgid, signal.SIGTERM)
+    except OSError:
+        pass
+    try:
+        os.remove(_PGID_FILE)
+    except OSError:
+        pass
+    try:
+        os.remove(_MODE_FILE)
+    except OSError:
+        pass
+    return True
+
+
+def status() -> Dict[str, Any]:
+    running = is_running()
+    return {
+        "status": "running" if running else "stopped",
+        "mode": _read_mode() if running else None,
+    }
+
+
+def _read_adsb_snapshot() -> List[Dict[str, Any]]:
+    """
+    Map dump1090's aircraft.json (--write-json output) to the server's
+    telemetry schema. Field names (hex/flight/lat/lon/altitude/speed/track)
+    match dump1090's long-documented JSON format — UNVERIFIED against a real
+    capture in this session, see the Dockerfile's caveat.
+    """
+    path = ADSB_JSON_DIR / "aircraft.json"
+    try:
+        raw = json.loads(path.read_text())
+    except Exception:
+        return []
+
+    out = []
+    for a in raw.get("aircraft", []):
+        icao = a.get("hex")
+        if not icao:
+            continue
+        out.append({
+            "icao": icao.upper(),
+            "callsign": (a.get("flight") or "").strip() or None,
+            "lat": a.get("lat"),
+            "lon": a.get("lon"),
+            "altitude_ft": a.get("altitude"),
+            "ground_speed_kt": a.get("speed"),
+            "track_deg": a.get("track"),
+        })
+    return out
+
+
+def data() -> Dict[str, Any]:
+    mode = _read_mode()
+    if mode == "adsb":
+        return {"mode": mode, "aircraft": _read_adsb_snapshot()}
+    return {"mode": mode, "aircraft": []}

secondary-sdr-container/app/internal/logger.py

@@ -0,0 +1,31 @@
+import logging
+from logging.handlers import RotatingFileHandler
+
+
+def create_logger(name, level=logging.DEBUG, max_bytes=10485760, backup_count=2):
+    debug_log_file = "./secondary-sdr.debug.log"
+    info_log_file = "./secondary-sdr.log"
+
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    if not logger.hasHandlers():
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(level)
+
+        debug_file_handler = RotatingFileHandler(debug_log_file, maxBytes=max_bytes, backupCount=backup_count)
+        debug_file_handler.setLevel(logging.DEBUG)
+
+        info_file_handler = RotatingFileHandler(info_log_file, maxBytes=max_bytes, backupCount=backup_count)
+        info_file_handler.setLevel(logging.INFO)
+
+        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        console_handler.setFormatter(formatter)
+        debug_file_handler.setFormatter(formatter)
+        info_file_handler.setFormatter(formatter)
+
+        logger.addHandler(console_handler)
+        logger.addHandler(debug_file_handler)
+        logger.addHandler(info_file_handler)
+
+    return logger

secondary-sdr-container/app/main.py

@@ -0,0 +1,13 @@
+from fastapi import FastAPI
+import routers.secondary_controller as secondary_controller
+from config import bind_host
+
+app = FastAPI()
+
+app.include_router(secondary_controller.create_secondary_router(), prefix="/secondary")
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run("main:app", host=bind_host(), port=8002, reload=True)

secondary-sdr-container/app/routers/secondary_controller.py

@@ -0,0 +1,40 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from internal import decoder_control
+from internal.logger import create_logger
+
+LOGGER = create_logger(__name__)
+
+
+class StartBody(BaseModel):
+    mode: str  # adsb | ais
+
+
+def create_secondary_router():
+    router = APIRouter()
+
+    @router.post("/start")
+    async def start(body: StartBody):
+        try:
+            ok = decoder_control.start(body.mode)
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+        if not ok:
+            raise HTTPException(status_code=500, detail="Failed to start secondary SDR decoder")
+        return {"status": f"secondary SDR started ({body.mode})"}
+
+    @router.post("/stop")
+    async def stop():
+        decoder_control.stop()
+        return {"status": "secondary SDR stopped"}
+
+    @router.get("/status")
+    async def get_status():
+        return decoder_control.status()
+
+    @router.get("/data")
+    async def get_data():
+        return decoder_control.data()
+
+    return router

secondary-sdr-container/docker-entrypoint.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+mkdir -p /tmp/adsb
+exec "$@"

secondary-sdr-container/requirements.txt

@@ -0,0 +1,3 @@
+uvicorn
+fastapi
+pydantic-settings