205 lines
7.8 KiB
Python
205 lines
7.8 KiB
Python
#!/usr/bin/env python3
|
|
"""Webcam-Relay: holt den MJPEG-Stream der Kamera einmal ab und stellt ihn
|
|
per HTTP für beliebig viele Zuschauer bereit (hinter Zoraxy / Reverse Proxy).
|
|
|
|
Endpunkte:
|
|
/ Übersicht aller Kameras
|
|
/<name>/ Webseite mit Livebild einer Kamera
|
|
/<name>/stream.mjpg Livestream (multipart/x-mixed-replace)
|
|
/<name>/snapshot.jpg aktuelles Einzelbild
|
|
/stream.mjpg Alias für die erste Kamera (Abwärtskompatibilität)
|
|
/health Status aller Kameras
|
|
|
|
Konfiguration über die Datei .env (neben relay.py) oder Umgebungsvariablen:
|
|
CAMERA_<name>=<url> eine Zeile pro Kamera, z.B. CAMERA_cam1=http://...
|
|
PORT (default 8000)
|
|
AUTH_USER / AUTH_PASS optional: Basic-Auth (nur sinnvoll mit HTTPS in Zoraxy)
|
|
"""
|
|
import base64
|
|
import hmac
|
|
import os
|
|
import threading
|
|
import time
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
|
|
import requests
|
|
|
|
|
|
|
|
def load_env(path):
|
|
"""Liest KEY=VALUE-Zeilen aus .env; echte Umgebungsvariablen haben Vorrang."""
|
|
try:
|
|
with open(path, encoding="utf-8") as f:
|
|
for line in f:
|
|
line = line.strip()
|
|
if line and not line.startswith("#") and "=" in line:
|
|
k, v = line.split("=", 1)
|
|
os.environ.setdefault(k.strip(), v.strip().strip("\"'"))
|
|
except FileNotFoundError:
|
|
pass
|
|
|
|
|
|
load_env(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".env"))
|
|
CAMERAS = {k[7:].lower(): v for k, v in os.environ.items() if k.startswith("CAMERA_") and v}
|
|
if not CAMERAS:
|
|
raise SystemExit("Keine Kameras konfiguriert: CAMERA_<name>=<url> in .env eintragen")
|
|
PORT = int(os.environ.get("PORT", "8000"))
|
|
AUTH_USER = os.environ.get("AUTH_USER", "")
|
|
AUTH_PASS = os.environ.get("AUTH_PASS", "")
|
|
BOUNDARY = "frame"
|
|
|
|
HEAD = ("<!doctype html><html lang=de><head><meta charset=utf-8>"
|
|
"<meta name=viewport content='width=device-width,initial-scale=1'><title>Webcam</title>"
|
|
"<style>html,body{margin:0;background:#111;color:#eee;font-family:sans-serif}"
|
|
"img{display:block;width:100%}a{color:#8cf}"
|
|
".grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:8px;padding:8px}"
|
|
"h3{margin:4px 0}</style></head><body>")
|
|
|
|
|
|
def single_page(name):
|
|
return (HEAD + f"<img src=stream.mjpg alt='{name}'></body></html>").encode()
|
|
|
|
|
|
def overview_page():
|
|
cells = "".join(f"<div><h3><a href='{n}/'>{n}</a></h3><img src='{n}/stream.mjpg' alt='{n}'></div>"
|
|
for n in CAMERAS)
|
|
return (HEAD + f"<div class=grid>{cells}</div></body></html>").encode()
|
|
|
|
|
|
class Hub:
|
|
"""Hält das neueste Frame; Zuschauer warten auf das jeweils nächste."""
|
|
|
|
def __init__(self):
|
|
self.cond = threading.Condition()
|
|
self.frame = None
|
|
self.seq = 0
|
|
self.last = 0.0
|
|
|
|
def publish(self, jpg):
|
|
with self.cond:
|
|
self.frame, self.seq, self.last = jpg, self.seq + 1, time.time()
|
|
self.cond.notify_all()
|
|
|
|
def wait(self, seq, timeout=10):
|
|
with self.cond:
|
|
self.cond.wait_for(lambda: self.seq != seq, timeout)
|
|
return self.frame, self.seq
|
|
|
|
|
|
hubs = {name: Hub() for name in CAMERAS}
|
|
|
|
|
|
def pull_camera(name, url, hub):
|
|
"""Liest die Kamera dauerhaft; baut die Verbindung bei Fehlern neu auf."""
|
|
while True:
|
|
try:
|
|
with requests.get(url, stream=True, timeout=10) as r:
|
|
r.raise_for_status()
|
|
buf = b""
|
|
for chunk in r.iter_content(chunk_size=8192):
|
|
buf += chunk
|
|
while True:
|
|
s = buf.find(b"\xff\xd8")
|
|
if s < 0:
|
|
buf = b""
|
|
break
|
|
e = buf.find(b"\xff\xd9", s + 2)
|
|
if e < 0:
|
|
buf = buf[s:]
|
|
break
|
|
hub.publish(buf[s:e + 2])
|
|
buf = buf[e + 2:]
|
|
except requests.RequestException as ex:
|
|
print(f"{name}: Kamera nicht erreichbar: {ex} - neuer Versuch in 3s", flush=True)
|
|
time.sleep(3)
|
|
|
|
|
|
class Handler(BaseHTTPRequestHandler):
|
|
protocol_version = "HTTP/1.1"
|
|
|
|
def log_message(self, fmt, *args):
|
|
pass
|
|
|
|
def authorized(self):
|
|
if not AUTH_USER:
|
|
return True
|
|
h = self.headers.get("Authorization", "")
|
|
want = "Basic " + base64.b64encode(f"{AUTH_USER}:{AUTH_PASS}".encode()).decode()
|
|
return hmac.compare_digest(h, want)
|
|
|
|
def send_bytes(self, code, ctype, body, extra=None):
|
|
self.send_response(code)
|
|
self.send_header("Content-Type", ctype)
|
|
self.send_header("Content-Length", str(len(body)))
|
|
self.send_header("Cache-Control", "no-store")
|
|
for k, v in (extra or {}).items():
|
|
self.send_header(k, v)
|
|
self.end_headers()
|
|
self.wfile.write(body)
|
|
|
|
def do_GET(self):
|
|
parts = [p for p in self.path.split("?")[0].split("/") if p]
|
|
if parts == ["health"]:
|
|
now = time.time()
|
|
lines = [f"{n}: {'ok' if h.last and now - h.last < 10 else 'keine Frames'}"
|
|
for n, h in hubs.items()]
|
|
ok = all(l.endswith(": ok") for l in lines)
|
|
return self.send_bytes(200 if ok else 503, "text/plain", ("\n".join(lines) + "\n").encode())
|
|
if not self.authorized():
|
|
return self.send_bytes(401, "text/plain", b"Login erforderlich",
|
|
{"WWW-Authenticate": 'Basic realm="Webcam"'})
|
|
if not parts:
|
|
return self.send_bytes(200, "text/html; charset=utf-8", overview_page())
|
|
if parts == ["stream.mjpg"] or parts == ["snapshot.jpg"]:
|
|
parts = [next(iter(CAMERAS))] + parts # Alias: erste Kamera
|
|
name = parts[0]
|
|
if name not in hubs or len(parts) > 2:
|
|
return self.send_bytes(404, "text/plain", b"Nicht gefunden")
|
|
hub = hubs[name]
|
|
what = parts[1] if len(parts) == 2 else ""
|
|
if what == "":
|
|
if not self.path.split("?")[0].endswith("/"):
|
|
return self.send_bytes(301, "text/plain", b"", {"Location": f"/{name}/"})
|
|
return self.send_bytes(200, "text/html; charset=utf-8", single_page(name))
|
|
if what == "snapshot.jpg":
|
|
if hub.frame is None:
|
|
return self.send_bytes(503, "text/plain", b"Noch kein Bild")
|
|
return self.send_bytes(200, "image/jpeg", hub.frame)
|
|
if what == "stream.mjpg":
|
|
return self.stream(hub)
|
|
self.send_bytes(404, "text/plain", b"Nicht gefunden")
|
|
|
|
def stream(self, hub):
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", f"multipart/x-mixed-replace; boundary={BOUNDARY}")
|
|
self.send_header("Cache-Control", "no-store")
|
|
self.send_header("X-Accel-Buffering", "no") # Proxy soll nicht puffern
|
|
self.send_header("Connection", "close")
|
|
self.end_headers()
|
|
self.close_connection = True
|
|
seq = 0
|
|
try:
|
|
while True:
|
|
frame, seq_new = hub.wait(seq)
|
|
if frame is None or seq_new == seq:
|
|
continue
|
|
seq = seq_new
|
|
self.wfile.write(
|
|
f"--{BOUNDARY}\r\nContent-Type: image/jpeg\r\n"
|
|
f"Content-Length: {len(frame)}\r\n\r\n".encode() + frame + b"\r\n")
|
|
self.wfile.flush()
|
|
except (BrokenPipeError, ConnectionResetError, TimeoutError):
|
|
pass
|
|
|
|
|
|
class Server(ThreadingHTTPServer):
|
|
daemon_threads = True
|
|
allow_reuse_address = True
|
|
|
|
|
|
if __name__ == "__main__":
|
|
for n, u in CAMERAS.items():
|
|
threading.Thread(target=pull_camera, args=(n, u, hubs[n]), daemon=True).start()
|
|
print(f"Relay läuft auf Port {PORT}, Kameras: {', '.join(CAMERAS)}", flush=True)
|
|
Server(("0.0.0.0", PORT), Handler).serve_forever()
|