docker-dosbox-novnc/scripts/setup_server.py

#!/usr/bin/env python3
"""HTML setup routine for DOSBox/ScummVM games.

Nothing about which games exist is hardcoded here: available games are
discovered by listing *.json manifests on the SMB share, one per game,
each describing how to install/uninstall/start/stop that game. Drop a new
<name>.json (and matching zip) on the share and it shows up here with no
image changes needed.

Manifest schema (all fields required):
{
  "name": "stuntcar",                 # must match the manifest's own filename
  "title": "Stuntcar Racer",
  "zip_path": "Games/dosbox/stuntcar.zip",   # path to the zip, relative to the share root -
                                              # games can live anywhere on the share, not just
                                              # next to their manifest
  "release_date": "1989",
  "publisher": "MicroStyle",
  "start_cmd": ["dosbox", "run.bat", "-conf", "dosbox-0.74-3.conf"]
}
Uninstall is implicit (remove GAMES_HOME/<name>); stop is implicit (terminate
the process tracked from the last start_cmd). Manifests themselves always live
in SMB_DIR (the catalog directory), even though the zip_path they point at may
not. Install size isn't a manifest field - it's looked up live from the share
(via `smbclient ls`) so it can't go stale.

Each running game gets its own ephemeral X session (Xvnc + fluxbox +
websockify on their own display/ports) instead of sharing one screen, so up
to MAX_CONCURRENT_GAMES can run side by side without fighting over focus or
being invisible to each other. Starting past that cap is refused.

Audio is deliberately *not* per-game: server.sh starts one PulseAudio daemon
and one pcm_ws_bridge.py (from docker-common) for the whole container's
lifetime, capturing PulseAudio's single default sink. Every running game's
audio mixes together there (normal PulseAudio behavior, no per-game routing
needed) - simpler than per-slot audio isolation, at the cost of not being
able to tell games' audio apart when more than one is running.

Video and audio are deliberately on separate pages/tabs, not one wrapper
page with an <iframe>: an iframe onto the noVNC HTTPS port hits browsers
(Firefox in particular) refusing to load embedded content signed by a
certificate whose warning hasn't been accepted at the top level, with no
way to click through *inside* the iframe. So "Open Screen" is a plain
top-level link straight to noVNC's own URL (opens in a new tab, normal
"Accept the Risk and Continue" applies), and audio lives on this page
instead, meant to be left open in its own tab for as long as you're
playing. Because of that, this page's auto-refresh is deliberately
limited to only while an install is actively in progress - refreshing
while a game is running would tear down the live AudioContext/WebSocket
every few seconds.

Audio is on by default, no button: the AudioContext/WebSocket connect
eagerly on page load, and just get resumed on this page's first click or
keypress (whatever the user was already doing, e.g. clicking Start),
since browsers require a user gesture before an AudioContext will
actually produce sound. Per-game volume is a real, independent control
even though every game's audio mixes into one shared PulseAudio sink -
each running game is still its own distinct sink-input there, and
PulseAudio already supports adjusting one sink-input's volume without
affecting the others (`pactl set-sink-input-volume`), found by matching
`application.process.id` against the game's own PID.
"""

import html
import json
import os
import re
import subprocess
import threading
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import parse_qs, urlparse

SMB_SERVER = "vlda-01"
SMB_SHARE = "software"
SMB_DIR = r"Games\dosbox"
GAMES_HOME = os.environ["GAMES_HOME"]
SETUP_PORT = int(os.environ.get("SETUP_PORT", "8080"))
AUDIO_PORT = int(os.environ.get("AUDIO_PORT", "8081"))
SCREEN_W = os.environ.get("SCREEN_W", "1024")
SCREEN_H = os.environ.get("SCREEN_H", "768")
NOVNC_CERT = "/tmp/novnc.pem"
NOVNC_KEY = "/tmp/novnc.key"
SCRIPTS_HOME = os.environ.get("SCRIPTS_HOME", "/opt/scripts")

MAX_CONCURRENT_GAMES = 10
GAME_DISPLAY_NUMS = list(range(90, 90 + MAX_CONCURRENT_GAMES))  # :90..:99, one per game slot

