Files
BetterDSPControl/server.py
T
GivouandClaude Opus 5.5 66f988cf08 Add audio test tab with test generator, test fader and output mutes
- switch the DSP's test generator (pink/white noise, sine 20 Hz-20 kHz, command 0x39)
- entering lowers all outputs to -50 dB before the generator starts; one test fader
  raises them together; mute buttons for every output
- presets cannot be stored, recalled, imported or exported while the test runs
- leaving switches the generator off first, then restores every output gain
- a DSP found playing a test signal on connect goes straight into the audio test;
  saved gains survive an app restart (config.json)
- simulator and memory-image support for the test signal

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-01 21:33:01 +01:00

810 lines
37 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""DSP Control - web server for t.racks DSP 204 / DSP 408.
Usage: python server.py [--host 0.0.0.0] [--port 8080] [--config config.json]
Then open http://<this-computer>:8080 on your phone.
"""
import argparse
import asyncio
import base64
import errno
import hashlib
import json
import logging
import mimetypes
import re
import secrets
import socket
import sys
import time
import uuid
from pathlib import Path
from urllib.parse import parse_qs, urlsplit
import sim
from dsp import preset, usbhid
from dsp import protocol as P
from dsp.device import Device
ROOT = Path(__file__).resolve().parent
STATIC = (ROOT / "static").resolve() # resolved: in the macOS .app bundle it is a symlink
log = logging.getLogger("server")
DEFAULT_PIN = "1234"
SESSION_TTL = 30 * 24 * 3600 # stay logged in for 30 days
MAX_SESSIONS = 50
COOKIE = "dspsess"
CONFIG_FORMAT = "dsp-control-config"
MAX_UNDO = 20 # automatic backups kept per DSP before each import
TEST_LEVEL = -50.0 # dB all outputs start at when an audio test begins (noise generators are loud)
TEST_MAX = 0.0 # highest level the test fader can set
def _num(v, lo: float, hi: float, default: float = 0.0) -> float:
try:
v = float(v)
except (TypeError, ValueError):
return default
return min(hi, max(lo, v)) if v == v else default
def local_ips() -> list[str]:
"""IPv4 addresses other devices on the LAN can reach this computer at."""
ips = []
try:
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
s.connect(("192.0.2.1", 9)) # no packet is sent; just picks the outgoing interface
ips.append(s.getsockname()[0])
except OSError:
pass
try:
for info in socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET):
ip = info[4][0]
if ip not in ips and not ip.startswith(("127.", "169.254.")):
ips.append(ip)
except OSError:
pass
return ips
def clean_limiter(data: dict) -> dict:
"""Validate the limiter calculator data (amplifier profiles + output assignments)."""
amps = []
for a in (data.get("amps") or [])[:100]:
amps.append({
"id": re.sub(r"[^\w-]", "", str(a.get("id") or uuid.uuid4().hex[:8]))[:16] or uuid.uuid4().hex[:8],
"name": str(a.get("name") or "Amplifier")[:40],
"mode": "gain" if a.get("mode") == "gain" else "sens",
"sens": _num(a.get("sens"), 0.05, 20, 1.4),
"gain": _num(a.get("gain"), 0, 60, 32),
"p8": _num(a.get("p8"), 0, 100000), "p4": _num(a.get("p4"), 0, 100000), "p2": _num(a.get("p2"), 0, 100000),
})
ids = {a["id"] for a in amps}
assign = {}
for k, v in (data.get("assign") or {}).items():
if re.fullmatch(r"[\w-]+:\d{1,2}", str(k)) and isinstance(v, dict) and v.get("amp") in ids:
assign[k] = {"amp": v["amp"], "ohm": _num(v.get("ohm"), 1, 32, 8),
"spk": _num(v.get("spk"), 0, 100000)}
ref = {str(k)[:32]: _num(v, -20, 30) for k, v in (data.get("ref") or {}).items()}
return {"amps": amps, "assign": assign, "ref": ref}
def clean_gains(v) -> list[int] | None:
"""Saved output gains of an interrupted audio test (from config.json)."""
if not isinstance(v, list) or not v or len(v) > 8:
return None
return [int(_num(g, 0, 400, 280)) for g in v]
def hash_pin(pin: str, salt: str) -> str:
return hashlib.pbkdf2_hmac("sha256", pin.encode(), bytes.fromhex(salt), 100_000).hex()
def token_id(token: str) -> str:
"""Sessions are stored hashed so config.json never contains a usable cookie."""
return hashlib.sha256(token.encode()).hexdigest()
class App:
def __init__(self, config_path: Path):
self.config_path = config_path
self.devices: dict[str, Device] = {}
self.clients: set[asyncio.Queue] = set()
self.auth: dict = {}
self.sessions: dict[str, float] = {} # token hash -> expiry
self.failures: dict[str, tuple[int, float]] = {} # ip -> (failed attempts, locked until)
self.limiter: dict = clean_limiter({})
# desktop app: its own window logs in with a one-time token, other devices need the PIN
self.app_token: str | None = None
self.app_sessions: set[str] = set()
self.remote = {"enabled": False, "port": 8080}
self.remote_server: asyncio.Server | None = None
self.remote_writers: set[asyncio.StreamWriter] = set()
self.remote_error = ""
self.locked = False # desktop app window read-only until unlocked with the PIN
self.lang = "" # UI language chosen in the desktop app ("" = not chosen yet, English)
# demo mode: the real DSPs are disconnected and a simulated one runs inside the server
self.demo = {"enabled": False, "model": "408"}
self.demo_server: asyncio.Server | None = None
self.demo_resume: set[str] = set() # real devices to reconnect when the demo ends
# ------------------------------------------------------------ config
def load(self):
if self.config_path.exists():
cfg = json.loads(self.config_path.read_text(encoding="utf-8"))
else:
cfg = {"devices": [
{"id": "dsp204", "name": "DSP 204", "host": "192.168.1.101", "model": "204", "autoconnect": False},
{"id": "dsp408", "name": "DSP 408", "host": "192.168.1.102", "model": "408", "autoconnect": False},
]}
now = time.time()
self.sessions = {k: v for k, v in cfg.get("sessions", {}).items() if v > now}
self.locked = bool(cfg.get("locked"))
self.lang = cfg.get("lang") if cfg.get("lang") in ("en", "de") else ""
self.apply_config(cfg)
def apply_config(self, cfg: dict):
"""Devices, PIN, limiter data and remote settings from a config dict (file or backup)."""
auth = cfg.get("auth") or {}
if re.fullmatch(r"[0-9a-f]{32}", str(auth.get("salt", ""))) and re.fullmatch(r"[0-9a-f]{64}", str(auth.get("hash", ""))):
self.auth = {"salt": auth["salt"], "hash": auth["hash"]}
elif not self.auth: # first start (a backup without PIN keeps the current one)
self.set_pin(DEFAULT_PIN, save=False)
self.limiter = clean_limiter(cfg.get("limiter") or {})
r = cfg.get("remote") or {}
self.remote = {"enabled": bool(r.get("enabled")), "port": int(_num(r.get("port"), 1, 65535, 8080))}
for d in cfg.get("devices", [])[:20]:
if isinstance(d, dict):
self.add_device(d, save=False)
self.save()
# ------------------------------------------------------------ backups
def export_config(self) -> dict:
"""App backup: devices, PIN (hashed), amplifiers/limiter data, remote access - no logins."""
return {"format": CONFIG_FORMAT, "version": 1, "exported": time.strftime("%Y-%m-%dT%H:%M:%S"),
"devices": [d.config() for d in self.real_devices()], "auth": self.auth,
"limiter": self.limiter, "remote": self.remote}
async def restore_config(self, doc: dict, session: str):
if not isinstance(doc, dict) or doc.get("format") != CONFIG_FORMAT:
raise ValueError("Not a DSP Control settings backup")
for dev in self.real_devices():
await dev.stop()
del self.devices[dev.id]
self.broadcast({"type": "removed", "device": dev.id})
old_auth = self.auth
self.apply_config(doc)
if self.auth != old_auth: # new PIN: other devices have to log in again
self.sessions = {k: v for k, v in self.sessions.items() if k == session or k in self.app_sessions}
self.save()
for dev in self.devices.values():
self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()})
self.broadcast({"type": "limiter", "data": self.limiter})
if self.app_token: # desktop app: (re)start or stop the LAN listener as restored
await self.start_remote()
@property
def undo_dir(self) -> Path:
return self.config_path.parent / "backups"
def undo_files(self, dev_id: str) -> list[Path]:
return sorted(self.undo_dir.glob(f"{dev_id}-*.json"), reverse=True)
async def import_preset(self, dev: Device, body: dict) -> dict:
if dev.status != "online" or not dev.state:
raise RuntimeError("DSP is not connected")
raw = base64.b64decode(body["raw"]) if body.get("raw") else None
state = preset.read_file(dev.model_name, dev.model, dev.state, doc=body.get("doc"), raw=raw)
# safety copy of the current state first, so the import can be undone
current = await dev.export_preset()
self.undo_dir.mkdir(exist_ok=True)
stamp = time.strftime("%Y%m%d-%H%M%S")
(self.undo_dir / f"{dev.id}-{stamp}.json").write_text(json.dumps(current), encoding="utf-8")
for old in self.undo_files(dev.id)[MAX_UNDO:]:
old.unlink(missing_ok=True)
diffs = await dev.import_preset(state)
return {"ok": not diffs, "differences": diffs[:20], "name": state.get("preset_name", "")}
async def undo_import(self, dev: Device) -> dict:
files = self.undo_files(dev.id)
if not files:
raise RuntimeError("No backup available")
doc = json.loads(files[0].read_text(encoding="utf-8"))
state = preset.read_file(dev.model_name, dev.model, dev.state, doc=doc)
diffs = await dev.import_preset(state)
files[0].unlink()
return {"ok": not diffs, "differences": diffs[:20]}
def save(self):
sessions = {k: v for k, v in self.sessions.items() if k not in self.app_sessions}
cfg = {"devices": [d.config() for d in self.real_devices()], "auth": self.auth,
"sessions": sessions, "limiter": self.limiter, "remote": self.remote, "locked": self.locked}
if self.lang:
cfg["lang"] = self.lang
self.config_path.write_text(json.dumps(cfg, indent=2), encoding="utf-8")
def add_device(self, d: dict, save=True) -> Device:
dev_id = d.get("id") or uuid.uuid4().hex[:8]
usb = d.get("transport") == "usb"
dev = Device(dev_id, d.get("name") or d.get("host") or "DSP (USB)", str(d.get("host") or ""),
int(d.get("port", 9761)), str(d.get("model", "auto")), int(d.get("addr", 1)),
bool(d.get("autoconnect", True)), on_event=self.broadcast,
transport="usb" if usb else "tcp", usb=str(d.get("usb") or ""),
lock_code=str(d.get("lock_code") or ""), auto_unlock=bool(d.get("auto_unlock")),
test_saved=clean_gains(d.get("test_saved")))
dev.on_online = self.check_audio_test
self.devices[dev_id] = dev
if dev.autoconnect:
if self.demo["enabled"]:
self.demo_resume.add(dev_id)
else:
dev.start()
if save:
self.save()
return dev
# ------------------------------------------------------------ audio test
def set_test_level(self, dev: Device, db: float):
"""Every output to the same level (the test fader)."""
dev.test_level = _num(db, -60, TEST_MAX, TEST_LEVEL)
raw = P.db_to_gain(dev.test_level)
for i in range(len(dev.state["outputs"])):
dev.set_param("out", i, "gain", raw)
def restore_gains(self, dev: Device):
for i, g in enumerate((dev.test_saved or [])[: len(dev.state["outputs"])]):
dev.set_param("out", i, "gain", g)
dev.test_saved = None
async def audio_test(self, dev: Device, body: dict) -> dict:
source = int(_num(body.get("source"), 0, len(P.TEST_SOURCES) - 1, 0))
freq = int(_num(body.get("freq"), 0, 30, dev.state["test"]["freq"] if dev.state else 17))
if not dev.state or dev.status != "online":
raise RuntimeError("DSP is not connected")
if source:
if not dev.test_active: # entering: lower every output before the generator starts
if dev.test_saved is None:
dev.test_saved = [ch["gain"] for ch in dev.state["outputs"]]
self.save()
self.set_test_level(dev, TEST_LEVEL)
await dev.set_test_signal(source, freq)
else: # leaving: generator off first, then the faders go back
await dev.set_test_signal(0, freq)
if dev.test_saved is not None:
self.restore_gains(dev)
await dev.flush()
self.save()
self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()})
return {"ok": True}
async def check_audio_test(self, dev: Device):
"""On connect: a DSP still playing a test signal goes straight into the audio test (outputs lowered);
one back on its analog inputs gets the faders saved by an interrupted test back."""
try:
if dev.test_active:
if dev.test_saved is None:
dev.test_saved = [ch["gain"] for ch in dev.state["outputs"]]
self.set_test_level(dev, TEST_LEVEL)
elif dev.test_saved is not None:
self.restore_gains(dev)
else:
return
await dev.flush()
if not dev.demo:
self.save()
self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()})
except Exception as e: # noqa: BLE001 - connection lost meanwhile: checked again on the next connect
log.warning("%s: audio test check failed: %s", dev.name, e)
def real_devices(self) -> list[Device]:
return [d for d in self.devices.values() if not d.demo]
# ------------------------------------------------------------ demo mode
def demo_info(self) -> dict:
return {**self.demo, "error": ""}
async def set_demo(self, body: dict) -> dict:
enabled = bool(body.get("enabled", self.demo["enabled"]))
model = body.get("model") if body.get("model") in ("204", "408") else self.demo["model"]
if self.demo["enabled"] and (not enabled or model != self.demo["model"]):
await self.stop_demo()
self.demo["model"] = model
if enabled and not self.demo["enabled"]:
await self.start_demo()
self.broadcast({"type": "demo", "data": self.demo_info()})
return self.demo_info()
async def start_demo(self):
"""Disconnect the real DSPs and start a simulated one inside this server."""
self.demo_resume = {d.id for d in self.real_devices() if d._want_connected}
for d in self.real_devices():
await d.stop()
model = self.demo["model"]
logging.getLogger("sim").setLevel(logging.WARNING)
dsp = sim.SimDSP(model)
dsp.presets[1] = {**dsp.presets[0], "preset_name": "Demo"}
self.demo_server = await asyncio.start_server(dsp.serve, "127.0.0.1", 0)
port = self.demo_server.sockets[0].getsockname()[1]
dev = Device("demo", f"Demo DSP {model}", "127.0.0.1", port, model, autoconnect=False, on_event=self.broadcast)
dev.demo = True
dev.on_online = self.check_audio_test
self.devices[dev.id] = dev
self.demo["enabled"] = True
self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()})
dev.start()
async def stop_demo(self):
dev = self.devices.pop("demo", None)
if dev:
await dev.stop()
self.broadcast({"type": "removed", "device": dev.id})
if self.demo_server:
self.demo_server.close()
self.demo_server = None
self.demo["enabled"] = False
for dev_id in self.demo_resume:
if dev_id in self.devices:
self.devices[dev_id].start()
self.demo_resume = set()
# ------------------------------------------------------------ auth
def set_pin(self, pin: str, save=True):
salt = secrets.token_hex(16)
self.auth = {"salt": salt, "hash": hash_pin(pin, salt)}
if save:
self.save()
def check_pin(self, pin: str) -> bool:
return secrets.compare_digest(hash_pin(str(pin), self.auth["salt"]), self.auth["hash"])
def session_of(self, headers: dict) -> str | None:
"""Hashed session id of a valid login cookie, else None."""
for part in headers.get("cookie", "").split(";"):
k, _, v = part.strip().partition("=")
if k == COOKIE and v:
tid = token_id(v)
if self.sessions.get(tid, 0) > time.time():
return tid
return None
def new_session(self) -> str:
token = secrets.token_urlsafe(32)
self.sessions[token_id(token)] = time.time() + SESSION_TTL
if len(self.sessions) > MAX_SESSIONS:
for k in sorted(self.sessions, key=self.sessions.get)[: len(self.sessions) - MAX_SESSIONS]:
del self.sessions[k]
self.save()
return token
@staticmethod
def cookie(token: str, max_age: int) -> str:
return f"Set-Cookie: {COOKIE}={token}; Path=/; Max-Age={max_age}; HttpOnly; SameSite=Strict\r\n"
async def guarded_pin(self, who: str, pin) -> tuple[int, dict]:
"""Check a PIN with brute-force protection per client: 200 if right, else 401/429."""
count, until = self.failures.get(who, (0, 0.0))
if until > time.time():
return 429, {"error": "locked", "retry": round(until - time.time())}
if self.check_pin(str(pin or "")):
self.failures.pop(who, None)
return 200, {"ok": True}
await asyncio.sleep(0.4) # slow down guessing
count += 1
# 5 tries, then a 30 s lock that doubles with every further 5 failures (max 15 min)
lock = min(900, 30 * 2 ** (count // 5 - 1)) if count % 5 == 0 else 0
self.failures[who] = (count, time.time() + lock)
return 401, {"error": "wrong pin", "retry": lock, "left": 5 - count % 5}
async def login(self, ip: str, body: dict) -> tuple[int, dict, str]:
status, result = await self.guarded_pin(ip, body.get("pin"))
return status, result, self.cookie(self.new_session(), SESSION_TTL) if status == 200 else ""
async def change_pin(self, session: str, body: dict) -> tuple[int, dict]:
new = str(body.get("new", ""))
# the desktop app window belongs to the owner of this computer: no current PIN needed (forgotten PIN)
if session not in self.app_sessions and not self.check_pin(str(body.get("current", ""))):
return 400, {"error": "Current PIN is wrong"}
if not re.fullmatch(r"\d{4}", new):
return 400, {"error": "The PIN must be 4 digits"}
self.set_pin(new, save=False)
# log out all other devices (the app window stays)
self.sessions = {k: v for k, v in self.sessions.items() if k == session or k in self.app_sessions}
self.save()
return 200, {"ok": True}
# ------------------------------------------------------------ desktop app
def app_login(self, token: str) -> str | None:
"""Session cookie value for the app window, if the one-time token matches."""
if not self.app_token or not secrets.compare_digest(token, self.app_token):
return None
cookie = secrets.token_urlsafe(32)
self.sessions[token_id(cookie)] = time.time() + SESSION_TTL
self.app_sessions.add(token_id(cookie))
return cookie
def set_locked(self, locked: bool):
self.locked = locked
self.save()
self.broadcast({"type": "lock", "locked": locked})
@staticmethod
def allowed_while_locked(method: str, path: str) -> bool:
"""What the locked app window may still do: look at everything, export presets."""
if path in ("/api/unlock", "/api/events", "/api/lang"):
return True
if method == "GET":
return path != "/api/backup" # holds the PIN hash
return method == "POST" and re.fullmatch(r"/api/devices/[\w-]+/(export|backups)", path) is not None
def remote_info(self) -> dict:
return {**self.remote, "running": self.remote_server is not None, "error": self.remote_error,
"platform": sys.platform,
# only the main address: the others are usually virtual adapters (WSL, Hyper-V, VPN)
"urls": [f"http://{ip}:{self.remote['port']}" for ip in local_ips()[:1]]}
async def start_remote(self):
"""(Re)start the LAN listener for other devices according to self.remote."""
self.stop_remote()
self.remote_error = ""
if not self.remote["enabled"]:
return
try:
self.remote_server = await asyncio.start_server(
lambda r, w: self.handle(r, w, remote=True), "0.0.0.0", self.remote["port"])
log.info("Remote access on port %d", self.remote["port"])
except OSError as e:
in_use = e.errno in (errno.EADDRINUSE, 98, 10048) or getattr(e, "winerror", None) == 10048
self.remote_error = (f"Port {self.remote['port']} is already in use – please choose another port" if in_use
else f"Port {self.remote['port']} is not available ({e.strerror or e})")
log.warning("Remote access failed: %s", e)
def stop_remote(self):
if self.remote_server:
self.remote_server.close()
self.remote_server = None
for w in list(self.remote_writers): # also end open connections (live event streams)
w.close()
self.remote_writers.clear()
async def set_remote(self, body: dict) -> dict:
if "enabled" in body:
self.remote["enabled"] = bool(body["enabled"])
if "port" in body:
self.remote["port"] = int(_num(body["port"], 1, 65535, 8080))
self.save()
await self.start_remote()
return self.remote_info()
async def shutdown(self):
self.stop_remote()
if self.demo["enabled"]:
self.demo_resume = set()
await self.stop_demo()
for d in self.devices.values():
await d.stop()
# ------------------------------------------------------------ events
def broadcast(self, ev: dict):
msg = json.dumps(ev, separators=(",", ":"))
for q in list(self.clients):
if ev["type"] == "meters" and q.qsize() > 50:
continue # slow client: drop meter frames, never state changes
q.put_nowait(msg)
# ------------------------------------------------------------ API
async def api(self, method: str, path: str, body: dict):
if path == "/api/devices" and method == "GET":
return [d.snapshot() for d in self.devices.values()]
if path == "/api/devices" and method == "POST":
return self.add_device(body).snapshot()
if path == "/api/demo":
return await self.set_demo(body) if method == "PUT" else self.demo_info()
if path == "/api/usb" and method == "GET":
return await asyncio.to_thread(usbhid.list_devices)
if path == "/api/limiter" and method == "GET":
return self.limiter
if path == "/api/limiter" and method == "PUT":
self.limiter = clean_limiter(body)
self.save()
self.broadcast({"type": "limiter", "data": self.limiter})
return self.limiter
m = re.fullmatch(r"/api/devices/([\w-]+)(?:/(\w+))?(?:/(\w+))?", path)
if not m or m.group(1) not in self.devices:
raise KeyError(path)
dev = self.devices[m.group(1)]
action = "/".join(g for g in m.groups()[1:] if g)
if dev.demo and (method in ("DELETE", "PUT") or action in ("unlock", "lockcode")):
raise RuntimeError("Not available for the demo device")
if dev.test_active and action in ("preset/recall", "preset/store", "export", "import", "undo"):
raise RuntimeError("Audio test is on – switch it off first")
if self.demo["enabled"] and not dev.demo and action == "connect":
raise RuntimeError("Demo mode is on – switch it off to connect the real DSPs")
if method == "DELETE" and not action:
await dev.stop()
del self.devices[dev.id]
self.save()
self.broadcast({"type": "removed", "device": dev.id})
return {"ok": True}
if method == "PUT" and not action:
was_running = dev._want_connected
await dev.stop()
for k in ("name", "host", "model", "usb"):
if k in body:
setattr(dev, "model_key" if k == "model" else k, str(body[k]))
if "transport" in body:
dev.transport = "usb" if body["transport"] == "usb" else "tcp"
for k in ("port", "addr"):
if k in body:
setattr(dev, k, int(body[k]))
if "autoconnect" in body:
dev.autoconnect = bool(body["autoconnect"])
if "auto_unlock" in body:
dev.auto_unlock = bool(body["auto_unlock"])
if body.get("lock_code") == "":
dev.lock_code, dev.auto_unlock = "", False # forget the remembered code
self.save()
if was_running:
dev.start()
self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()})
return dev.snapshot()
if method != "POST":
raise KeyError(path)
if action == "connect":
dev.start()
return {"ok": True}
if action == "disconnect":
await dev.stop()
return {"ok": True}
if action == "set":
dev.set_param(body["kind"], int(body["idx"]), body["param"], body["value"])
return {"ok": True}
if action == "preset/recall":
await dev.recall_preset(int(body["index"]))
return {"ok": True}
if action == "preset/store":
await dev.store_preset(int(body["index"]), str(body["name"]))
return {"ok": True}
if action == "export":
return await dev.export_preset()
if action == "import":
return await self.import_preset(dev, body)
if action == "undo":
return await self.undo_import(dev)
if action == "backups":
return [{"file": f.name, "time": f.stat().st_mtime} for f in self.undo_files(dev.id)]
if action == "link":
kind = "in" if body.get("kind") == "in" else "out"
groups = [[int(i) for i in g] for g in body.get("groups") or [] if isinstance(g, list)]
await dev.set_links(kind, groups)
return {"ok": True}
if action == "refresh":
await dev.refresh()
return {"ok": True}
if action == "test":
return await self.audio_test(dev, body)
if action == "testlevel":
if not dev.test_active:
raise RuntimeError("Audio test is off")
self.set_test_level(dev, body.get("db"))
return {"ok": True, "db": dev.test_level}
if action == "unlock": # hardware lock of the DSP, independent of the app lock
code = str(body.get("code") or "").strip().upper()
ok = await dev.unlock(code)
if ok and body.get("remember"):
dev.lock_code, dev.auto_unlock = code, True
self.save()
self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()})
return {"ok": ok}
if action == "lockcode":
await dev.set_lock_code(body.get("code"))
self.save()
self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()})
return {"ok": True}
raise KeyError(path)
# ------------------------------------------------------------ HTTP
async def handle(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter, remote=False):
if remote:
self.remote_writers.add(writer)
try:
await self._handle(reader, writer, remote)
finally:
self.remote_writers.discard(writer)
async def _handle(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter, remote: bool):
try:
head = await reader.readuntil(b"\r\n\r\n")
except (asyncio.IncompleteReadError, asyncio.LimitOverrunError, ConnectionError):
writer.close()
return
lines = head.decode("latin1").split("\r\n")
try:
method, target, _ = lines[0].split(" ", 2)
except ValueError:
writer.close()
return
headers = {k.lower(): v.strip() for k, _, v in (l.partition(":") for l in lines[1:] if l)}
url = urlsplit(target)
path = url.path
body = b""
if int(headers.get("content-length", 0)):
body = await reader.readexactly(int(headers["content-length"]))
try:
if path == "/app-login" and not remote:
cookie = self.app_login(parse_qs(url.query).get("t", [""])[0])
if cookie:
await self.respond(writer, 302, b"", "text/plain",
"Location: /\r\n" + self.cookie(cookie, SESSION_TTL))
else:
await self.respond(writer, 401, b"invalid app token", "text/plain")
return
if path.startswith("/api/"):
try:
data = json.loads(body) if body else {}
except ValueError:
data = {}
session = self.session_of(headers)
if session in self.app_sessions and remote:
session = None # the window's session never counts on the LAN listener
is_app = session in self.app_sessions
if path == "/api/auth":
await self.respond_json(writer, 200, {"authenticated": bool(session), "app": is_app,
"locked": is_app and self.locked,
"lang": self.lang if is_app else ""})
return
if path == "/api/login" and method == "POST":
ip = (writer.get_extra_info("peername") or ("?",))[0]
status, result, cookie = await self.login(ip, data)
await self.respond_json(writer, status, result, cookie)
return
if path == "/api/logout" and method == "POST":
if self.sessions.pop(session, None):
self.save()
await self.respond_json(writer, 200, {"ok": True}, self.cookie("", 0))
return
if not session:
await self.respond_json(writer, 401, {"error": "login required"})
return
if is_app and self.locked and not self.allowed_while_locked(method, path):
await self.respond_json(writer, 423, {"error": "Locked – unlock with the PIN to make changes"})
return
if path == "/api/lang" and method == "PUT":
if is_app and data.get("lang") in ("en", "de"):
self.lang = data["lang"]
self.save()
await self.respond_json(writer, 200, {"lang": self.lang})
return
if path in ("/api/lock", "/api/unlock") and method == "POST":
if not is_app:
await self.respond_json(writer, 403, {"error": "desktop app only"})
elif path == "/api/lock":
self.set_locked(True)
await self.respond_json(writer, 200, {"locked": True})
else:
status, result = await self.guarded_pin("app-unlock", data.get("pin"))
if status == 200:
self.set_locked(False)
# not 401: the page would take that for "logged out"
await self.respond_json(writer, 400 if status == 401 else status, result)
return
if path == "/api/pin" and method == "POST":
await self.respond_json(writer, *await self.change_pin(session, data))
return
if path == "/api/backup":
if method == "GET":
await self.respond_json(writer, 200, self.export_config())
elif not is_app and not self.check_pin(str(data.get("pin", ""))):
# on the LAN only with the PIN: a backup can replace it
await self.respond_json(writer, 400, {"error": "Wrong PIN"})
else:
try:
await self.restore_config(data.get("doc"), session)
await self.respond_json(writer, 200, {"ok": True})
except ValueError as e:
await self.respond_json(writer, 400, {"error": str(e)})
return
if path == "/api/remote":
if not is_app:
await self.respond_json(writer, 403, {"error": "desktop app only"})
elif method == "PUT":
await self.respond_json(writer, 200, await self.set_remote(data))
else:
await self.respond_json(writer, 200, self.remote_info())
return
if path == "/api/events":
await self.sse(writer)
return
if path.startswith("/api/"):
try:
result = await self.api(method, path, json.loads(body) if body else {})
await self.respond(writer, 200, json.dumps(result).encode(), "application/json")
except KeyError as e:
await self.respond(writer, 404, json.dumps({"error": f"not found: {e}"}).encode(),
"application/json")
except Exception as e: # noqa: BLE001 - report any API error to the client
log.exception("API error")
await self.respond(writer, 400, json.dumps({"error": str(e)}).encode(), "application/json")
return
await self.static(writer, path)
except (ConnectionError, asyncio.CancelledError):
pass
finally:
try:
writer.close()
except Exception: # noqa: BLE001
pass
async def respond(self, writer, status: int, data: bytes, ctype: str, extra: str = ""):
reason = {200: "OK", 302: "Found", 400: "Bad Request", 401: "Unauthorized", 403: "Forbidden",
404: "Not Found", 423: "Locked", 429: "Too Many Requests"}.get(status, "OK")
writer.write(f"HTTP/1.1 {status} {reason}\r\nContent-Type: {ctype}\r\nContent-Length: {len(data)}\r\n"
f"Cache-Control: no-cache\r\n{extra}Connection: close\r\n\r\n".encode() + data)
await writer.drain()
async def respond_json(self, writer, status: int, obj, extra: str = ""):
await self.respond(writer, status, json.dumps(obj).encode(), "application/json", extra)
async def static(self, writer, path: str):
rel = "index.html" if path in ("/", "") else path.lstrip("/")
f = (STATIC / rel).resolve()
if STATIC not in f.parents or not f.is_file():
await self.respond(writer, 404, b"not found", "text/plain")
return
ctype = mimetypes.guess_type(f.name)[0] or "application/octet-stream"
if ctype.startswith("text/") or ctype.endswith("javascript"):
ctype += "; charset=utf-8"
await self.respond(writer, 200, f.read_bytes(), ctype)
async def sse(self, writer):
writer.write(b"HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nCache-Control: no-cache\r\n"
b"Connection: keep-alive\r\nX-Accel-Buffering: no\r\n\r\n")
q: asyncio.Queue = asyncio.Queue()
self.clients.add(q)
try:
hello = {"type": "hello", "devices": [d.snapshot() for d in self.devices.values()], "limiter": self.limiter,
"demo": self.demo_info()}
writer.write(f"data: {json.dumps(hello)}\n\n".encode())
await writer.drain()
while True:
try:
msg = await asyncio.wait_for(q.get(), timeout=15)
writer.write(f"data: {msg}\n\n".encode())
except asyncio.TimeoutError:
writer.write(b": ping\n\n")
await writer.drain()
finally:
self.clients.discard(q)
async def main():
ap = argparse.ArgumentParser(description="Web control for t.racks DSP 204/408")
ap.add_argument("--host", default="0.0.0.0")
ap.add_argument("--port", type=int, default=8080)
ap.add_argument("--config", default=str(ROOT / "config.json"))
ap.add_argument("-v", "--verbose", action="store_true")
args = ap.parse_args()
logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO,
format="%(asctime)s %(name)s %(levelname)s %(message)s")
app = App(Path(args.config))
app.load()
server = await asyncio.start_server(app.handle, args.host, args.port)
log.info("DSP Control running on http://%s:%d", "localhost" if args.host == "0.0.0.0" else args.host, args.port)
async with server:
await server.serve_forever()
if __name__ == "__main__":
try:
asyncio.run(main())
except KeyboardInterrupt:
pass