#!/usr/bin/env python3 """Mesh: én sentral som fordeler utrop til flere soner. Hver sone er en vanlig announcer med egen kø og eget anlegg. Sentralen er en vanlig announcer som i tillegg har [zones] i config. Det er hele forskjellen; det finnes ingen «mode», og en sone kan brukes alene hvis sentralen er nede. Bærende valg: - Sentralen syntetiserer én gang og sender ferdig WAV. Sonen trenger da verken nett, edge-tts eller Pipers stemmer for å spille det den får. - Køene forblir per sone. Er hovedscenen opptatt med en lang melding, skal ikke en resepsjonsmelding vente. Dispatcheren fordeler og går videre; hver sone køer selv. - Faller én sone ut, feiler bare den. De andre får meldingen. Modulen kjenner verken Flask eller Player. Den får funksjoner inn: synthesize, play_local og send. Det er det som gjør den testbar uten nett. """ from __future__ import annotations import json import logging import queue import re import secrets import threading import time import urllib.error import urllib.request from dataclasses import asdict, dataclass, field from pathlib import Path from typing import Any, Callable log = logging.getLogger("announcer.mesh") ZONE_NAME = re.compile(r"[A-Za-z0-9_æøåÆØÅ-]{1,32}") # -------------------------------------------------------------------------- # Soner # -------------------------------------------------------------------------- @dataclass(frozen=True) class Zone: name: str url: str = "" # tom = sentralens eget anlegg @property def local(self) -> bool: return not self.url def zones_from_config(raw: dict[str, str]) -> dict[str, Zone]: """[zones] i config: navn -> "local" eller http(s)://…. Feiler høyt på noe annet, så en skrivefeil oppdages ved oppstart og ikke ved første utrop.""" out: dict[str, Zone] = {} for name, target in raw.items(): name = str(name).strip() if not ZONE_NAME.fullmatch(name): raise ValueError(f"[zones]: ugyldig sonenavn {name!r}") target = str(target).strip() if target.lower() == "local": out[name] = Zone(name) elif target.startswith(("http://", "https://")): out[name] = Zone(name, target.rstrip("/")) else: raise ValueError(f'[zones] {name}: {target!r} er verken "local" eller en http-URL') return out # -------------------------------------------------------------------------- # Én fordeling = én melding til N soner # -------------------------------------------------------------------------- # sending -> queued (sonen tok imot) | unreachable (nådde ikke fram) # | rejected (sonen sa nei, f.eks. feil nøkkel) | failed (syntese/lokalt) ZONE_STATUSES = ("sending", "queued", "unreachable", "rejected", "failed") @dataclass class ZoneResult: status: str = "sending" item_id: int | None = None # kø-id på sonen error: str = "" @dataclass class Dispatch: id: str text: str voice: str speed: float chime: str zones: dict[str, ZoneResult] user: str = "" subject: str = "" method: str = "none" sender: str = "" # IP-en forespørselen kom fra created: float = field(default_factory=time.time) schedule_id: str = "" error: str = "" # syntesefeil, da feiler alle soner likt @property def pending(self) -> bool: return any(z.status == "sending" for z in self.zones.values()) @property def accepted(self) -> list[str]: return [n for n, z in self.zones.items() if z.status == "queued"] def summary(self) -> str: """«hovedscene: kø #3, crew: nede» – til planen og loggen.""" parts = [] for name, z in self.zones.items(): if z.status == "queued": parts.append(f"{name}: kø #{z.item_id}") elif z.status == "unreachable": parts.append(f"{name}: nede") else: parts.append(f"{name}: {z.status}") return ", ".join(parts) def public(self, *, show_ip: bool = False) -> dict[str, Any]: return { "id": self.id, "text": self.text, "voice": self.voice, "user": self.user, "sender": self.sender if show_ip else "", "created": self.created, "error": self.error, "zones": {n: asdict(z) for n, z in self.zones.items()}, } class Dispatcher: """Egen tråd og egen kø, atskilt fra Player. Gjør bare fordeling. synthesize(text, voice, speed, chime) -> Path play_local(dispatch, path) -> int kø-id lokalt send(zone, path, dispatch) -> (status, item_id, error) """ def __init__(self, zones: dict[str, Zone], *, synthesize: Callable, play_local: Callable, send: Callable, timeout: float = 5.0, on_finished: Callable | None = None) -> None: self.zones = zones self.synthesize = synthesize self.play_local = play_local self.send = send self.timeout = float(timeout) self.on_finished = on_finished self.q: queue.Queue[Dispatch] = queue.Queue() self.history: list[Dispatch] = [] self.lock = threading.Lock() self._thread: threading.Thread | None = None # -- oppslag ----------------------------------------------------------- def names(self) -> list[str]: return list(self.zones) def resolve(self, requested: Any) -> list[str]: """Tom/None = alle. Ukjent navn kaster ValueError før noe sendes.""" if not requested: return self.names() if isinstance(requested, str): requested = [requested] if not isinstance(requested, (list, tuple)): raise ValueError("zones må være en liste med sonenavn") out: list[str] = [] for name in requested: name = str(name).strip() if name not in self.zones: raise ValueError(f"Ukjent sone: {name}") if name not in out: out.append(name) return out # -- innlevering ------------------------------------------------------- def submit(self, text: str, voice: str, speed: float, chime: str, zone_names: list[str], *, user: str = "", subject: str = "", method: str = "none", sender: str = "", schedule_id: str = "") -> Dispatch: d = Dispatch( id=secrets.token_hex(4), text=text, voice=voice, speed=speed, chime=chime, zones={n: ZoneResult() for n in zone_names}, user=user, subject=subject, method=method, sender=sender, schedule_id=schedule_id, ) with self.lock: self.history.append(d) del self.history[:-50] self.q.put(d) return d def snapshot(self, *, show_ip: bool = False) -> list[dict]: with self.lock: return [d.public(show_ip=show_ip) for d in reversed(self.history)][:15] # -- tråden ------------------------------------------------------------ def start(self) -> None: if self._thread is None: self._thread = threading.Thread(target=self._loop, daemon=True, name="dispatcher") self._thread.start() def _loop(self) -> None: while True: try: self.run_once() except Exception: # noqa: BLE001 log.exception("dispatcheren feilet") def run_once(self, timeout: float | None = None) -> Dispatch | None: """Én fordeling, fra syntese til svar fra hver sone. Returnerer den.""" try: d = self.q.get(timeout=timeout) except queue.Empty: return None try: path = self.synthesize(d.text, d.voice, d.speed, d.chime) except Exception as e: # noqa: BLE001 log.exception("syntese feilet for fordeling #%s", d.id) d.error = str(e)[:200] for z in d.zones.values(): z.status, z.error = "failed", d.error self._finish(d) return d threads: list[threading.Thread] = [] for name, result in d.zones.items(): zone = self.zones[name] if zone.local: try: result.item_id = self.play_local(d, path) result.status = "queued" except Exception as e: # noqa: BLE001 result.status, result.error = "failed", str(e)[:200] else: # Hver sone i sin tråd, så en som henger ikke holder igjen de # andre lenger enn timeouten. t = threading.Thread(target=self._send_one, args=(zone, path, d, result), daemon=True, name=f"send-{name}") t.start() threads.append(t) for t in threads: t.join(self.timeout + 1.0) for name, result in d.zones.items(): if result.status == "sending": result.status, result.error = "unreachable", "svarte ikke i tide" self._finish(d) return d def _send_one(self, zone: Zone, path: Path, d: Dispatch, result: ZoneResult) -> None: try: status, item_id, error = self.send(zone, path, d) except Exception as e: # noqa: BLE001 status, item_id, error = "unreachable", None, str(e)[:200] result.status, result.item_id, result.error = status, item_id, error def _finish(self, d: Dispatch) -> None: log.info("fordeling #%s: %s", d.id, d.summary()) if self.on_finished: try: self.on_finished(d) except Exception: # noqa: BLE001 log.exception("on_finished feilet") # -------------------------------------------------------------------------- # Transport: sentral -> sone, stdlib urllib # -------------------------------------------------------------------------- def send_to_zone(zone: Zone, path: Path, d: Dispatch, *, secret: str, timeout: float = 5.0) -> tuple[str, int | None, str]: """POST /api/play på sonen: multipart med fila og metadata. Returnerer (status, kø-id på sonen, feilmelding). Kaster ikke; alt som kan gå galt blir en status, siden kallet skjer i en tråd uten noen å kaste til. """ meta = json.dumps({ "origin_id": d.id, "text": d.text, "voice": d.voice, "user": d.user, "subject": d.subject, "method": d.method, }, ensure_ascii=False).encode() boundary = "----announcer-" + secrets.token_hex(8) nl = b"\r\n" body = b"".join([ b"--" + boundary.encode() + nl, b'Content-Disposition: form-data; name="meta"' + nl, b"Content-Type: application/json; charset=utf-8" + nl + nl, meta + nl, b"--" + boundary.encode() + nl, b'Content-Disposition: form-data; name="wav"; filename="' + path.name.encode() + b'"' + nl, b"Content-Type: audio/wav" + nl + nl, path.read_bytes() + nl, b"--" + boundary.encode() + b"--" + nl, ]) req = urllib.request.Request( f"{zone.url}/api/play", data=body, headers={ "Content-Type": f"multipart/form-data; boundary={boundary}", "X-Mesh-Key": secret, "Accept": "application/json", }, method="POST", ) try: with urllib.request.urlopen(req, timeout=timeout) as r: # noqa: S310 data = json.loads(r.read().decode()) return "queued", int(data["id"]), "" except urllib.error.HTTPError as e: try: msg = json.loads(e.read().decode()).get("error", "") except Exception: # noqa: BLE001 msg = "" return "rejected", None, f"{e.code} {msg or e.reason}".strip() except (urllib.error.URLError, TimeoutError, OSError) as e: reason = getattr(e, "reason", e) return "unreachable", None, str(reason)[:120] except (ValueError, KeyError) as e: return "rejected", None, f"uventet svar ({e})" def fetch_zone_status(zone: Zone, *, secret: str, timeout: float = 2.0) -> dict[str, Any]: """GET /api/status på sonen. Returnerer det UI-et trenger, aldri kaster.""" req = urllib.request.Request( f"{zone.url}/api/status", headers={"X-Mesh-Key": secret, "Accept": "application/json"}, ) try: with urllib.request.urlopen(req, timeout=timeout) as r: # noqa: S310 d = json.loads(r.read().decode()) return { "reachable": True, "current": d.get("current"), "queued": len(d.get("queued") or []), } except urllib.error.HTTPError as e: return {"reachable": False, "error": f"{e.code} {e.reason}"} except (urllib.error.URLError, TimeoutError, OSError) as e: return {"reachable": False, "error": str(getattr(e, "reason", e))[:120]} except ValueError as e: return {"reachable": False, "error": f"uventet svar ({e})"} # -------------------------------------------------------------------------- # Statuspoller: én i bakgrunnen, så N nettlesere ikke gir N x soner kall # -------------------------------------------------------------------------- class ZonePoller: """Henter status fra hver ekstern sone med jevne mellomrom og cacher den. Den lokale sonen slås opp ferskt ved hvert snapshot via local_status, så eget anlegg aldri er to sekunder på etterskudd. """ def __init__(self, zones: dict[str, Zone], *, fetch: Callable, interval: float = 2.0, local_status: Callable[[], dict] | None = None) -> None: self.zones = zones self.fetch = fetch self.interval = float(interval) self.local_status = local_status self.lock = threading.Lock() self.cache: dict[str, dict] = { z.name: {"reachable": False, "error": "ikke spurt ennå"} for z in zones.values() if not z.local } self._thread: threading.Thread | None = None def poll_once(self) -> None: remote = [z for z in self.zones.values() if not z.local] results: dict[str, dict] = {} def one(z: Zone) -> None: try: results[z.name] = self.fetch(z) except Exception as e: # noqa: BLE001 results[z.name] = {"reachable": False, "error": str(e)[:120]} threads = [threading.Thread(target=one, args=(z,), daemon=True) for z in remote] for t in threads: t.start() for t in threads: t.join(5.0) with self.lock: for z in remote: self.cache[z.name] = results.get(z.name, {"reachable": False, "error": "svarte ikke"}) self.cache[z.name]["checked"] = time.time() def snapshot(self) -> dict[str, dict]: out: dict[str, dict] = {} for z in self.zones.values(): if z.local: out[z.name] = {"reachable": True, **(self.local_status() if self.local_status else {})} else: with self.lock: out[z.name] = dict(self.cache.get(z.name, {"reachable": False})) return out def start(self) -> None: if self._thread is None: self._thread = threading.Thread(target=self._loop, daemon=True, name="zone-poller") self._thread.start() def _loop(self) -> None: while True: try: self.poll_once() except Exception: # noqa: BLE001 log.exception("sonepolleren feilet") time.sleep(self.interval)