state_lock = threading.RLock()
install_state = {}   # name -> "downloading" | "extracting" | "done" | "error: ..."
game_errors = {}      # name -> error message from the last failed start attempt
running_procs = {}   # name -> {game, xvnc, fluxbox, websockify: Popen, display_num, novnc_port}


def smb_run(*commands):
    result = subprocess.run(
        ["smbclient", "-N", f"//{SMB_SERVER}/{SMB_SHARE}", "-c", ";".join(commands)],
        capture_output=True, text=True, timeout=15,
    )
    return result.stdout


def discover_games():
    """Returns {name: manifest} for every *.json manifest found on the share."""
    listing = smb_run(f"ls {SMB_DIR}\\*.json")
    names = [m.group(1) for m in re.finditer(r"\s*(\S+)\.json\s+A\s+\d+", listing)]
    if not names:
        return {}

    tmpdir = "/tmp/manifests"
    os.makedirs(tmpdir, exist_ok=True)
    gets = [f"get {SMB_DIR}\\{name}.json {tmpdir}/{name}.json" for name in names]
    smb_run(*gets)

    games = {}
    for name in names:
        try:
            with open(f"{tmpdir}/{name}.json") as f:
                manifest = json.load(f)
            if manifest.get("name") == name:
                games[name] = manifest
        except (OSError, json.JSONDecodeError):
            continue
    return games


def get_zip_sizes(games):
    """Returns {name: size_bytes or None}, looked up live via smbclient so it can't go stale."""
    if not games:
        return {}
    names = list(games)
    commands = [f'ls "{games[name]["zip_path"].replace("/", chr(92))}"' for name in names]
    output = smb_run(*commands)
    # Each `ls` result ends with a "N blocks of size 1024. M blocks available" trailer,
    # so splitting on that reliably separates one command's output from the next.
    chunks = re.split(r"\n\s*\d+ blocks of size \d+\.\s*\d+ blocks available\s*\n?", output)
    sizes = {}
    for name, chunk in zip(names, chunks):
        m = re.search(r"\s+A\s+(\d+)\s", chunk)
        sizes[name] = int(m.group(1)) if m else None
    return sizes


def is_installed(name):
    path = os.path.join(GAMES_HOME, name)
    return os.path.isdir(path) and os.listdir(path)


def _free_display_num():
    used = {info["display_num"] for info in running_procs.values()}
    for d in GAME_DISPLAY_NUMS:
        if d not in used:
            return d
    return None


def _clean_display(display_num):
    subprocess.run(
        ["rm", "-f", f"/tmp/.X{display_num}-lock", f"/tmp/.X11-unix/X{display_num}"],
        check=False,
    )


def _teardown(info):
    for key in ("game", "websockify", "fluxbox", "xvnc"):
        proc = info[key]
        if proc.poll() is None:
            proc.terminate()
    for key in ("game", "websockify", "fluxbox", "xvnc"):
        proc = info[key]
        try:
            proc.wait(timeout=5)
        except subprocess.TimeoutExpired:
            proc.kill()
            proc.wait()
    _clean_display(info["display_num"])


def is_running(name):
    with state_lock:
        info = running_procs.get(name)
        if info is None:
            return False
        if info["game"].poll() is None:
            return True
        # The game exited on its own (quit/crash) - tear down its X session too
        # instead of leaving an idle Xvnc/websockify pair holding the slot.
        _teardown(info)
        del running_procs[name]
        return False


