erster docker release

2026-09-15 18:10:57 +02:00
parent 794156a088
commit 9fa589789e
21 changed files with 3182 additions and 71 deletions
@@ -0,0 +1,138 @@
+"""
+Euer-Radio Metadata-Monitor Plugin.
+
+Polls RTMP stream metadata via ffprobe to detect whether a specific show
+is currently live. When the show ends (pattern disappears from metadata),
+the recording is stopped after a configurable grace period.
+"""
+
+import json
+import subprocess
+import threading
+import time
+from typing import Optional, Callable
+
+
+def probe_stream_title(stream_url: str, timeout: int = 10) -> Optional[str]:
+    """Query the current title tag from a live stream via ffprobe."""
+    cmd = [
+        "ffprobe", "-v", "quiet",
+        "-print_format", "json",
+        "-show_entries", "format_tags",
+        stream_url,
+    ]
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            stdin=subprocess.DEVNULL,
+        )
+        if result.returncode != 0:
+            return None
+        data = json.loads(result.stdout)
+        return data.get("format", {}).get("tags", {}).get("title")
+    except (subprocess.TimeoutExpired, json.JSONDecodeError, Exception):
+        return None
+
+
+def title_matches_pattern(title: str, pattern: str) -> bool:
+    """
+    Check whether a stream title matches the configured show pattern.
+
+    TODO: Finalize once we've seen real live-show metadata from euer.tv.
+    Current assumption: the title contains the pattern string as a prefix
+    or substring, e.g. "Donnerwolke live - Artist - Song".
+    """
+    if not title or not pattern:
+        return False
+    return pattern.lower() in title.lower()
+
+
+class MetadataMonitor:
+    """Monitors a stream's metadata and stops the recording when a show ends."""
+
+    def __init__(self, log_fn: Callable, stop_fn: Callable):
+        self._log = log_fn
+        self._stop_recording = stop_fn
+        self._monitors: dict[int, threading.Thread] = {}
+        self._cancel_events: dict[int, threading.Event] = {}
+
+    def start_monitoring(
+        self,
+        rec_id: int,
+        stream_url: str,
+        pattern: str,
+        grace_period: int = 300,
+        poll_interval: int = 30,
+        job_name: str = "",
+    ):
+        if rec_id in self._monitors:
+            return
+
+        cancel = threading.Event()
+        self._cancel_events[rec_id] = cancel
+
+        thread = threading.Thread(
+            target=self._monitor_loop,
+            args=(rec_id, stream_url, pattern, grace_period, poll_interval, cancel, job_name),
+            daemon=True,
+        )
+        self._monitors[rec_id] = thread
+        thread.start()
+        self._log("INFO", f"Metadata-Monitor gestartet für '{job_name}' (Pattern: '{pattern}')", job_name)
+
+    def stop_monitoring(self, rec_id: int):
+        cancel = self._cancel_events.pop(rec_id, None)
+        if cancel:
+            cancel.set()
+        self._monitors.pop(rec_id, None)
+
+    def is_monitoring(self, rec_id: int) -> bool:
+        return rec_id in self._monitors
+
+    def _monitor_loop(
+        self,
+        rec_id: int,
+        stream_url: str,
+        pattern: str,
+        grace_period: int,
+        poll_interval: int,
+        cancel: threading.Event,
+        job_name: str,
+    ):
+        grace_start = None
+
+        while not cancel.is_set():
+            title = probe_stream_title(stream_url)
+
+            if title is None:
+                if cancel.wait(timeout=poll_interval):
+                    break
+                continue
+
+            if title_matches_pattern(title, pattern):
+                if grace_start is not None:
+                    self._log("INFO",
+                              f"Show '{pattern}' wieder erkannt, Karenz abgebrochen [{job_name}]",
+                              job_name)
+                    grace_start = None
+            else:
+                if grace_start is None:
+                    grace_start = time.time()
+                    self._log("INFO",
+                              f"Show '{pattern}' nicht mehr erkannt, Karenzzeit läuft ({grace_period}s) [{job_name}]",
+                              job_name)
+                elif time.time() - grace_start >= grace_period:
+                    self._log("INFO",
+                              f"Karenzzeit abgelaufen, Aufnahme wird gestoppt [{job_name}]",
+                              job_name)
+                    self._stop_recording(rec_id)
+                    break
+
+            if cancel.wait(timeout=poll_interval):
+                break
+
+        self._monitors.pop(rec_id, None)
+        self._cancel_events.pop(rec_id, None)