Initial commit — DRB client (edge node) stack

Includes edge-node (FastAPI/MQTT/Discord voice), op25-container (SDR decoder),
and icecast (audio streaming).

drb-edge-node/app/internal/metadata_watcher.py

@@ -0,0 +1,127 @@
+import asyncio
+import uuid
+from datetime import datetime, timezone
+from typing import Optional, Callable, Awaitable
+from app.internal.op25_client import op25_client
+from app.internal.logger import logger
+
+CallbackFn = Callable[[dict], Awaitable[None]]
+
+HANG_THRESHOLD = 3   # polls before declaring a call ended (1 poll/sec → 3s hang time)
+POLL_INTERVAL = 1.0  # seconds
+
+
+class MetadataWatcher:
+    def __init__(self):
+        self._running = False
+        self._current_tgid: Optional[int] = None
+        self._hang_counter: int = 0
+        self._active_call_id: Optional[str] = None
+        self._call_started_at: Optional[datetime] = None
+
+        # Set these before calling start()
+        self.on_call_start: Optional[CallbackFn] = None
+        self.on_call_end: Optional[CallbackFn] = None
+
+    async def start(self):
+        self._running = True
+        asyncio.create_task(self._poll_loop())
+        logger.info("Metadata watcher started.")
+
+    async def stop(self):
+        self._running = False
+        if self._active_call_id:
+            await self._end_call()
+
+    async def _poll_loop(self):
+        while self._running:
+            try:
+                await self._tick()
+            except Exception as e:
+                logger.warning(f"Metadata poll error: {e}")
+            await asyncio.sleep(POLL_INTERVAL)
+
+    async def _tick(self):
+        status = await op25_client.get_terminal_status()
+
+        if not status:
+            # OP25 not responding — hang-out any active call
+            if self._active_call_id:
+                self._hang_counter += 1
+                if self._hang_counter >= HANG_THRESHOLD:
+                    await self._end_call()
+            return
+
+        # OP25 terminal returns either a list of channels or a single dict
+        channels = status if isinstance(status, list) else [status]
+        active_tgid: Optional[int] = None
+        active_meta: dict = {}
+
+        for ch in channels:
+            tgid = ch.get("tgid") or ch.get("tg_id")
+            if tgid and str(tgid) not in ("0", "", "None"):
+                active_tgid = int(tgid)
+                active_meta = ch
+                break
+
+        if active_tgid:
+            self._hang_counter = 0
+            if self._current_tgid != active_tgid:
+                # Talkgroup changed — close previous call and open a new one
+                if self._active_call_id:
+                    await self._end_call()
+                self._current_tgid = active_tgid
+                await self._start_call(active_tgid, active_meta)
+        else:
+            # No active talkgroup
+            if self._active_call_id:
+                self._hang_counter += 1
+                if self._hang_counter >= HANG_THRESHOLD:
+                    await self._end_call()
+
+    async def _start_call(self, tgid: int, meta: dict):
+        self._active_call_id = str(uuid.uuid4())
+        self._call_started_at = datetime.now(timezone.utc)
+        payload = {
+            "call_id": self._active_call_id,
+            "tgid": tgid,
+            "tgid_name": meta.get("tag") or meta.get("tgid_tag") or "",
+            "freq": meta.get("freq"),
+            "srcaddr": meta.get("srcaddr"),
+            "started_at": self._call_started_at.isoformat(),
+        }
+        logger.info(f"Call start: tgid={tgid} id={self._active_call_id}")
+        if self.on_call_start:
+            await self.on_call_start(payload)
+
+    async def _end_call(self):
+        if not self._active_call_id:
+            return
+        payload = {
+            "call_id": self._active_call_id,
+            "tgid": self._current_tgid,
+            "started_at": self._call_started_at.isoformat() if self._call_started_at else None,
+            "ended_at": datetime.now(timezone.utc).isoformat(),
+        }
+        logger.info(f"Call end: id={self._active_call_id}")
+        self._active_call_id = None
+        self._current_tgid = None
+        self._hang_counter = 0
+        self._call_started_at = None
+        if self.on_call_end:
+            await self.on_call_end(payload)
+
+    @property
+    def active_call_id(self) -> Optional[str]:
+        return self._active_call_id
+
+    @property
+    def current_tgid(self) -> Optional[int]:
+        return self._current_tgid
+
+    @property
+    def is_active(self) -> bool:
+        return self._active_call_id is not None
+
+
+metadata_watcher = MetadataWatcher()