def install_game(name, manifest):
    with state_lock:
        if install_state.get(name) in ("downloading", "extracting"):
            return
        install_state[name] = "downloading"

    tmpdir = f"/tmp/setup-{name}"
    try:
        os.makedirs(tmpdir, exist_ok=True)
        zip_name = manifest["zip_path"].rsplit("/", 1)[-1]
        zip_path = os.path.join(tmpdir, zip_name)
        # smbget's -a (guest) can't be combined with -o (output file), so let it save
        # under its default name in tmpdir instead.
        subprocess.run(
            ["smbget", "-au", f"smb://{SMB_SERVER}/{SMB_SHARE}/{manifest['zip_path']}"],
            check=True, timeout=1800, cwd=tmpdir,
        )
        with state_lock:
            install_state[name] = "extracting"
        os.makedirs(GAMES_HOME, exist_ok=True)
        subprocess.run(["unzip", "-o", "-d", GAMES_HOME, zip_path], check=True, timeout=600)
        with state_lock:
            install_state[name] = "done"
    except Exception as exc:
        with state_lock:
            install_state[name] = f"error: {exc}"
    finally:
        subprocess.run(["rm", "-rf", tmpdir], check=False)


def uninstall_game(name):
    with state_lock:
        if is_running(name):
            return
        subprocess.run(["rm", "-rf", os.path.join(GAMES_HOME, name)], check=False)
        install_state.pop(name, None)


def start_game(name, manifest):
    with state_lock:
        if is_running(name):
            return
        display_num = _free_display_num()
        if display_num is None:
            game_errors[name] = f"no free game slot ({MAX_CONCURRENT_GAMES}/{MAX_CONCURRENT_GAMES} running)"
            return
        game_errors.pop(name, None)

        _clean_display(display_num)
        display = f":{display_num}"
        rfb_port = f"59{display_num}"
        novnc_port = int(f"80{display_num}")
        game_env = dict(os.environ, DISPLAY=display)

        xvnc = subprocess.Popen(
            ["Xvnc", display, "-geometry", f"{SCREEN_W}x{SCREEN_H}", "-depth", "24",
             "+xinerama", "-securitytypes", "none"],
            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
        )
        fluxbox = subprocess.Popen(
            ["fluxbox"], env=game_env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
        )
        websockify = subprocess.Popen(
            ["websockify", "--web=/usr/share/novnc/", f"--cert={NOVNC_CERT}", f"--key={NOVNC_KEY}",
             str(novnc_port), f"localhost:{rfb_port}"],
            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
        )
        time.sleep(1)  # give Xvnc a moment to bind before the game connects
        game_proc = subprocess.Popen(manifest["start_cmd"], cwd=os.path.join(GAMES_HOME, name), env=game_env)

        running_procs[name] = {
            "game": game_proc, "xvnc": xvnc, "fluxbox": fluxbox, "websockify": websockify,
            "display_num": display_num, "novnc_port": novnc_port,
        }


def stop_game(name):
    with state_lock:
        info = running_procs.get(name)
        if info is None:
            return
    _teardown(info)
    with state_lock:
        running_procs.pop(name, None)


def _sink_input_index(pid):
    """Finds the PulseAudio sink-input belonging to a given PID.

    All games mix into PulseAudio's one default sink (see module docstring),
    but each game is still its own distinct sink-input there, and PulseAudio
    already supports adjusting one sink-input's volume independently of the
    others - this is what backs the per-game volume slider, without needing
    any per-game audio isolation.
    """
    result = subprocess.run(
        ["pactl", "-f", "json", "list", "sink-inputs"],
        capture_output=True, text=True, timeout=5,
    )
    try:
        sink_inputs = json.loads(result.stdout)
    except json.JSONDecodeError:
        return None
    for sink_input in sink_inputs:
        if sink_input.get("properties", {}).get("application.process.id") == str(pid):
            return sink_input.get("index")
    return None


def set_volume(name, level):
    with state_lock:
        info = running_procs.get(name)
    if info is None:
        return
    index = _sink_input_index(info["game"].pid)
    if index is None:
        return
    subprocess.run(["pactl", "set-sink-input-volume", str(index), f"{level}%"], check=False)


