Docker-Adapter: LAN-Modus ohne GSLT, Container starten nacheinander

Ohne CS2_GSLT starten Match-Container mit CS2_LAN=1. Neue Container
warten, bis der vorige seinen SteamCMD-Update-Check abgeschlossen hat,
damit nie zwei gleichzeitig das gemeinsame Volume aktualisieren.
Anleitung: Docker per SSH (DOCKER_HOST), eindeutige Passwort-Beispiele
mit Warnung vor Sonderzeichen (Startskript nutzt eval).

server/src/servers/dockerAdapter.js

@@ -4,26 +4,39 @@ import { configureViaRcon, rconStatus } from './rconConfigure.js';
 import { runRcon } from './rcon.js';
 
 const exec = promisify(execFile);
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// Diese Zeile schreibt das Image, sobald SteamCMD fertig ist und der Spielserver startet.
+const UPDATE_DONE_MARKER = 'Starting CS2 Dedicated Server';
 
 /**
  * Startet pro Match einen eigenen CS2-Container (Standard-Image: joedwards32/cs2, Nachfolger von cm2network/cs2).
- * Benötigt Docker auf dem Backend-Host, ein Game Server Login Token (CS2_GSLT)
- * und eine öffentlich erreichbare Adresse (CS2_PUBLIC_HOST).
+ * Benötigt Docker (lokal oder per DOCKER_HOST, z. B. ssh://…) und die Adresse, unter der Spieler
+ * den Docker-Host erreichen (CS2_PUBLIC_HOST).
+ *
+ * Ohne CS2_GSLT laufen die Server im LAN-Modus (sv_lan 1): nur aus dem lokalen Netz erreichbar.
  *
  * Pro Match werden zwei aufeinanderfolgende Ports belegt: Spielport (TCP+UDP, auch RCON)
  * und CSTV-Port (UDP).
+ *
+ * Alle Container teilen sich das Volume mit den Spieldateien. Jeder prüft beim Start per SteamCMD
+ * auf Updates; damit nie zwei gleichzeitig schreiben, starten Container nacheinander: der nächste
+ * erst, wenn der vorige seinen Update-Check abgeschlossen hat.
  */
 export class DockerServerAdapter {
-  constructor(options, { getUsedPorts }) {
+  constructor(options, { getUsedPorts, runDocker } = {}) {
     this.name = 'docker';
     this.simulated = false;
     this.options = options;
     this.getUsedPorts = getUsedPorts;
+    this.runDocker = runDocker; // nur für Tests
+    this.lanMode = !options.gslt;
+    this.startQueue = Promise.resolve();
     if (!options.host) throw new Error('SERVER_ADAPTER=docker benötigt CS2_PUBLIC_HOST');
-    if (!options.gslt) throw new Error('SERVER_ADAPTER=docker benötigt CS2_GSLT (Game Server Login Token)');
   }
 
   async docker(args, timeout = 60_000) {
+    if (this.runDocker) return this.runDocker(args);
     const { stdout } = await exec(this.options.bin, args, { timeout, maxBuffer: 4 * 1024 * 1024 });
     return stdout.trim();
   }
@@ -36,12 +49,45 @@ export class DockerServerAdapter {
     throw new Error('Kein freier Port im Bereich CS2_PORT_RANGE_START–CS2_PORT_RANGE_END');
   }
 
-  async start({ matchId, mode, secrets }) {
+  async start(args) {
+    // In die Warteschlange: erst starten, wenn der vorige Container seinen Update-Check hinter sich hat.
+    const previous = this.startQueue;
+    let release;
+    this.startQueue = new Promise((resolve) => { release = resolve; });
+    await previous;
+    let result;
+    try {
+      result = await this.launch(args);
+    } catch (err) {
+      release();
+      throw err;
+    }
+    this.waitForUpdateCheck(result.handle.container).finally(release);
+    return result;
+  }
+
+  /** Wartet, bis der Container SteamCMD abgeschlossen hat, beendet ist oder die Startzeit abläuft. */
+  async waitForUpdateCheck(container, { pollMs = 3000 } = {}) {
+    const deadline = Date.now() + this.options.startTimeoutMinutes * 60_000;
+    while (Date.now() < deadline) {
+      try {
+        const state = await this.docker(['inspect', '-f', '{{.State.Status}}', container], 15_000);
+        if (state !== 'running' && state !== 'created') return;
+        const logs = await this.docker(['logs', '--tail', '200', container], 15_000);
+        if (logs.includes(UPDATE_DONE_MARKER)) return;
+      } catch {
+        return; // Container weg – nicht ewig blockieren
+      }
+      await sleep(pollMs);
+    }
+  }
+
+  async launch({ matchId, mode, secrets }) {
     const port = this.allocatePort();
     const tvPort = port + 1;
     const container = `cs2mv-${matchId.replace(/[^a-zA-Z0-9_-]/g, '')}`.toLowerCase();
     const env = {
-      SRCDS_TOKEN: this.options.gslt,
+      ...(this.lanMode ? { CS2_LAN: '1' } : { SRCDS_TOKEN: this.options.gslt, CS2_LAN: '0' }),
       CS2_SERVERNAME: `CS2 Mapveto ${matchId}`,
       CS2_PORT: String(port),
       CS2_RCONPW: secrets.rconPassword,
@@ -104,7 +150,7 @@ export class DockerServerAdapter {
       if (minutes >= this.options.startTimeoutMinutes) {
         return { state: 'failed', message: `Server nach ${minutes} Minuten nicht per RCON erreichbar` };
       }
-      return { state: 'starting', message: 'Container läuft, Spielserver lädt (Download/Update möglich)' };
+      return { state: 'starting', message: 'Container läuft, Spielserver lädt (Update-Prüfung oder Start)' };
     }
   }
 

server/test/dockerAdapter.test.js

@@ -0,0 +1,74 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { DockerServerAdapter } from '../src/servers/dockerAdapter.js';
+
+const options = {
+  bin: 'docker', image: 'joedwards32/cs2:latest', host: '192.168.178.111', rconHost: '192.168.178.111',
+  portRangeStart: 27100, portRangeEnd: 27139, gslt: '', volume: 'cs2-mapveto-gamefiles', extraArgs: '', startTimeoutMinutes: 1,
+};
+const secrets = { rconPassword: 'Rcon123', serverPassword: 'Pw123', tvPassword: 'Tv123' };
+
+/** Simuliertes Docker: merkt sich Aufrufe; Container gelten als "Update fertig", sobald freigegeben. */
+function fakeDocker() {
+  const calls = [];
+  const updated = new Set();
+  const run = async (args) => {
+    calls.push(args);
+    const [cmd] = args;
+    const name = args.at(-1);
+    if (cmd === 'inspect') return 'running';
+    if (cmd === 'logs') return updated.has(name) ? 'Success! App \'730\' already up to date.\nStarting CS2 Dedicated Server' : 'Checking for available updates...';
+    return '';
+  };
+  return { run, calls, finishUpdate: (name) => updated.add(name) };
+}
+
+const envOf = (args) => Object.fromEntries(args.flatMap((a, i) => (args[i - 1] === '-e' ? [a.split(/=(.*)/s).slice(0, 2)] : [])));
+
+test('Ohne GSLT startet der Container im LAN-Modus, mit GSLT mit Token', async () => {
+  const lan = fakeDocker();
+  const a = new DockerServerAdapter(options, { getUsedPorts: () => new Set(), runDocker: lan.run });
+  const r = await a.start({ matchId: 'abc_DEF-1', mode: 'wingman', secrets });
+  lan.finishUpdate(r.handle.container);
+  const runArgs = lan.calls.find((c) => c[0] === 'run');
+  const env = envOf(runArgs);
+  assert.equal(env.CS2_LAN, '1');
+  assert.equal(env.SRCDS_TOKEN, undefined);
+  assert.equal(env.CS2_GAMEMODE, '2');
+  assert.equal(env.CS2_PORT, '27100');
+  assert.equal(env.TV_PORT, '27101');
+  assert.ok(runArgs.includes('cs2-mapveto-gamefiles:/home/steam/cs2-dedicated'));
+  assert.equal(r.host, '192.168.178.111');
+
+  const tok = fakeDocker();
+  const b = new DockerServerAdapter({ ...options, gslt: 'TOKEN1' }, { getUsedPorts: () => new Set(), runDocker: tok.run });
+  const r2 = await b.start({ matchId: 'x', mode: 'competitive', secrets });
+  tok.finishUpdate(r2.handle.container);
+  const env2 = envOf(tok.calls.find((c) => c[0] === 'run'));
+  assert.equal(env2.SRCDS_TOKEN, 'TOKEN1');
+  assert.equal(env2.CS2_LAN, '0');
+});
+
+test('Zweiter Container startet erst, wenn der erste seinen Update-Check abgeschlossen hat', async () => {
+  const d = fakeDocker();
+  const used = new Set();
+  const a = new DockerServerAdapter(options, { getUsedPorts: () => used, runDocker: d.run });
+  // Wartezeit zwischen Prüfungen für den Test verkürzen
+  const original = a.waitForUpdateCheck.bind(a);
+  a.waitForUpdateCheck = (name) => original(name, { pollMs: 10 });
+
+  const first = await a.start({ matchId: 'm1', mode: 'competitive', secrets });
+  used.add(first.port).add(first.tvPort);
+  let secondDone = false;
+  const second = a.start({ matchId: 'm2', mode: 'competitive', secrets }).then((r) => { secondDone = true; return r; });
+
+  await new Promise((r) => setTimeout(r, 60));
+  assert.equal(secondDone, false, 'zweiter Start wartet noch');
+  assert.equal(d.calls.filter((c) => c[0] === 'run').length, 1);
+
+  d.finishUpdate(first.handle.container);
+  const r2 = await second;
+  assert.equal(d.calls.filter((c) => c[0] === 'run').length, 2);
+  assert.equal(r2.port, 27102, 'zweiter Container bekommt die nächsten Ports');
+  d.finishUpdate(r2.handle.container);
+});