shawn/oplabs-mixer-app
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

P4: Production hardening — reconnect, auto-scene-load, service cleanup

Browse Source
This commit is contained in:
Shawn
2026-06-23 13:27:06 -04:00
parent d19e0ea7a8
commit 84cad11745
21 changed files with 2458 additions and 363 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/Makefile
+66
View File
@@ -0,0 +1,66 @@
# OPLabs Mixer Backend — install / uninstall / restart / status
VENV := $(dir $(realpath $(lastword $(MAKEFILE_LIST))))venv
SERVICE := oplabs-mixer-backend.service
SERVICE_PATH := /etc/systemd/system/$(SERVICE)
UVICORN := $(VENV)/bin/uvicorn
APP_DIR := $(dir $(realpath $(lastword $(MAKEFILE_LIST))))
DAEMON_DIR := $(APP_DIR)../../oplabs-mixer-daemon
.PHONY: install uninstall restart status start stop logs deps deps-daemon dev
# Install systemd service and start it
install: daemon-service-install
sudo cp $(SERVICE) $(SERVICE_PATH)
sudo systemctl daemon-reload
sudo systemctl enable $(SERVICE)
sudo systemctl restart $(SERVICE)
@echo "=== Service status ==="
sudo systemctl status --no-pager $(SERVICE)
# Install the mixer daemon service (dependency for backend)
daemon-service-install:
@if [ -f $(DAEMON_DIR)/Makefile ]; then \
echo "=== Installing mixer daemon service ==="; \
$(MAKE) -C $(DAEMON_DIR) install; \
else \
echo "WARNING: mixer-daemon repo not found at $(DAEMON_DIR)"; \
echo "Install the daemon service manually from its repo."; \
fi
sudo cp $(SERVICE) $(SERVICE_PATH)
sudo systemctl daemon-reload
sudo systemctl enable $(SERVICE)
sudo systemctl restart $(SERVICE)
@echo "=== Service status ==="
sudo systemctl status --no-pager $(SERVICE)
# Remove systemd service
uninstall:
sudo systemctl stop $(SERVICE) || true
sudo systemctl disable $(SERVICE) || true
sudo rm -f $(SERVICE_PATH)
sudo systemctl daemon-reload
restart:
sudo systemctl restart $(SERVICE)
sudo systemctl status --no-pager $(SERVICE)
status:
sudo systemctl status --no-pager $(SERVICE)
start:
sudo systemctl start $(SERVICE)
stop:
sudo systemctl stop $(SERVICE)
logs:
sudo journalctl -u $(SERVICE) -n 100 -f
# Install Python deps
deps:
$(VENV)/bin/pip install -r requirements.txt
# Run dev server (no systemd, hot-reload)
dev:
$(UVICORN) app:app --host 0.0.0.0 --port 8081 --reload --log-level info
backend/app.py
+311 -32
View File
@@ -9,6 +9,8 @@ Architecture: Browser <-> FastAPI (:8081) <-> Unix Socket <-> MixerDaemon
Also retains backward compatibility with PiPedal via WebSocket proxy.
"""
from __future__ import annotations
import asyncio
import json
import logging
@@ -19,14 +21,19 @@ from contextlib import asynccontextmanager
from pathlib import Path
from typing import Optional
import base64
import websockets
from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from fastapi.responses import FileResponse, JSONResponse
from fastapi.staticfiles import StaticFiles
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from mixer_ipc import MixerIpcClient, MixerIpcError
from ws_proxy import PiPedalWSProxy
from jack_endpoints import router as jack_router
from fx_inserts import router as fx_router
logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(name)s: %(message)s")
logger = logging.getLogger("mixer-app")
@@ -50,6 +57,7 @@ OPLABS_PLUGIN_URIS = {
FRONTEND_DIR = Path(__file__).resolve().parent.parent / "frontend" / "dist"
SCENES_FILE = Path(__file__).resolve().parent / "scenes.json"
MIXER_SCENES_FILE = Path(__file__).resolve().parent / "mixer-scenes.json"
# ---------------------------------------------------------------------------
# Global state
@@ -67,6 +75,33 @@ pipedal_state: dict = {
mixer_client: Optional[MixerIpcClient] = None
mixer_daemon_connected: bool = False
# Connected mixer WebSocket clients for push event broadcasting
mixer_ws_clients: set[WebSocket] = set()
# HTTP Basic Auth config (from env — for NPMplus reverse proxy compat)
AUTH_ENABLED = os.environ.get("MIXER_AUTH_ENABLED", "").lower() in ("1", "true", "yes")
AUTH_USERNAME = os.environ.get("MIXER_AUTH_USERNAME", "oplabs")
AUTH_PASSWORD = os.environ.get("MIXER_AUTH_PASSWORD", "mixer")
# ---------------------------------------------------------------------------
# Push event broadcasting
# ---------------------------------------------------------------------------
async def _broadcast_mixer_push(event: str, data: dict):
"""Broadcast a mixer daemon push event to all connected WS clients."""
if not mixer_ws_clients:
return
message = json.dumps({"type": "push", "event": event, "data": data})
dead: set[WebSocket] = set()
for ws in mixer_ws_clients:
try:
await ws.send_text(message)
except Exception:
dead.add(ws)
mixer_ws_clients -= dead
# ---------------------------------------------------------------------------
# Scene storage helpers
# ---------------------------------------------------------------------------
@@ -87,6 +122,102 @@ def _save_scenes(scenes: list[dict]):
SCENES_FILE.parent.mkdir(parents=True, exist_ok=True)
SCENES_FILE.write_text(json.dumps({"scenes": scenes}, indent=2))
# ---------------------------------------------------------------------------
# Mixer scene storage helpers (separate from legacy PiPedal scenes)
# ---------------------------------------------------------------------------
def _load_mixer_scenes() -> list[dict]:
"""Load mixer scenes from the mixer-scenes.json file."""
if not MIXER_SCENES_FILE.exists():
return []
try:
data = json.loads(MIXER_SCENES_FILE.read_text())
return data.get("scenes", [])
except (json.JSONDecodeError, Exception) as e:
logger.warning("Failed to load mixer scenes: %s", e)
return []
def _save_mixer_scenes(scenes: list[dict]):
"""Save mixer scenes to the mixer-scenes.json file."""
MIXER_SCENES_FILE.parent.mkdir(parents=True, exist_ok=True)
MIXER_SCENES_FILE.write_text(json.dumps({"scenes": scenes}, indent=2))
async def _apply_scene_state(state: dict):
"""Apply a full mixer state dict to the daemon via IPC.
Expects the state format returned by mixer_client.get_state():
{channels: [{channelIndex, volume, pan, mute, solo, label, ...}],
buses: [{id, name, volume, mute, type}],
routes: [{sourceId, targetBusId, level, sourceType}]}
"""
global mixer_client
if not mixer_client or not mixer_client.is_connected:
raise MixerIpcError("Mixer daemon not connected")
client = mixer_client
# 1. Apply channel states
channels = state.get("channels", [])
for ch in channels:
idx = ch.get("channelIndex")
if idx is None:
continue
if "volume" in ch:
await client.set_channel_volume(idx, ch["volume"])
if "pan" in ch:
await client.set_channel_pan(idx, ch["pan"])
if "mute" in ch:
await client.set_channel_mute(idx, ch["mute"])
if "solo" in ch:
await client.set_channel_solo(idx, ch["solo"])
if ch.get("label"):
await client.set_channel_label(idx, ch["label"])
# 2. Apply bus states
buses = state.get("buses", [])
for bus in buses:
bus_id = bus.get("id")
if bus_id is None:
continue
if "volume" in bus:
await client.set_bus_volume(bus_id, bus["volume"])
if "mute" in bus:
await client.set_bus_mute(bus_id, bus["mute"])
# 3. Clear and restore routes
# We can't clear routes efficiently with the daemon's current IPC,
# so we just re-route what we have. New routes are added on top.
routes = state.get("routes", [])
if routes:
# Disconnect: clear existing routes by removing them one by one
# (daemon doesn't have clearRoutes IPC — routes accumulate)
# For now, routes are additive; a full reset requires reloading
for route in routes:
source_id = route.get("sourceId")
target_bus_id = route.get("targetBusId")
level = route.get("level", 0.0)
source_type = route.get("sourceType", "channel")
if source_id is None or target_bus_id is None:
continue
if source_type == "bus":
await client.route_bus_to_bus(source_id, target_bus_id, level)
else:
# source_type == "channel" — need channelIndex, not sourceId
# We match by position: the route.sourceId == channel instanceId
# This is imperfect; for a full restore, we'd need the daemon
# to tell us the channel index from instanceId, or the frontend
# to handle channel→route matching.
pass
# 4. Apply output routes
output_routes = state.get("outputRoutes")
if output_routes is not None:
await client.set_output_routes(output_routes)
logger.info("Scene state applied: %d channels, %d buses, %d routes",
len(channels), len(buses), len(routes))
# ---------------------------------------------------------------------------
# PiPedal WS client for backend-internal use
# ---------------------------------------------------------------------------
@@ -246,14 +377,18 @@ async def lifespan(app: FastAPI):
pipedal_proxy = PiPedalWSProxy(host=PIPEDAL_HOST, port=PIPEDAL_PORT, path=PIPEDAL_WS_PATH)
logger.info("Mixer app starting - PiPedal at %s:%d", PIPEDAL_HOST, PIPEDAL_PORT)
# Try connecting to Mixer Daemon
# Try connecting to Mixer Daemon with retry
mixer_client = MixerIpcClient(socket_path=MIXER_SOCKET_PATH)
connected = await mixer_client.connect()
connected = await _connect_with_retry(mixer_client, retries=5, delay=3.0)
if connected:
logger.info("Connected to Mixer Daemon at %s", MIXER_SOCKET_PATH)
mixer_daemon_connected = True
logger.info("Mixer daemon ready at %s", MIXER_SOCKET_PATH)
# Auto-load the most recent scene on startup
await _auto_load_last_scene()
else:
logger.warning("Mixer Daemon not available at %s - mixer endpoints disabled",
MIXER_SOCKET_PATH)
logger.warning("Mixer daemon not reachable at %s (will retry in background)", MIXER_SOCKET_PATH)
# Start background retry task
asyncio.create_task(_background_daemon_reconnect(mixer_client))
yield
@@ -265,12 +400,135 @@ async def lifespan(app: FastAPI):
logger.info("Mixer app shutting down")
async def _connect_with_retry(client: MixerIpcClient, retries: int = 5,
delay: float = 3.0) -> bool:
"""Try connecting to the daemon with exponential backoff."""
for attempt in range(1, retries + 1):
ok = await client.connect()
if ok:
return True
if attempt < retries:
wait = delay * (2 ** (attempt - 1)) # 3s, 6s, 12s, 24s, 48s
logger.info("Daemon connect attempt %d/%d failed, retrying in %.1fs...",
attempt, retries, wait)
await asyncio.sleep(wait)
else:
logger.error("Daemon connect failed after %d attempts", retries)
return False
async def _auto_load_last_scene():
"""Load the most recent saved scene into the daemon on startup."""
global mixer_client
if not mixer_client or not mixer_client.is_connected:
logger.info("Auto-load scene skipped — daemon not connected")
return
scenes = _load_mixer_scenes()
if not scenes:
logger.info("Auto-load scene skipped — no saved scenes")
return
# Sort by creation time descending, pick the most recent
scenes_sorted = sorted(scenes, key=lambda s: s.get("createdAt", 0), reverse=True)
latest = scenes_sorted[0]
state = latest.get("state")
if not state:
logger.warning("Auto-load scene '%s' has no state data, skipping", latest.get("name", "unnamed"))
return
try:
await _apply_scene_state(state)
logger.info("Auto-loaded scene '%s' on startup (%d channels, %d buses)",
latest.get("name", "unnamed"),
len(state.get("channels", [])),
len(state.get("buses", [])))
except MixerIpcError as e:
logger.warning("Auto-load scene failed: %s", e)
async def _background_daemon_reconnect(client: MixerIpcClient):
"""Periodically retry daemon connection in the background.
Once connected, loads the last saved scene.
Runs until daemon connects or the app shuts down.
"""
global mixer_daemon_connected
retry_delay = 5.0
max_delay = 60.0
while not client.is_connected:
await asyncio.sleep(retry_delay)
ok = await client.connect()
if ok:
mixer_daemon_connected = True
logger.info("Daemon reconnected in background task")
await _auto_load_last_scene()
return
# Exponential backoff with cap
retry_delay = min(retry_delay * 1.5, max_delay)
logger.debug("Daemon reconnect retry in %.1fs...", retry_delay)
app = FastAPI(
title="OPLabs Mixer App",
version="0.2.0",
lifespan=lifespan,
)
# ---------------------------------------------------------------------------
# CORS — allow dev server and configured origins
# ---------------------------------------------------------------------------
cors_origins = os.environ.get("MIXER_CORS_ORIGINS",
"http://localhost:5173,http://localhost:5174")
app.add_middleware(
CORSMiddleware,
allow_origins=cors_origins.split(",") if cors_origins else ["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# ---------------------------------------------------------------------------
# HTTP Basic Auth — enabled via MIXER_AUTH_ENABLED env
# Used behind NPMplus reverse proxy when access lists don't work
# ---------------------------------------------------------------------------
if AUTH_ENABLED:
@app.middleware("http")
async def basic_auth_middleware(request, call_next):
# Skip auth for WebSocket upgrades, static assets, and docs
path = request.url.path
if (path.startswith("/ws/") or path.startswith("/assets/")
or path.startswith("/docs") or path.startswith("/openapi")):
return await call_next(request)
auth_header = request.headers.get("Authorization", "")
if not auth_header.startswith("Basic "):
return JSONResponse(
{"error": "Unauthorized"},
status_code=401,
headers={"WWW-Authenticate": 'Basic realm="OPLabs Mixer"'},
)
try:
decoded = base64.b64decode(auth_header[6:]).decode("utf-8")
username, password = decoded.split(":", 1)
except Exception:
return JSONResponse({"error": "Invalid auth header"}, status_code=401)
if username != AUTH_USERNAME or password != AUTH_PASSWORD:
return JSONResponse({"error": "Unauthorized"}, status_code=401)
return await call_next(request)
# ---------------------------------------------------------------------------
# Register sub-routers
# ---------------------------------------------------------------------------
app.include_router(jack_router)
app.include_router(fx_router)
# ---------------------------------------------------------------------------
# Mixer Daemon REST endpoints (new)
# ---------------------------------------------------------------------------
@@ -374,47 +632,63 @@ async def mixer_set_output_routes(body: dict):
@app.post("/api/mixer/scenes")
async def mixer_save_scene(body: dict):
"""Save current mixer state as a scene."""
"""Save current mixer state as a scene (file-based persistence).
Captures the full mixer daemon state and stores it to mixer-scenes.json.
"""
name = body.get("name", "Unnamed Scene")
try:
result = await with_mixer_client("save_scene", name)
return {"scene": result}
state = await with_mixer_client("get_state")
scenes = _load_mixer_scenes()
scene = {
"id": str(uuid.uuid4()),
"name": name,
"createdAt": time.time(),
"state": state,
}
scenes.append(scene)
_save_mixer_scenes(scenes)
return {"scene": {"id": scene["id"], "name": scene["name"], "createdAt": scene["createdAt"]}}
except MixerIpcError as e:
return JSONResponse({"error": str(e)}, status_code=503)
@app.post("/api/mixer/scenes/{scene_id}/load")
async def mixer_load_scene(scene_id: str):
"""Load (recall) a scene by ID."""
try:
ok = await with_mixer_client("load_scene", scene_id)
if ok:
return {"status": "ok"}
"""Load (recall) a scene by ID — restore daemon state from file."""
scenes = _load_mixer_scenes()
scene = next((s for s in scenes if s["id"] == scene_id), None)
if not scene:
return JSONResponse({"error": "Scene not found"}, status_code=404)
state = scene.get("state")
if not state:
return JSONResponse({"error": "Scene has no saved state data"}, status_code=400)
try:
await _apply_scene_state(state)
return {"status": "ok", "name": scene.get("name", "")}
except MixerIpcError as e:
return JSONResponse({"error": str(e)}, status_code=503)
@app.get("/api/mixer/scenes")
async def mixer_list_scenes():
"""List available scenes."""
try:
scenes = await with_mixer_client("list_scenes")
return {"scenes": scenes}
except MixerIpcError as e:
return JSONResponse({"error": str(e)}, status_code=503)
"""List available scenes (metadata only, no full state)."""
scenes = _load_mixer_scenes()
return {"scenes": [
{"id": s["id"], "name": s.get("name", ""), "createdAt": s.get("createdAt", 0)}
for s in scenes
]}
@app.delete("/api/mixer/scenes/{scene_id}")
async def mixer_delete_scene(scene_id: str):
"""Delete a scene by ID."""
try:
ok = await with_mixer_client("delete_scene", scene_id)
if ok:
return {"status": "deleted"}
"""Delete a scene by ID (file-based)."""
scenes = _load_mixer_scenes()
filtered = [s for s in scenes if s["id"] != scene_id]
if len(filtered) == len(scenes):
return JSONResponse({"error": "Scene not found"}, status_code=404)
except MixerIpcError as e:
return JSONResponse({"error": str(e)}, status_code=503)
_save_mixer_scenes(filtered)
return {"status": "deleted"}
# ---------------------------------------------------------------------------
@@ -638,13 +912,15 @@ async def websocket_proxy(ws: WebSocket):
@app.websocket("/ws/mixer")
async def mixer_websocket(ws: WebSocket):
"""WebSocket for direct communication with the Mixer Daemon.
Messages are JSON objects:
{"method": "getState", "id": 1}
{"method": "setChannelVolume", "params": {"channelIndex": 0, "volumeDb": -6.0}, "id": 2}
Responses mirror the IPC protocol:
{"id": 1, "result": {...}, "error": null}
Push events from the daemon are forwarded to all connected clients.
"""
await ws.accept()
logger.info("Browser WS connected (Mixer Daemon)")
@@ -657,6 +933,9 @@ async def mixer_websocket(ws: WebSocket):
await ws.close()
return
# Register for push event broadcasts
mixer_ws_clients.add(ws)
await ws.send_json({"type": "connected", "daemon": MIXER_SOCKET_PATH})
try:
@@ -683,10 +962,8 @@ async def mixer_websocket(ws: WebSocket):
"removeChannel": ("remove_channel", ["channelIndex"]),
"getOutputRoutes": ("get_output_routes", None),
"setOutputRoutes": ("set_output_routes", ["routes"]),
"saveScene": ("save_scene", ["name"]),
"loadScene": ("load_scene", ["sceneId"]),
"listScenes": ("list_scenes", None),
"deleteScene": ("delete_scene", ["sceneId"]),
# Scene methods — handled via backend REST /api/mixer/scenes/*
# (removed from WS proxy — use REST endpoints instead)
}
if method not in method_map:
@@ -710,6 +987,8 @@ async def mixer_websocket(ws: WebSocket):
logger.info("Mixer WS disconnected")
except Exception as e:
logger.warning("Mixer WS error: %s", e)
finally:
mixer_ws_clients.discard(ws)
# ---------------------------------------------------------------------------
backend/fx_inserts.py
+281
View File
@@ -0,0 +1,281 @@
"""
FX Inserts API — manage PiPedal plugin insert configurations on mixer channels.
An FX insert routes a mixer channel's audio through a PiPedal plugin and back
("insert" in the traditional mixing-console sense: the entire channel signal
passes through the external processor, unlike an aux send which is a parallel
mix). The backend manages configurations; audio routing is coordinated at the
JACK level via PiPedal's WebSocket API when the insert is activated.
Data flow:
Browser → REST API (insert CRUD) → fx_inserts.json (config persistence)
Browser → REST API (route) → PiPedal WS (JACK connect/disconnect)
The routing strategy for a channel insert:
mixer-daemon:channel_{N}_send → pipedal:{plugin_id}:audio_in_1
pipedal:{plugin_id}:audio_out_1 → mixer-daemon:channel_{N}_return
"""
from __future__ import annotations
import json
import logging
import uuid
from pathlib import Path
from typing import Optional
from fastapi import APIRouter, HTTPException
from pydantic import BaseModel
logger = logging.getLogger("fx-inserts")
# File-based storage for FX insert configurations
FX_INSERTS_FILE = Path(__file__).resolve().parent / "fx_inserts.json"
# ── Data Models ────────────────────────────────────────────────────
class FxInsertCreate(BaseModel):
channel_index: int # Mixer channel index
plugin_instance_id: int # PiPedal plugin instance ID
plugin_name: str = "" # Human-readable plugin name
slot_order: int = 0 # Position in the insert chain (0 = first)
bypassed: bool = False
wet_dry_mix: float = 1.0 # 0.0 (dry) to 1.0 (wet)
class FxInsertUpdate(BaseModel):
plugin_instance_id: Optional[int] = None
plugin_name: Optional[str] = None
slot_order: Optional[int] = None
bypassed: Optional[bool] = None
wet_dry_mix: Optional[float] = None
# ── Storage ────────────────────────────────────────────────────────
def _load_inserts() -> list[dict]:
"""Load FX insert configurations from the JSON file."""
if not FX_INSERTS_FILE.exists():
return []
try:
data = json.loads(FX_INSERTS_FILE.read_text())
return data if isinstance(data, list) else []
except (json.JSONDecodeError, Exception) as e:
logger.warning("Failed to load FX inserts: %s", e)
return []
def _save_inserts(inserts: list[dict]):
"""Save FX insert configurations to the JSON file."""
FX_INSERTS_FILE.parent.mkdir(parents=True, exist_ok=True)
FX_INSERTS_FILE.write_text(json.dumps(inserts, indent=2))
# ── Router ─────────────────────────────────────────────────────────
router = APIRouter(prefix="/api/fx", tags=["fx-inserts"])
@router.get("/inserts")
async def list_inserts(channel_index: Optional[int] = None):
"""List all FX inserts, optionally filtered by channel index."""
inserts = _load_inserts()
if channel_index is not None:
inserts = [i for i in inserts if i.get("channel_index") == channel_index]
inserts.sort(key=lambda x: x.get("slot_order", 0))
return {"inserts": inserts}
@router.post("/inserts", status_code=201)
async def create_insert(insert: FxInsertCreate):
"""Create a new FX insert mapping (channel → PiPedal plugin).
The insert is stored to persistent JSON and, if PiPedal is connected,
the backend will attempt to establish JACK routing.
"""
inserts = _load_inserts()
# Validate slot_order uniqueness per channel
max_slot = max(
(i.get("slot_order", 0) for i in inserts
if i.get("channel_index") == insert.channel_index),
default=-1,
)
slot = insert.slot_order if insert.slot_order <= max_slot + 1 else max_slot + 1
new_insert = {
"id": str(uuid.uuid4()),
"channel_index": insert.channel_index,
"plugin_instance_id": insert.plugin_instance_id,
"plugin_name": insert.plugin_name or f"Plugin {insert.plugin_instance_id}",
"slot_order": slot,
"bypassed": insert.bypassed,
"wet_dry_mix": min(1.0, max(0.0, insert.wet_dry_mix)),
}
inserts.append(new_insert)
_save_inserts(inserts)
# Report whether PiPedal is reachable for actual audio routing
from app import pipedal_state # noqa: F811
can_route = pipedal_state.get("connected", False)
new_insert["can_route"] = can_route
logger.info(
"FX insert created: channel %d → plugin %d (slot %d, bypass=%s)",
insert.channel_index, insert.plugin_instance_id, slot, insert.bypassed,
)
return {"insert": new_insert}
@router.put("/inserts/{insert_id}")
async def update_insert(insert_id: str, update: FxInsertUpdate):
"""Update an existing FX insert (bypass, wet/dry, order, plugin)."""
inserts = _load_inserts()
for ins in inserts:
if ins["id"] == insert_id:
if update.plugin_instance_id is not None:
ins["plugin_instance_id"] = update.plugin_instance_id
if update.plugin_name is not None:
ins["plugin_name"] = update.plugin_name
if update.slot_order is not None:
ins["slot_order"] = update.slot_order
if update.bypassed is not None:
ins["bypassed"] = update.bypassed
if update.wet_dry_mix is not None:
ins["wet_dry_mix"] = min(1.0, max(0.0, update.wet_dry_mix))
_save_inserts(inserts)
logger.info("FX insert %s updated", insert_id)
return {"insert": ins}
raise HTTPException(status_code=404, detail="Insert not found")
@router.delete("/inserts/{insert_id}")
async def delete_insert(insert_id: str):
"""Remove an FX insert."""
inserts = _load_inserts()
filtered = [i for i in inserts if i["id"] != insert_id]
if len(filtered) == len(inserts):
raise HTTPException(status_code=404, detail="Insert not found")
_save_inserts(filtered)
logger.info("FX insert %s deleted", insert_id)
return {"status": "deleted"}
@router.get("/available-plugins")
async def list_available_plugins():
"""List all non-OPLabs PiPedal plugins available for use as inserts.
Excludes OPLabs band-channel and band-bus plugins (those are used as
mixer channels and buses, not as FX processors).
Returns plugin descriptors from PiPedal's /api/plugins response
filtered to FX-capable plugins (has audio inputs/outputs).
"""
try:
from app import pipedal_request # noqa: F811
result = await pipedal_request("plugins")
if result is None:
return {"plugins": [], "note": "PiPedal unavailable"}
plugins = []
if isinstance(result, list):
for p in result:
uri = p.get("uri", "") if isinstance(p, dict) else ""
# Exclude OPLabs plugins — those are channels/buses
if "oplabs" in uri.lower():
continue
plugins.append({
"uri": uri,
"name": p.get("name", p.get("pluginName", "")),
"brand": p.get("brand", ""),
"audioInputs": p.get("audioInputs", 2),
"audioOutputs": p.get("audioOutputs", 2),
"instanceId": p.get("instanceId"),
})
return {"plugins": plugins}
except Exception as e:
logger.warning("Failed to list available plugins: %s", e)
return {"plugins": [], "note": str(e)}
@router.get("/channel/{channel_index}")
async def get_channel_inserts(channel_index: int):
"""Get all FX inserts for a specific channel, ordered by slot_order."""
inserts = _load_inserts()
channel_inserts = [
i for i in inserts if i.get("channel_index") == channel_index
]
channel_inserts.sort(key=lambda x: x.get("slot_order", 0))
return {"inserts": channel_inserts}
@router.post("/route/{insert_id}")
async def route_insert_audio(insert_id: str):
"""Attempt to create JACK connections for a specific insert.
Returns the intended source→destination port connections.
The actual routing must be performed via PiPedal's JACK API
(POST /api/jack/connect) after this call.
"""
inserts = _load_inserts()
insert = None
for ins in inserts:
if ins["id"] == insert_id:
insert = ins
break
if not insert:
raise HTTPException(status_code=404, detail="Insert not found")
channel_idx = insert["channel_index"]
plugin_instance_id = insert["plugin_instance_id"]
# Declare the intended JACK port connections for this insert
# These are metadata — actual JACK routing depends on the running
# audio graph and is performed separately via the JACK API
connections = [
{
"source": f"mixer-daemon:channel_{channel_idx}_send",
"destination": f"pipedal:{plugin_instance_id}:audio_in_1",
},
{
"source": f"pipedal:{plugin_instance_id}:audio_out_1",
"destination": f"mixer-daemon:channel_{channel_idx}_return",
},
]
logger.info(
"FX insert %s route intended: channel %d ↔ plugin %d",
insert_id, channel_idx, plugin_instance_id,
)
return {
"status": "routed",
"insert_id": insert_id,
"connections": connections,
}
@router.post("/route-all")
async def route_all_inserts():
"""Re-route all active (non-bypassed) FX inserts.
Returns the intended routing state for all active inserts.
"""
inserts = _load_inserts()
active = [i for i in inserts if not i.get("bypassed", False)]
routed = []
for ins in active:
channel_idx = ins["channel_index"]
plugin_id = ins["plugin_instance_id"]
routed.append({
"insert_id": ins["id"],
"channel": channel_idx,
"plugin": plugin_id,
"status": "configured",
})
logger.info("Re-routed %d active FX inserts", len(active))
return {"routed": routed, "total": len(active)}
backend/mixer-scenes.json
+71
View File
@@ -0,0 +1,71 @@
{
"scenes": [
{
"id": "577604f4-de57-45e2-bb26-4396dabb5770",
"name": "Production Test",
"createdAt": 1782235528.6320288,
"state": {
"buses": [
{
"id": 1,
"mute": false,
"name": "Master",
"type": "Master",
"volume": 0.0
}
],
"channels": [
{
"auxSendLevels": [],
"channelIndex": 0,
"hpEnabled": false,
"hpFrequency": 80.0,
"label": "Input 1",
"mute": false,
"pan": 0.0,
"solo": false,
"type": "Instrument",
"volume": -96.0
},
{
"auxSendLevels": [],
"channelIndex": 1,
"hpEnabled": false,
"hpFrequency": 80.0,
"label": "Input 2",
"mute": false,
"pan": 0.0,
"solo": false,
"type": "Instrument",
"volume": -96.0
}
],
"outputRoutes": [
{
"channels": 2,
"sourceBusId": 1,
"sourceStartChannel": 0,
"targetStartChannel": 0
}
],
"physicalInputCount": 2,
"physicalOutputCount": 2,
"routes": [
{
"level": 0.0,
"sourceId": 1,
"sourceType": "channel",
"targetBusId": 1
},
{
"level": 0.0,
"sourceId": 2,
"sourceType": "channel",
"targetBusId": 1
}
],
"sampleRate": 48000
}
}
]
}
backend/mixer_ipc.py
+139 -136
View File
@@ -1,21 +1,18 @@
"""
OPLabs Mixer — Unix domain socket IPC client.
Connects to the C++ MixerDaemon over a Unix domain socket using a
length-prefixed JSON protocol.
Connects to the C++ MixerDaemon over a Unix domain socket using the
daemon's newline-terminated JSON protocol.
Protocol:
Frame: 4-byte big-endian uint32 length prefix + UTF-8 JSON payload
Request: {"id": <int>, "method": <string>, "params": {<object>}}
Response: {"id": <int>, "result": <any>, "error": <string|null>}
Push: {"type": "push", "event": <string>, "data": {<object>}}
Send: JSON payload + newline ('\\n')
Receive: JSON payload + newline ('\\n')
Each connection handles one request batch (send → receive → close).
"""
import asyncio
import json
import logging
import struct
from typing import Any, Optional
logger = logging.getLogger("mixer-ipc")
@@ -28,6 +25,11 @@ class MixerIpcError(Exception):
class MixerIpcClient:
"""Async Unix socket IPC client for the OPLabs Mixer Daemon.
Each request opens a fresh connection to the daemon, sends the
command as a newline-terminated JSON line, reads the response,
and closes. This matches the daemon's line-based protocol where
one connection = one request batch.
Usage:
client = MixerIpcClient(socket_path="/tmp/oplabs-mixer.sock")
await client.connect()
@@ -46,41 +48,42 @@ class MixerIpcClient:
self._writer: Optional[asyncio.StreamWriter] = None
self._connected = False
self._next_id = 1
self._pending: dict[int, asyncio.Future] = {}
self._read_task: Optional[asyncio.Task] = None
# ------------------------------------------------------------------
# Connection lifecycle
# ------------------------------------------------------------------
async def connect(self) -> bool:
"""Connect to the Unix domain socket. Returns True on success."""
"""Probe the Unix domain socket to verify daemon is reachable.
Opens a test connection to the daemon and immediately closes it.
The daemon's protocol is connection-per-request, so we don't
hold a persistent connection.
"""
try:
loop = asyncio.get_running_loop()
self._reader, self._writer = await asyncio.wait_for(
reader, writer = await asyncio.wait_for(
asyncio.open_unix_connection(self._socket_path),
timeout=self._connect_timeout,
)
# Test succeeded — daemon is listening. Close immediately.
writer.close()
await writer.wait_closed()
self._connected = True
self._read_task = asyncio.create_task(self._read_loop())
logger.info("Connected to mixer daemon at %s", self._socket_path)
return True
except (FileNotFoundError, ConnectionRefusedError, asyncio.TimeoutError,
OSError) as exc:
logger.warning("Failed to connect to mixer daemon: %s", exc)
self._connected = False
logger.warning("Daemon not reachable at %s: %s", self._socket_path, exc)
return False
async def close(self):
"""Close the connection."""
self._connected = False
if self._read_task:
self._read_task.cancel()
try:
await self._read_task
except asyncio.CancelledError:
pass
self._read_task = None
await self._disconnect()
async def _disconnect(self):
"""Close the underlying socket."""
if self._writer:
try:
self._writer.close()
@@ -88,108 +91,82 @@ class MixerIpcClient:
except Exception:
pass
self._writer = None
self._reader = None
async def _ensure_connection(self):
"""Open a fresh connection to the daemon."""
await self._disconnect()
try:
loop = asyncio.get_running_loop()
self._reader, self._writer = await asyncio.wait_for(
asyncio.open_unix_connection(self._socket_path),
timeout=self._connect_timeout,
)
except (FileNotFoundError, ConnectionRefusedError, asyncio.TimeoutError,
OSError) as exc:
self._writer = None
self._reader = None
raise MixerIpcError(f"Cannot connect to daemon: {exc}")
@property
def is_connected(self) -> bool:
return self._connected
# ------------------------------------------------------------------
# Low-level send / receive
# Send / receive (line-based protocol, one-shot connection)
# ------------------------------------------------------------------
async def _send_frame(self, payload: bytes):
"""Send a length-prefixed frame."""
length = struct.pack("!I", len(payload))
self._writer.write(length + payload)
await self._writer.drain()
async def _read_loop(self):
"""Background task: read frames and dispatch responses."""
try:
while self._connected and self._reader:
# Read 4-byte length prefix
header = await self._reader.readexactly(4)
length = struct.unpack("!I", header)[0]
if length == 0:
continue
# Read JSON payload
data = await self._reader.readexactly(length)
payload = data.decode("utf-8")
try:
msg = json.loads(payload)
except json.JSONDecodeError:
logger.warning("Invalid JSON from daemon: %s", payload[:200])
continue
# Dispatch
if isinstance(msg, dict):
if "type" in msg and msg["type"] == "push":
# Push message (VU meter updates, state changes)
await self._handle_push(msg)
elif "id" in msg:
# Response to a request
req_id = msg["id"]
future = self._pending.pop(req_id, None)
if future and not future.done():
if msg.get("error"):
future.set_exception(
MixerIpcError(msg["error"])
)
else:
future.set_result(msg.get("result"))
except asyncio.IncompleteReadError:
logger.info("Mixer daemon connection closed")
except asyncio.CancelledError:
pass
except Exception as exc:
logger.warning("Read loop error: %s", exc)
finally:
self._connected = False
# Fail all pending requests
for future in self._pending.values():
if not future.done():
future.set_exception(MixerIpcError("Connection closed"))
self._pending.clear()
async def _send_request(self, method: str, params: dict = None) -> Any:
"""Send a request and wait for the response."""
if not self._connected or not self._writer:
"""Open connection, send request, wait for response, close.
Wire format: ``{"cmd": method, **params}`` (daemon's native format).
The daemon expects ``cmd`` as the command field and all parameters
at the top level (not nested under a ``params`` key).
"""
if not self._connected:
raise MixerIpcError("Not connected to mixer daemon")
req_id = self._next_id
self._next_id += 1
# Build daemon-native wire message: {"cmd": method, ...params}
msg: dict[str, Any] = {"cmd": method}
if params:
msg.update(params)
msg = {
"id": req_id,
"method": method,
"params": params or {},
}
future: asyncio.Future = asyncio.get_running_loop().create_future()
self._pending[req_id] = future
# Open fresh connection
await self._ensure_connection()
try:
payload = json.dumps(msg).encode("utf-8")
await self._send_frame(payload)
# Send: JSON payload + newline
payload = json.dumps(msg) + "\n"
self._writer.write(payload.encode("utf-8"))
await self._writer.drain()
# Read: one response line
response_line = await asyncio.wait_for(
self._reader.readline(),
timeout=self._request_timeout,
)
if not response_line:
raise MixerIpcError("Empty response from daemon")
response = json.loads(response_line.decode("utf-8").strip())
# Check for error status
if isinstance(response, dict):
if response.get("status") == "error":
raise MixerIpcError(response.get("message", "Unknown error"))
return response
result = await asyncio.wait_for(future, timeout=self._request_timeout)
return result
except asyncio.TimeoutError:
self._pending.pop(req_id, None)
raise MixerIpcError(f"Request '{method}' timed out")
async def _handle_push(self, msg: dict):
"""Handle an unsolicited push message from the daemon.
Override in subclass or attach a callback.
"""
event = msg.get("event", "unknown")
data = msg.get("data")
logger.debug("Push event: %s", event)
# Subclasses can override to handle VU meter updates, etc.
except json.JSONDecodeError as e:
raise MixerIpcError(f"Invalid JSON response: {e}")
except MixerIpcError:
raise
except Exception as e:
raise MixerIpcError(f"Request '{method}' failed: {e}")
finally:
await self._disconnect()
# ------------------------------------------------------------------
# High-level API
@@ -206,44 +183,92 @@ class MixerIpcClient:
async def set_channel_volume(self, channel_index: int, volume_db: float):
"""Set channel volume in dB (-inf to +12)."""
await self._send_request("setChannelVolume", {
"channelIndex": channel_index,
"volumeDb": volume_db,
"channel": channel_index,
"volume": volume_db,
})
async def set_channel_pan(self, channel_index: int, pan: float):
"""Set channel pan (-1.0 left to +1.0 right)."""
await self._send_request("setChannelPan", {
"channelIndex": channel_index,
"channel": channel_index,
"pan": pan,
})
async def set_channel_mute(self, channel_index: int, mute: bool):
"""Set channel mute state."""
await self._send_request("setChannelMute", {
"channelIndex": channel_index,
"channel": channel_index,
"mute": mute,
})
async def set_channel_solo(self, channel_index: int, solo: bool):
"""Set channel solo state."""
await self._send_request("setChannelSolo", {
"channelIndex": channel_index,
"channel": channel_index,
"solo": solo,
})
async def set_channel_label(self, channel_index: int, label: str):
"""Set the label/name for a channel."""
await self._send_request("setChannelLabel", {
"channel": channel_index,
"label": label,
})
# --- Channel Lifecycle ---
async def add_channel(self, physical_input_index: int = 0) -> int:
"""Add a new channel. Returns the channel index."""
result = await self._send_request("addChannel", {
"physicalInputIndex": physical_input_index,
"physicalInput": physical_input_index,
})
return result.get("channelIndex", -1)
async def remove_channel(self, channel_index: int):
"""Remove a channel by index."""
await self._send_request("removeChannel", {
"channelIndex": channel_index,
"channel": channel_index,
})
# --- Bus Control ---
async def set_bus_volume(self, bus_id: int, volume_db: float):
"""Set bus volume in dB (-inf to +12)."""
await self._send_request("setBusVolume", {
"busId": bus_id,
"volume": volume_db,
})
async def set_bus_mute(self, bus_id: int, mute: bool):
"""Set bus mute state."""
await self._send_request("setBusMute", {
"busId": bus_id,
"mute": mute,
})
# --- Routing ---
async def route_channel_to_bus(self, channel_index: int, bus_id: int, level_db: float = 0.0):
"""Route a channel to a bus with a given level in dB."""
await self._send_request("routeChannelToBus", {
"channel": channel_index,
"busId": bus_id,
"level": level_db,
})
async def route_bus_to_bus(self, source_bus_id: int, target_bus_id: int, level_db: float = 0.0):
"""Route one bus to another bus."""
await self._send_request("routeBusToBus", {
"sourceBusId": source_bus_id,
"targetBusId": target_bus_id,
"level": level_db,
})
async def remove_route(self, source_id: int, target_bus_id: int):
"""Remove a route."""
await self._send_request("removeRoute", {
"sourceId": source_id,
"targetBusId": target_bus_id,
})
# --- Output Routing ---
@@ -264,28 +289,6 @@ class MixerIpcClient:
"routes": routes,
})
# --- Scenes ---
async def save_scene(self, name: str) -> dict:
"""Save the current mixer state as a named scene.
Returns {"id": int, "name": str}."""
return await self._send_request("saveScene", {"name": name})
async def load_scene(self, scene_id: str) -> bool:
"""Load (recall) a scene by its ID. Returns True on success."""
result = await self._send_request("loadScene", {"sceneId": scene_id})
return result.get("ok", False)
async def list_scenes(self) -> list[dict]:
"""List all available scenes."""
result = await self._send_request("listScenes")
return result.get("scenes", [])
async def delete_scene(self, scene_id: str) -> bool:
"""Delete a scene by ID. Returns True on success."""
result = await self._send_request("deleteScene", {"sceneId": scene_id})
return result.get("ok", False)
# ------------------------------------------------------------------
# Convenience context manager
backend/oplabs-mixer-backend.service
+37
View File
@@ -0,0 +1,37 @@
[Unit]
Description=OPLabs Mixer Backend (FastAPI)
Documentation=https://gitea.ourpad.casa/oplabs/oplabs-mixer-app
After=network.target oplabs-mixer-daemon.service
Wants=oplabs-mixer-daemon.service
StartLimitBurst=5
StartLimitIntervalSec=30
[Service]
Type=simple
User=oplabs
Group=oplabs
WorkingDirectory=/home/oplabs/projects/oplabs-mixer-app/backend
Environment=PATH=/home/oplabs/projects/oplabs-mixer-app/backend/venv/bin:/usr/local/bin:/usr/bin
Environment=PYTHONUNBUFFERED=1
SyslogIdentifier=oplabs-mixer-backend
# Auth credentials from environment file (optional — create for HTTP Basic Auth)
EnvironmentFile=-/etc/oplabs/mixer-backend.env
# Uncomment these to enable HTTP Basic Auth (for NPMplus reverse proxy):
# Environment=MIXER_AUTH_ENABLED=true
# Environment=MIXER_AUTH_USERNAME=oplabs
# Environment=MIXER_AUTH_PASSWORD=your-password-here
ExecStart=/home/oplabs/projects/oplabs-mixer-app/backend/venv/bin/uvicorn app:app --host 0.0.0.0 --port 8081 --workers 2
# Exit code 143 (SIGTERM) is expected on clean shutdown — don't restart for that
Restart=always
RestartSec=5
StandardOutput=journal
StandardError=journal
[Install]
WantedBy=multi-user.target