def render_page(host):
    games = discover_games()
    sizes = get_zip_sizes(games)
    with state_lock:
        pending = dict(install_state)
        errors = dict(game_errors)
        for name in list(running_procs):
            is_running(name)  # lazy cleanup of any game that exited on its own
        novnc_ports = {name: info["novnc_port"] for name, info in running_procs.items()}
    slots_used = len(novnc_ports)

    def button(action, name, label):
        # Not a <form> - a real form submit navigates the page, which would tear down the
        # persistent audio AudioContext/WebSocket below. doAction() fetch()es instead and
        # re-renders just #content in place, so the page never actually navigates.
        return (
            f'<button onclick="doAction(\'{action}\',\'{name}\')">{label}</button>'
        )

    rows = []
    for name, manifest in sorted(games.items()):
        title = html.escape(manifest.get("title", name))
        release_date = html.escape(manifest.get("release_date", ""))
        publisher = html.escape(manifest.get("publisher", ""))
        size = sizes.get(name)
        size_html = f"{size / 1_000_000:.1f} MB" if size else "?"
        status = pending.get(name)
        screen_html = ""
        volume_html = ""
        if name in novnc_ports:
            status_html = '<span class="status busy">Running</span>'
            screen_html = f'<a href="https://{host}:{novnc_ports[name]}/" target="_blank">Open Screen</a>'
            volume_html = (
                f'<input type="range" min="0" max="150" value="100" class="volume" '
                f"oninput=\"fetch('/volume',{{method:'POST',"
                f"headers:{{'Content-Type':'application/x-www-form-urlencoded'}},"
                f"body:'name={name}&level='+this.value}})\">"
            )
            actions = button("stop", name, "Stop")
        elif status in ("downloading", "extracting"):
            status_html = f'<span class="status busy">{status}...</span>'
            actions = ""
        elif status and status.startswith("error"):
            status_html = f'<span class="status err">{html.escape(status)}</span>'
            actions = button("install", name, "Retry")
        elif is_installed(name):
            status_html = '<span class="status ok">Installed</span>'
            if name in errors:
                status_html += f'<br><span class="status err">{html.escape(errors[name])}</span>'
            start_button = button("start", name, "Start") if slots_used < MAX_CONCURRENT_GAMES else ""
            actions = start_button + button("uninstall", name, "Uninstall")
        else:
            status_html = "Not installed"
            actions = button("install", name, "Install")
        rows.append(
            f"<tr><td>{title}</td><td>{release_date}</td><td>{publisher}</td>"
            f"<td>{size_html}</td><td>{status_html}</td><td>{actions}</td>"
            f"<td>{screen_html}</td><td>{volume_html}</td></tr>"
        )

    return f"""<!doctype html>
<html>
<head>
<title>dosbox-novnc game setup</title>
<style>
body {{ font-family: sans-serif; margin: 2em; }}
table {{ border-collapse: collapse; width: 100%; max-width: 800px; }}
th, td {{ text-align: left; padding: 0.5em 1em; border-bottom: 1px solid #ccc; }}
button {{ padding: 0.3em 0.8em; margin-right: 0.3em; }}
.status.ok {{ color: #2a2; font-weight: bold; }}
.status.busy {{ color: #a70; font-weight: bold; }}
.status.err {{ color: #c22; }}
.slots {{ margin-bottom: 1.5em; }}
.volume {{ width: 80px; vertical-align: middle; }}
</style>
</head>
<body>
<div id="content">
<p class="slots">{slots_used}/{MAX_CONCURRENT_GAMES} game slots in use</p>
<h1>DOSBox games</h1>
<table>
<tr><th>Game</th><th>Release</th><th>Publisher</th><th>Size</th><th>Status</th><th>Actions</th><th></th><th>Volume</th></tr>
{''.join(rows) if rows else '<tr><td colspan="8">No game manifests found on the share</td></tr>'}
</table>
</div>
<script>
// None of the buttons/inputs above are <form>s - a real form submit (or any other full
// page navigation) would tear down the persistent audio AudioContext/WebSocket set up
// below. doAction()/refresh() fetch() instead and only ever replace #content in place, so
// the page itself never navigates, no matter how many games get installed/started/stopped.
async function refresh() {{
  const res = await fetch('/');
  const doc = new DOMParser().parseFromString(await res.text(), 'text/html');
  document.getElementById('content').innerHTML = doc.getElementById('content').innerHTML;
}}
async function doAction(action, name) {{
  await fetch('/' + action, {{
    method: 'POST',
    headers: {{'Content-Type': 'application/x-www-form-urlencoded'}},
    body: 'name=' + encodeURIComponent(name),
  }});
  refresh();
}}
setInterval(refresh, 3000);

// Audio is on by default - no button. AudioContexts start suspended until a user
// gesture, so this connects everything eagerly and just resumes on the page's first
// click/keypress (whatever the user was already doing, e.g. clicking Start on a game).
// Safe from the refresh() calls above too, since those never touch anything outside
// #content - this script block, and the AudioContext/WebSocket it created, are untouched.
const ctx = new AudioContext({{ sampleRate: 48000 }});
ctx.audioWorklet.addModule('/pcm-worklet.js').then(() => {{
  const node = new AudioWorkletNode(ctx, 'pcm-worklet-processor', {{ outputChannelCount: [2] }});
  node.connect(ctx.destination);
  const ws = new WebSocket('ws://{host}:{AUDIO_PORT}/');
  ws.binaryType = 'arraybuffer';
  ws.onmessage = (event) => node.port.postMessage(event.data, [event.data]);
}});
const unlockAudio = () => {{
  ctx.resume();
  document.removeEventListener('click', unlockAudio);
  document.removeEventListener('keydown', unlockAudio);
}};
document.addEventListener('click', unlockAudio);
document.addEventListener('keydown', unlockAudio);
</script>
</body>
</html>"""


