- overlay chips read the stored selection on every click (second click hides again) - phase view: points keep their gain position and can be dragged in both directions, phase wraps are drawn as vertical lines like the original software, selected band shows Q / frequency / gain next to its point - audio test: other tabs, settings and device switching are locked until the analog input is back; the server only accepts the test controls meanwhile - test fader value has a fixed width and normal weight (meters no longer shift) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
812 lines
38 KiB
Python
812 lines
38 KiB
Python
"""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")
|
||
# during the audio test only the test controls work: generator, test fader, output mutes
|
||
if dev.test_active and (action in ("preset/recall", "preset/store", "export", "import", "undo", "link")
|
||
or action == "set" and body.get("param") != "mute"):
|
||
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
|