class Handler(BaseHTTPRequestHandler):
    def log_message(self, fmt, *args):
        pass

    def _send_html(self, body, status=200):
        encoded = body.encode("utf-8")
        self.send_response(status)
        self.send_header("Content-Type", "text/html; charset=utf-8")
        self.send_header("Content-Length", str(len(encoded)))
        self.end_headers()
        self.wfile.write(encoded)

    def _send_file(self, path, content_type):
        try:
            with open(path, "rb") as f:
                content = f.read()
        except OSError:
            self._send_html("Not found", status=404)
            return
        self.send_response(200)
        self.send_header("Content-Type", content_type)
        self.send_header("Content-Length", str(len(content)))
        self.end_headers()
        self.wfile.write(content)

    def do_GET(self):
        path = urlparse(self.path).path
        if path == "/":
            host = self.headers.get("Host", "localhost").rsplit(":", 1)[0]
            self._send_html(render_page(host))
        elif path == "/pcm-worklet.js":
            self._send_file(os.path.join(SCRIPTS_HOME, "pcm-worklet.js"), "application/javascript")
        else:
            self._send_html("Not found", status=404)

    def do_POST(self):
        action = urlparse(self.path).path.lstrip("/")
        if action not in ("install", "uninstall", "start", "stop", "volume"):
            self._send_html("Not found", status=404)
            return

        length = int(self.headers.get("Content-Length", 0))
        body = self.rfile.read(length).decode("utf-8")
        params = parse_qs(body)
        name = params.get("name", [""])[0]

        if action == "volume":
            # Fired on every slider tick via fetch(), not a form submit - no page navigation.
            try:
                level = int(params.get("level", ["100"])[0])
            except ValueError:
                level = 100
            set_volume(name, level)
            self.send_response(204)
            self.end_headers()
            return

        games = discover_games()

        if name in games:
            manifest = games[name]
            if action == "install":
                threading.Thread(target=install_game, args=(name, manifest), daemon=True).start()
            elif action == "uninstall":
                threading.Thread(target=uninstall_game, args=(name,), daemon=True).start()
            elif action == "start":
                threading.Thread(target=start_game, args=(name, manifest), daemon=True).start()
            elif action == "stop":
                threading.Thread(target=stop_game, args=(name,), daemon=True).start()

        # No redirect: the client's own doAction()/refresh() re-fetches "/" itself and
        # replaces #content in place, never navigating the page (see render_page()'s JS).
        self.send_response(204)
        self.end_headers()


if __name__ == "__main__":
    ThreadingHTTPServer(("0.0.0.0", SETUP_PORT), Handler).serve_forever()