Compare commits
21
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 mregosar
|
46d1954a6d | ||
|
mregosar
|
30ec5359b1 | ||
|
mregosar
|
5527c2ce58 | ||
|
mregosar
|
1b7c13b592 | ||
|
mregosar
|
e3a1ed4a63 | ||
|
mregosar
|
84dad0993c | ||
|
mregosar
|
3a109883b3 | ||
|
mregosar
|
85041b2bff | ||
|
mregosar
|
ea2207899f | ||
|
mregosar
|
263c7e7b7c | ||
|
mregosar
|
306b3aa7e5 | ||
|
mregosar
|
34e5fc7d0e | ||
|
mregosar
|
8be8b3d879 | ||
|
mregosar
|
3a74e16bb8 | ||
|
mregosar
|
f1fc1642ab | ||
|
mregosar
|
db4a6bedf7 | ||
|
mregosar
|
7be0d85ab5 | ||
|
mregosar
|
e304556346 | ||
|
mregosar
|
bf438511d6 | ||
|
mregosar
|
f7520a6ca7 | ||
|
mregosar
|
f08297dd0d |
No files matched your search
@@ -14,7 +14,6 @@ export default function App() {
|
||||
<Routes>
|
||||
{/* Stream-Übersicht ohne Kopfzeile, als Vollbild bzw. OBS-Browserquelle */}
|
||||
<Route path="/stream/:code" element={<StreamPage />} />
|
||||
<Route path="/stream/match/:matchId" element={<StreamOverviewPage />} />
|
||||
<Route path="/stream" element={<StreamOverviewPage />} />
|
||||
<Route path="*" element={<MainLayout />} />
|
||||
</Routes>
|
||||
|
||||
@@ -29,8 +29,6 @@ export default function OrganizerPanel({ state, act, busy, matchId, token }) {
|
||||
<div className="stream-link">
|
||||
<CopyField label="Stream-Übersicht (als Browserquelle in OBS, 1920×1080)" value={links.stream} />
|
||||
<a className="btn btn-sm" href={links.stream} target="_blank" rel="noreferrer">Stream-Ansicht öffnen</a>
|
||||
<CopyField label="Match-Übersicht (nur dieses Match, ohne Zuschauercode)" value={links.overview} />
|
||||
<a className="btn btn-sm" href={links.overview} target="_blank" rel="noreferrer">Match-Übersicht öffnen</a>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
|
||||
@@ -99,7 +99,7 @@ export default function AdminPage() {
|
||||
|
||||
<div className="admin-list">
|
||||
{matches?.map((m) => (
|
||||
<MatchAdminCard key={m.id} m={m} run={run} busy={busy} token={token} reload={load} setNotice={setNotice} />
|
||||
<MatchAdminCard key={m.id} m={m} run={run} busy={busy} />
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
@@ -137,56 +137,7 @@ function AdminLogin({ onLogin }) {
|
||||
);
|
||||
}
|
||||
|
||||
/** Rollback: nur auf der Admin-Seite. Lädt die Sicherungen der aktuellen Map und spielt eine davon zurück. */
|
||||
function RollbackPanel({ matchId, token, reload, setNotice }) {
|
||||
const [points, setPoints] = useState(null);
|
||||
const [file, setFile] = useState('');
|
||||
const [loading, setLoading] = useState(false);
|
||||
|
||||
const load = async () => {
|
||||
setLoading(true);
|
||||
try {
|
||||
const res = await api(`/admin/matches/${matchId}/rollback-points`, { token });
|
||||
setPoints(res.points);
|
||||
setFile(res.points[0]?.file ?? '');
|
||||
} catch (err) {
|
||||
setNotice({ tone: 'error', text: err.message });
|
||||
} finally {
|
||||
setLoading(false);
|
||||
}
|
||||
};
|
||||
|
||||
const rollback = async () => {
|
||||
const p = points.find((x) => x.file === file);
|
||||
if (!p || !window.confirm(`Match auf den Stand nach Runde ${p.round} zurückspielen? Spätere Runden dieser Map gehen verloren.`)) return;
|
||||
try {
|
||||
await api(`/admin/matches/${matchId}/rollback`, { method: 'POST', body: { file }, token });
|
||||
setNotice({ tone: 'ok', text: `Zurückgespielt auf Runde ${p.round}` });
|
||||
setPoints(null);
|
||||
reload();
|
||||
} catch (err) {
|
||||
setNotice({ tone: 'error', text: err.message });
|
||||
}
|
||||
};
|
||||
|
||||
return (
|
||||
<div className="rollback">
|
||||
<h3>Runde zurückspielen <span className="admin-badge">nur Admin</span></h3>
|
||||
{!points && <button className="btn btn-sm" onClick={load} disabled={loading}>{loading ? 'Lade …' : 'Sicherungen laden'}</button>}
|
||||
{points && points.length === 0 && <p className="small muted">Keine Sicherungen für diese Map gefunden.</p>}
|
||||
{points && points.length > 0 && (
|
||||
<div className="row">
|
||||
<select value={file} onChange={(e) => setFile(e.target.value)}>
|
||||
{points.map((p) => <option key={p.file} value={p.file}>Nach Runde {p.round}</option>)}
|
||||
</select>
|
||||
<button className="btn btn-sm btn-danger" onClick={rollback}>Zurückspielen</button>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
function MatchAdminCard({ m, run, busy, token, reload, setNotice }) {
|
||||
function MatchAdminCard({ m, run, busy }) {
|
||||
const [open, setOpen] = useState(false);
|
||||
const server = serverLabel(m.server);
|
||||
const closed = ['finished', 'cancelled'].includes(m.status);
|
||||
@@ -280,10 +231,6 @@ function MatchAdminCard({ m, run, busy, token, reload, setNotice }) {
|
||||
))}
|
||||
</div>
|
||||
|
||||
{m.status === 'live' && m.server?.status === 'configured' && (
|
||||
<RollbackPanel matchId={id} token={token} reload={reload} setNotice={setNotice} />
|
||||
)}
|
||||
|
||||
{m.veto && !m.veto.done && m.veto.current && (
|
||||
<p className="small">Veto: {m.teams[m.veto.current.team].name} ist am Zug ({m.veto.current.type}).</p>
|
||||
)}
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
import { useEffect, useState } from 'react';
|
||||
import { useParams } from 'react-router-dom';
|
||||
import { api } from '../lib/api.js';
|
||||
import { FORMAT_LABEL } from '../lib/labels.js';
|
||||
import { getSocket } from '../lib/useMatch.js';
|
||||
@@ -15,13 +14,11 @@ const PAGE_SECONDS = 12;
|
||||
/**
|
||||
* Stream-Übersicht aller laufenden Vetos und Matches: /stream
|
||||
* Mit STREAM_KEY: /stream?key=<schlüssel>. Optional ?bg=transparent.
|
||||
* Ein einzelnes Match: /stream/match/<matchId>, daraus führen die Karten der Übersicht.
|
||||
*/
|
||||
export default function StreamOverviewPage() {
|
||||
const params = new URLSearchParams(window.location.search);
|
||||
const key = params.get('key') ?? '';
|
||||
const transparent = params.get('bg') === 'transparent';
|
||||
const { matchId } = useParams();
|
||||
const { data, error } = useStreamOverview(key);
|
||||
const now = useClock();
|
||||
const [page, setPage] = useState(0);
|
||||
@@ -32,10 +29,8 @@ export default function StreamOverviewPage() {
|
||||
return () => document.documentElement.classList.remove('stream-mode', 'stream-transparent');
|
||||
}, [transparent]);
|
||||
|
||||
const activeMatches = (data?.active ?? []).filter((m) => !matchId || m.id === matchId);
|
||||
|
||||
// Mehr Matches als auf eine Seite passen: automatisch weiterblättern
|
||||
const pages = Math.max(1, Math.ceil(activeMatches.length / PER_PAGE));
|
||||
const pages = data ? Math.max(1, Math.ceil(data.active.length / PER_PAGE)) : 1;
|
||||
useEffect(() => {
|
||||
if (pages <= 1) { setPage(0); return undefined; }
|
||||
const t = setInterval(() => setPage((p) => (p + 1) % pages), PAGE_SECONDS * 1000);
|
||||
@@ -54,7 +49,7 @@ export default function StreamOverviewPage() {
|
||||
);
|
||||
}
|
||||
|
||||
const active = activeMatches;
|
||||
const active = data?.active ?? [];
|
||||
const shown = active.slice(page * PER_PAGE, page * PER_PAGE + PER_PAGE);
|
||||
const liveCount = active.filter((m) => m.status === 'live').length;
|
||||
const vetoCount = active.filter((m) => m.status === 'veto').length;
|
||||
@@ -78,24 +73,11 @@ export default function StreamOverviewPage() {
|
||||
{!data && <div className="so-empty">Lade Matches …</div>}
|
||||
{data && shown.length === 0 && (
|
||||
<div className="so-empty">
|
||||
{matchId ? (
|
||||
<>
|
||||
<h2>Dieses Match läuft gerade nicht</h2>
|
||||
<p>Es erscheint hier, sobald das Veto oder das Match beginnt.</p>
|
||||
</>
|
||||
) : (
|
||||
<>
|
||||
<h2>Gerade läuft kein Match</h2>
|
||||
<p>{data.upcoming.length ? 'Die nächsten Lobbys stehen unten.' : 'Sobald ein Veto beginnt, erscheint es hier.'}</p>
|
||||
</>
|
||||
)}
|
||||
<h2>Gerade läuft kein Match</h2>
|
||||
<p>{data.upcoming.length ? 'Die nächsten Lobbys stehen unten.' : 'Sobald ein Veto beginnt, erscheint es hier.'}</p>
|
||||
</div>
|
||||
)}
|
||||
{shown.map((m) => (
|
||||
<a key={m.id} className="so-link" href={matchHref(m.id, key)}>
|
||||
<MatchCard m={m} />
|
||||
</a>
|
||||
))}
|
||||
{shown.map((m) => <MatchCard key={m.id} m={m} />)}
|
||||
</main>
|
||||
|
||||
<footer className="so-bottom">
|
||||
@@ -105,10 +87,8 @@ export default function StreamOverviewPage() {
|
||||
<ul>
|
||||
{data.upcoming.map((m) => (
|
||||
<li key={m.id}>
|
||||
<a className="so-link" href={matchHref(m.id, key)}>
|
||||
<span className="a">{m.teams.A}</span> <span className="vs">vs</span> <span className="b">{m.teams.B}</span>
|
||||
<small>{FORMAT_LABEL[m.format]}{m.ready.A && m.ready.B ? ', bereit' : ''}</small>
|
||||
</a>
|
||||
<span className="a">{m.teams.A}</span> <span className="vs">vs</span> <span className="b">{m.teams.B}</span>
|
||||
<small>{FORMAT_LABEL[m.format]}{m.ready.A && m.ready.B ? ', bereit' : ''}</small>
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
@@ -120,11 +100,9 @@ export default function StreamOverviewPage() {
|
||||
<ul>
|
||||
{data.results.map((m) => (
|
||||
<li key={m.id}>
|
||||
<a className="so-link" href={matchHref(m.id, key)}>
|
||||
<span className={`a ${winner(m) === 'A' ? 'won' : ''}`}>{m.teams.A}</span>
|
||||
<b>{resultScore(m)}</b>
|
||||
<span className={`b ${winner(m) === 'B' ? 'won' : ''}`}>{m.teams.B}</span>
|
||||
</a>
|
||||
<span className={`a ${winner(m) === 'A' ? 'won' : ''}`}>{m.teams.A}</span>
|
||||
<b>{resultScore(m)}</b>
|
||||
<span className={`b ${winner(m) === 'B' ? 'won' : ''}`}>{m.teams.B}</span>
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
@@ -136,11 +114,6 @@ export default function StreamOverviewPage() {
|
||||
);
|
||||
}
|
||||
|
||||
/** Link zur Stream-Übersicht eines einzelnen Matches. Der Zuschauercode bleibt geheim, daher nur die Match-ID. */
|
||||
function matchHref(id, key) {
|
||||
return `/stream/match/${encodeURIComponent(id)}${key ? `?key=${encodeURIComponent(key)}` : ''}`;
|
||||
}
|
||||
|
||||
function useStreamOverview(key) {
|
||||
const [data, setData] = useState(null);
|
||||
const [error, setError] = useState(null);
|
||||
@@ -172,6 +145,7 @@ function winner(m) {
|
||||
const [a, b] = resultScore(m).split(':').map(Number);
|
||||
return a === b ? null : a > b ? 'A' : 'B';
|
||||
}
|
||||
|
||||
function MatchCard({ m }) {
|
||||
const current = m.series.find((s) => s.number === m.currentMapNumber);
|
||||
const isBo1 = m.format === 'bo1';
|
||||
|
||||
@@ -114,9 +114,3 @@
|
||||
.so-strip li b { font-variant-numeric: tabular-nums; }
|
||||
.so-strip li .won { text-decoration: underline; text-underline-offset: 5px; }
|
||||
.so-none { color: var(--muted); font-size: 22px; margin: 0; }
|
||||
|
||||
/* Klickbare Karten und Listeneinträge führen zur Übersicht des jeweiligen Matches */
|
||||
.so-link { display: block; color: inherit; text-decoration: none; }
|
||||
.so-strip li .so-link { display: flex; align-items: baseline; gap: 10px; color: inherit; text-decoration: none; }
|
||||
.so-link:hover { filter: brightness(1.15); }
|
||||
.so-link:focus-visible { outline: 3px solid var(--brand-red); outline-offset: 4px; }
|
||||
@@ -506,9 +506,3 @@ input:focus, select:focus { border-color: var(--link); outline: none; }
|
||||
.admin-login { margin-top: 40px; }
|
||||
.danger { color: var(--error); }
|
||||
@media (max-width: 640px) { .admin-players { grid-template-columns: 1fr; } }
|
||||
|
||||
/* ---------- Rollback (nur Admin) ---------- */
|
||||
.rollback { border: 1px dashed var(--brand-red); border-radius: var(--radius); padding: 12px 14px; }
|
||||
.rollback h3 { margin: 0 0 8px; display: flex; align-items: center; gap: 10px; }
|
||||
.rollback select { min-width: 200px; }
|
||||
.admin-badge { font: 600 .75rem var(--body); color: #fff; background: var(--brand-red); padding: 2px 8px; border-radius: 3px; }
|
||||
@@ -101,13 +101,6 @@ export function createAdminRouter({ service, manager, config }) {
|
||||
action('kick', (v, b) => service.kick(v, b.playerId));
|
||||
action('codes/regenerate', (v, b) => service.regenerateCode(v, b.target));
|
||||
|
||||
// Rollback: nur für Admins. Diese Routen gibt es für Organisatoren nicht.
|
||||
router.get('/matches/:id/rollback-points', requireAdmin, wrap(async (req) => {
|
||||
service.getMatch(req.params.id);
|
||||
return { points: await manager.rollbackPoints(adminViewer(req.params.id)) };
|
||||
}));
|
||||
action('rollback', (v, b) => manager.rollback(v, b.file));
|
||||
|
||||
// Match endgültig löschen (Server wird vorher freigegeben)
|
||||
router.delete('/matches/:id', requireAdmin, wrap(async (req) => {
|
||||
await manager.deleteMatch(req.params.id);
|
||||
|
||||
@@ -2,7 +2,6 @@ import { EventEmitter } from 'node:events';
|
||||
import { BEST_OF, computeVetoState, resolveAction, VetoError } from './veto.js';
|
||||
import { formatCode, hashToken, normalizeCode, randomCode, randomId, randomToken, safeEqual } from './security.js';
|
||||
import { applyLogLines, initialLiveState, seriesScore, splitLogBody } from './liveScore.js';
|
||||
import { trimLiveState } from './rounds.js';
|
||||
import { sanitizeConsoleText } from './servers/cs2Config.js';
|
||||
|
||||
export class HttpError extends Error {
|
||||
@@ -449,20 +448,6 @@ export class MatchService extends EventEmitter {
|
||||
.run(matchId, number);
|
||||
}
|
||||
|
||||
/** Stand auf den Zeitpunkt nach einer Runde zurückstellen (nach Rollback). */
|
||||
rewindLiveScore(matchId, roundNumber, file) {
|
||||
const match = this.getMatch(matchId);
|
||||
const row = this.seriesMaps(matchId).find((m) => m.number === match.current_map_number);
|
||||
if (!row) return;
|
||||
const live = row.live ? trimLiveState(JSON.parse(row.live), roundNumber) : null;
|
||||
const score = live ? live.score : { A: 0, B: 0 };
|
||||
this.db
|
||||
.prepare("UPDATE series_maps SET score_a = ?, score_b = ?, winner = NULL, status = 'live', live = ?, live_updated_at = ? WHERE match_id = ? AND number = ?")
|
||||
.run(score.A, score.B, live ? JSON.stringify(live) : null, this.now(), matchId, row.number);
|
||||
this.log(matchId, 'rollback', `Map ${row.number} zurückgespielt auf Runde ${roundNumber} (${file})`);
|
||||
this.changed(matchId);
|
||||
}
|
||||
|
||||
/** Organisator hat die Aufwärmphase beendet: ab dem nächsten Match_Start wird gezählt. */
|
||||
markWarmupEnded(matchId, ended = true) {
|
||||
const match = this.getMatch(matchId);
|
||||
@@ -796,8 +781,6 @@ export class MatchService extends EventEmitter {
|
||||
spectator: `${base}/watch/${formatCode(match.code_spectator)}`,
|
||||
// Vollbild-Übersicht für den Stream (OBS-Browserquelle), nutzt den Zuschauercode
|
||||
stream: `${base}/stream/${formatCode(match.code_spectator)}`,
|
||||
// Stream-Übersicht nur für dieses Match, ohne Zuschauercode (Schlüssel nur wenn gesetzt)
|
||||
overview: `${base}/stream/match/${match.id}${this.config.streamKey ? `?key=${encodeURIComponent(this.config.streamKey)}` : ''}`,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
@@ -1,62 +0,0 @@
|
||||
// Rundensicherung und Zurückspielen (Rollback).
|
||||
//
|
||||
// CS2 speichert nach jeder Runde eine Sicherungsdatei des Spielzustands auf dem Server (mp_backup_round_auto).
|
||||
// Diese Datei lässt sich später wieder laden (mp_backup_restore_load_file). Dieses Modul kennt die Namen,
|
||||
// wertet die Liste aus und kürzt den gespeicherten Live-Stand passend zur Rückkehr.
|
||||
|
||||
// Präfix und Muster wie bei TMT2: der Präfix enthält die Match-ID, das Muster Map, Runde und Stand.
|
||||
export const backupPrefix = (matchId) => `round_backup_${matchId}`;
|
||||
export const BACKUP_PATTERN = '%prefix%_%date%_%time%_%map%_round%round%_score_%score1%_%score2%.txt';
|
||||
|
||||
// Endung: _<map>_round<N>_score_<a>_<b>.txt – die Map beginnt mit zwei Kleinbuchstaben und Unterstrich (de_, cs_, ar_ …)
|
||||
const ROUND_RE = /_([a-z]{2}_[a-z0-9_]+?)_round(\d+)_score_(\d+)_(\d+)\.txt$/;
|
||||
|
||||
/** Ist der Dateiname eine Sicherung genau dieses Matches? Schützt vor Pfaden wie "../" und fremden Dateien. */
|
||||
export function isValidBackupFile(file, matchId) {
|
||||
if (typeof file !== 'string' || file.length > 200) return false;
|
||||
if (!file.startsWith(backupPrefix(matchId))) return false;
|
||||
return /^[A-Za-z0-9_.-]+\.txt$/.test(file) && !file.includes('..') && ROUND_RE.test(file);
|
||||
}
|
||||
|
||||
/** Findet alle Sicherungsdateien dieses Matches in einer RCON-Antwort (Format der Antwort ist nicht festgelegt). */
|
||||
export function parseBackupFiles(text, matchId) {
|
||||
const prefix = backupPrefix(matchId);
|
||||
const found = new Set();
|
||||
const re = new RegExp(`${prefix}_[A-Za-z0-9_.-]+\\.txt`, 'g');
|
||||
for (const m of String(text ?? '').matchAll(re)) found.add(m[0]);
|
||||
return [...found].filter((f) => isValidBackupFile(f, matchId)).map((file) => describeBackup(file, matchId));
|
||||
}
|
||||
|
||||
/**
|
||||
* Zerlegt einen Dateinamen in Map, Rundennummer und Stand. Mit matchId wird vorher der Präfix entfernt,
|
||||
* damit Teile der Match-ID nicht mit einem Map-Namen verwechselt werden.
|
||||
*/
|
||||
export function describeBackup(file, matchId = null) {
|
||||
const rest = matchId && file.startsWith(backupPrefix(matchId)) ? file.slice(backupPrefix(matchId).length) : file;
|
||||
const m = ROUND_RE.exec(rest);
|
||||
if (!m) return { file, map: null, round: null, score: null };
|
||||
return { file, map: m[1], round: Number(m[2]), score: { s1: Number(m[3]), s2: Number(m[4]) } };
|
||||
}
|
||||
|
||||
/** Nur die Sicherungen der gerade gespielten Map, neueste Runde zuerst. */
|
||||
export function pointsForMap(points, map) {
|
||||
return points.filter((p) => p.map === map).sort((a, b) => b.round - a.round);
|
||||
}
|
||||
|
||||
/**
|
||||
* Kürzt den Live-Stand auf die Runden bis einschließlich roundNumber und rechnet den Stand neu.
|
||||
* Danach zählt die Anzeige weiter, sobald CS2 wieder Rundenmeldungen schickt.
|
||||
*/
|
||||
export function trimLiveState(state, roundNumber) {
|
||||
const rounds = (state.rounds ?? []).filter((r) => r.number <= roundNumber);
|
||||
const score = { A: 0, B: 0 };
|
||||
for (const r of rounds) if (r.winner) score[r.winner] += 1;
|
||||
return {
|
||||
...state,
|
||||
status: 'live',
|
||||
rounds,
|
||||
score,
|
||||
winner: null,
|
||||
pendingRound: null,
|
||||
};
|
||||
}
|
||||
@@ -1,8 +1,6 @@
|
||||
// Erzeugt die Konsolenbefehle, mit denen ein laufender CS2-Server für eine Map der Serie konfiguriert wird.
|
||||
// Alle Werte werden so bereinigt, dass sie keine weiteren Befehle einschleusen können.
|
||||
|
||||
import { BACKUP_PATTERN } from '../rounds.js';
|
||||
|
||||
export function sanitizeConsoleText(value, maxLength = 32) {
|
||||
return String(value ?? '')
|
||||
.replace(/["';\\\r\n\t]/g, '')
|
||||
@@ -25,7 +23,7 @@ export function sanitizeConsoleText(value, maxLength = 32) {
|
||||
* @param {object} p.secrets { serverPassword, tvPassword }
|
||||
* @param {object} p.settings config.match
|
||||
*/
|
||||
export function buildMapCommands({ match, pool, seriesMap, secrets, settings, logUrl, backupPrefix }) {
|
||||
export function buildMapCommands({ match, pool, seriesMap, secrets, settings, logUrl }) {
|
||||
const isWingman = pool.mode === 'wingman';
|
||||
const ctTeam = seriesMap.ctTeam ?? 'A';
|
||||
const tTeam = ctTeam === 'A' ? 'B' : 'A';
|
||||
@@ -42,13 +40,6 @@ export function buildMapCommands({ match, pool, seriesMap, secrets, settings, lo
|
||||
...(logUrl && /^https?:\/\/[\w.:/-]+$/.test(logUrl)
|
||||
? ['log on', 'logaddress_delall_http', `logaddress_add_http "${logUrl}"`]
|
||||
: []),
|
||||
// Rundensicherung: CS2 speichert nach jeder Runde den Spielzustand, damit sich Runden zurückspielen lassen
|
||||
...(backupPrefix ? [
|
||||
`mp_backup_round_file "${backupPrefix}"`,
|
||||
`mp_backup_round_file_pattern "${BACKUP_PATTERN}"`,
|
||||
'mp_backup_round_auto 1',
|
||||
'mp_backup_restore_load_autopause 1',
|
||||
] : []),
|
||||
`changelevel ${seriesMap.map}`,
|
||||
];
|
||||
|
||||
|
||||
@@ -2,8 +2,6 @@
|
||||
// Er simuliert nur Startdauer und Konfiguration, damit der Ablauf ohne Hosting getestet werden kann.
|
||||
// Das Flag simulated=true sorgt dafür, dass das Frontend den Server ausdrücklich als Simulation kennzeichnet.
|
||||
|
||||
import { backupPrefix, parseBackupFiles } from '../rounds.js';
|
||||
|
||||
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
||||
|
||||
export class DemoServerAdapter {
|
||||
@@ -43,14 +41,6 @@ export class DemoServerAdapter {
|
||||
handle.map = plan.map;
|
||||
}
|
||||
|
||||
// Simulierte Sicherungen: eine Datei je Runde der aktuellen Map, damit die Oberfläche testbar ist
|
||||
async listRoundBackups(handle, matchId, map = 'de_demo') {
|
||||
const files = [1, 2, 3].map((r) => `${backupPrefix(matchId)}_01_01_${map}_round${r}_score_${r}_0.txt`);
|
||||
return parseBackupFiles(files.join('\n'), matchId);
|
||||
}
|
||||
|
||||
async loadRoundBackup() {}
|
||||
|
||||
async sendCommands(handle, commands) {
|
||||
return commands.map(() => '(Demo – nicht ausgeführt)');
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import { execFile } from 'node:child_process';
|
||||
import { promisify } from 'node:util';
|
||||
import { configureViaRcon, listRoundBackups, loadRoundBackup, rconStatus } from './rconConfigure.js';
|
||||
import { configureViaRcon, rconStatus } from './rconConfigure.js';
|
||||
import { runRcon } from './rcon.js';
|
||||
|
||||
const exec = promisify(execFile);
|
||||
@@ -112,8 +112,6 @@ export class DockerServerAdapter {
|
||||
CS2_GAMETYPE: '0',
|
||||
CS2_GAMEMODE: mode === 'wingman' ? '2' : '1',
|
||||
CS2_SERVER_HIBERNATE: '0',
|
||||
// Ohne diesen Startparameter legt CS2 keine Rundensicherungen an (Rollback)
|
||||
CS2_ADDITIONAL_ARGS: '-allow_round_backup_files',
|
||||
TV_ENABLE: '1',
|
||||
TV_PORT: String(tvPort),
|
||||
TV_PW: secrets.tvPassword,
|
||||
@@ -176,14 +174,6 @@ export class DockerServerAdapter {
|
||||
await configureViaRcon(this.target(handle), plan);
|
||||
}
|
||||
|
||||
async listRoundBackups(handle, matchId) {
|
||||
return listRoundBackups(this.target(handle), matchId);
|
||||
}
|
||||
|
||||
async loadRoundBackup(handle, file) {
|
||||
await loadRoundBackup(this.target(handle), file);
|
||||
}
|
||||
|
||||
async sendCommands(handle, commands) {
|
||||
return runRcon(this.target(handle), commands);
|
||||
}
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
import { parseBackupFiles } from '../rounds.js';
|
||||
import { parseStatus, runRcon } from './rcon.js';
|
||||
|
||||
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
||||
@@ -43,19 +42,3 @@ export async function rconStatus(target) {
|
||||
const [output] = await runRcon(target, ['status'], { timeoutMs: 4000 });
|
||||
return parseStatus(output);
|
||||
}
|
||||
|
||||
/** Sicherungsdateien dieses Matches vom Server holen. */
|
||||
export async function listRoundBackups(target, matchId) {
|
||||
const [out] = await runRcon(target, ['mp_backup_restore_list_files 60'], { timeoutMs: 8000, quietMs: 500 });
|
||||
return parseBackupFiles(out, matchId);
|
||||
}
|
||||
|
||||
/** Sicherung laden. Der Dateiname muss vorher mit isValidBackupFile geprüft sein. */
|
||||
export async function loadRoundBackup(target, file) {
|
||||
// mp_backup_restore_load_autopause wirkt in CS2 nicht zuverlässig, deshalb pausieren wir ausdrücklich
|
||||
await runRcon(target, [
|
||||
'mp_backup_restore_load_autopause 1',
|
||||
`mp_backup_restore_load_file "${file}"`,
|
||||
'mp_pause_match',
|
||||
], { timeoutMs: 15000, quietMs: 800 });
|
||||
}
|
||||
@@ -1,6 +1,5 @@
|
||||
import { buildMapCommands, sanitizeConsoleText } from './cs2Config.js';
|
||||
import { DemoMatchSimulator } from './demoMatchSimulator.js';
|
||||
import { backupPrefix, describeBackup, isValidBackupFile, pointsForMap } from '../rounds.js';
|
||||
import { HttpError, CLOSED_STATUSES } from '../matchService.js';
|
||||
import { randomPassword } from '../security.js';
|
||||
|
||||
@@ -87,43 +86,6 @@ export class ServerManager {
|
||||
this.timers.push(setInterval(() => this.reap().catch((e) => this.logger.error(e)), this.config.reaperIntervalSeconds * 1000));
|
||||
}
|
||||
|
||||
/** Admin: Rücksprungpunkte der aktuellen Map, neueste Runde zuerst. */
|
||||
async rollbackPoints(viewer) {
|
||||
this.service.require(viewer, 'organizer');
|
||||
const { match, seriesMap, handle } = this.rollbackContext(viewer.matchId);
|
||||
const all = await this.adapter.listRoundBackups(handle, match.id, seriesMap.map);
|
||||
return pointsForMap(all, seriesMap.map);
|
||||
}
|
||||
|
||||
/** Admin: Match auf den Stand nach einer Runde zurückspielen. */
|
||||
async rollback(viewer, file) {
|
||||
this.service.require(viewer, 'organizer');
|
||||
const { match, handle, seriesMap } = this.rollbackContext(viewer.matchId);
|
||||
if (!isValidBackupFile(file, match.id)) throw new HttpError(400, 'Ungültige Sicherungsdatei', 'invalid_input');
|
||||
const point = describeBackup(file, match.id);
|
||||
if (point.map !== seriesMap.map) throw new HttpError(409, 'Die Sicherung gehört zu einer anderen Map', 'wrong_map');
|
||||
if (this.busy.has(match.id)) throw new HttpError(409, 'Für diesen Server läuft bereits eine Aktion', 'busy');
|
||||
this.busy.add(match.id);
|
||||
try {
|
||||
await this.adapter.loadRoundBackup(handle, file);
|
||||
} catch (err) {
|
||||
throw new HttpError(502, `Zurückspielen fehlgeschlagen: ${err.message}`, 'server_error');
|
||||
} finally {
|
||||
this.busy.delete(match.id);
|
||||
}
|
||||
this.service.rewindLiveScore(match.id, point.round, file);
|
||||
}
|
||||
|
||||
rollbackContext(matchId) {
|
||||
const match = this.service.getMatch(matchId);
|
||||
const row = this.row(matchId);
|
||||
if (!row?.handle || row.status !== 'configured' || match.status !== 'live') {
|
||||
throw new HttpError(409, 'Zurückspielen ist nur bei einem laufenden Match mit bereitem Server möglich', 'wrong_state');
|
||||
}
|
||||
const seriesMap = this.service.seriesMaps(matchId).find((m) => m.number === match.current_map_number);
|
||||
return { match, row, seriesMap, handle: JSON.parse(row.handle) };
|
||||
}
|
||||
|
||||
/** Löscht ein Match samt Server-Datensatz. Ein laufender Server wird vorher freigegeben. */
|
||||
async deleteMatch(matchId) {
|
||||
this.service.getMatch(matchId);
|
||||
@@ -313,7 +275,6 @@ export class ServerManager {
|
||||
secrets: { serverPassword: row.server_password, tvPassword: row.tv_password },
|
||||
settings: this.config.match,
|
||||
logUrl: `${this.config.logReceiverUrl}/api/logs/${matchId}/${row.config_key}`,
|
||||
backupPrefix: backupPrefix(matchId),
|
||||
});
|
||||
this.simulator.stop(matchId);
|
||||
this.service.resetLiveScore(matchId, seriesMap.number);
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import { configureViaRcon, listRoundBackups, loadRoundBackup, rconStatus } from './rconConfigure.js';
|
||||
import { configureViaRcon, rconStatus } from './rconConfigure.js';
|
||||
import { runRcon } from './rcon.js';
|
||||
|
||||
/**
|
||||
@@ -45,14 +45,6 @@ export class StaticPoolServerAdapter {
|
||||
await configureViaRcon(this.target(handle), plan);
|
||||
}
|
||||
|
||||
async listRoundBackups(handle, matchId) {
|
||||
return listRoundBackups(this.target(handle), matchId);
|
||||
}
|
||||
|
||||
async loadRoundBackup(handle, file) {
|
||||
await loadRoundBackup(this.target(handle), file);
|
||||
}
|
||||
|
||||
async sendCommands(handle, commands) {
|
||||
return runRcon(this.target(handle), commands);
|
||||
}
|
||||
|
||||
@@ -107,9 +107,6 @@ test('kompletter Ablauf: Lobby, Berechtigungen, Veto, Server-Konfiguration', asy
|
||||
const orgView = (await call('GET', `/matches/${id}`, { token: org })).body;
|
||||
assert.equal(orgView.viewer.role, 'organizer');
|
||||
const { codes } = orgView.organizer;
|
||||
// Match-Übersicht nur für dieses Match, ohne Zuschauercode
|
||||
assert.match(orgView.organizer.links.overview, new RegExp(`/stream/match/${id}$`));
|
||||
assert.ok(!orgView.organizer.links.overview.includes(codes.spectator));
|
||||
|
||||
// Zuschauer- und fremde Codes erlauben keinen Teambeitritt
|
||||
assert.equal((await call('POST', `/matches/${id}/join`, { body: { code: codes.spectator, nickname: 'spy' } })).status, 403);
|
||||
@@ -415,40 +412,6 @@ test('Admin-Modus: Anmeldung, Verwaltung aller Matches, Sperre ohne Anmeldung',
|
||||
}
|
||||
});
|
||||
|
||||
test('Rollback: nur mit Admin-Anmeldung, nur für die laufende Map, Dateiname wird geprüft', async () => {
|
||||
const { app, call, close } = await setup({ adminPassword: 'Admin123', demo: { startSeconds: 0, failFirstConfigure: false, roundSeconds: 600 } });
|
||||
try {
|
||||
const { id, org, tokens } = await readyWingmanMatch(call, 'bo3');
|
||||
await call('POST', `/matches/${id}/veto/start`, { token: org });
|
||||
await playVeto(call, id, { A: tokens.a1, B: tokens.b1 });
|
||||
await app.manager.poll();
|
||||
await waitFor(() => app.service.getMatch(id).status === 'live', { label: 'live' });
|
||||
await call('POST', `/matches/${id}/server/warmup-end`, { token: org });
|
||||
|
||||
// Organisator sieht keine Rollback-Funktion
|
||||
assert.equal((await call('GET', `/admin/matches/${id}/rollback-points`, { token: org })).status, 401);
|
||||
assert.equal((await call('POST', `/matches/${id}/rollback`, { token: org, body: { file: 'x.txt' } })).status, 404);
|
||||
|
||||
const login = (await call('POST', '/admin/login', { body: { password: 'Admin123' } })).body;
|
||||
const admin = { token: login.token };
|
||||
const points = (await call('GET', `/admin/matches/${id}/rollback-points`, admin)).body.points;
|
||||
assert.equal(points.length, 3, 'Demo liefert drei Sicherungen der aktuellen Map');
|
||||
const map = app.service.seriesMaps(id)[0].map;
|
||||
assert.ok(points.every((p) => p.map === map));
|
||||
|
||||
// Dateien, die nicht zu diesem Match gehören, werden abgelehnt
|
||||
assert.equal((await call('POST', `/admin/matches/${id}/rollback`, { ...admin, body: { file: '../../x.txt' } })).status, 400);
|
||||
|
||||
const ok = await call('POST', `/admin/matches/${id}/rollback`, { ...admin, body: { file: points[0].file } });
|
||||
assert.equal(ok.status, 200);
|
||||
const log = app.service.db.prepare("SELECT message FROM events WHERE match_id = ? AND type = 'rollback'").all(id);
|
||||
assert.equal(log.length, 1);
|
||||
assert.match(log[0].message, /zurückgespielt/);
|
||||
} finally {
|
||||
await close();
|
||||
}
|
||||
});
|
||||
|
||||
test('Admin-Modus ohne ADMIN_PASSWORD ist komplett aus', async () => {
|
||||
const { call, close } = await setup({ adminPassword: '' });
|
||||
try {
|
||||
|
||||
@@ -37,7 +37,6 @@ test('Ohne GSLT startet der Container im LAN-Modus, mit GSLT mit Token', async (
|
||||
assert.equal(env.SRCDS_TOKEN, undefined);
|
||||
assert.equal(env.CS2_GAMEMODE, '2');
|
||||
assert.equal(env.CS2_MAXPLAYERS, '6', '4 Spieler + CSTV + Reserve');
|
||||
assert.equal(env.CS2_ADDITIONAL_ARGS, '-allow_round_backup_files', 'Rundensicherung für Rollback');
|
||||
assert.equal(env.CS2_PORT, '27100');
|
||||
assert.equal(env.TV_PORT, '27101');
|
||||
assert.ok(runArgs.includes('cs2-mapveto-gamefiles:/home/steam/cs2-dedicated'));
|
||||
|
||||
@@ -1,54 +0,0 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { backupPrefix, describeBackup, isValidBackupFile, parseBackupFiles, pointsForMap, trimLiveState } from '../src/rounds.js';
|
||||
|
||||
const id = 'Ab_9-xY';
|
||||
const file = (map, round, s1, s2) => `${backupPrefix(id)}_2026-10-25_18-30-00_${map}_round${round}_score_${s1}_${s2}.txt`;
|
||||
|
||||
test('Gültige Sicherungsdateien nur für dieses Match', () => {
|
||||
assert.equal(isValidBackupFile(file('de_inferno', 3, 2, 1), id), true);
|
||||
assert.equal(isValidBackupFile(file('de_inferno', 3, 2, 1), 'anderes'), false, 'fremdes Match');
|
||||
assert.equal(isValidBackupFile(`${backupPrefix(id)}_../../etc/passwd.txt`, id), false, 'Pfad');
|
||||
assert.equal(isValidBackupFile(`${backupPrefix(id)}_x;quit_round1_score_0_0.txt`, id), false, 'Befehl');
|
||||
assert.equal(isValidBackupFile(`${backupPrefix(id)}_de_inferno.txt`, id), false, 'ohne Runde');
|
||||
assert.equal(isValidBackupFile(undefined, id), false);
|
||||
});
|
||||
|
||||
test('Liste aus einer RCON-Antwort auslesen, fremde Dateien ignorieren', () => {
|
||||
const text = [
|
||||
'Backups:',
|
||||
file('de_inferno', 1, 1, 0),
|
||||
file('de_inferno', 2, 1, 1),
|
||||
'round_backup_fremd_2026_de_nuke_round4_score_3_1.txt',
|
||||
file('de_nuke', 1, 1, 0),
|
||||
].join('\n');
|
||||
const found = parseBackupFiles(text, id);
|
||||
assert.equal(found.length, 3);
|
||||
assert.deepEqual(found[0], { file: file('de_inferno', 1, 1, 0), map: 'de_inferno', round: 1, score: { s1: 1, s2: 0 } });
|
||||
});
|
||||
|
||||
test('Nur die Map der laufenden Serie, neueste Runde zuerst', () => {
|
||||
const all = parseBackupFiles([file('de_inferno', 1, 1, 0), file('de_inferno', 3, 2, 1), file('de_nuke', 2, 1, 1)].join('\n'), id);
|
||||
const points = pointsForMap(all, 'de_inferno');
|
||||
assert.deepEqual(points.map((p) => p.round), [3, 1]);
|
||||
});
|
||||
|
||||
test('Stand nach Rollback: Runden bis zur Sicherung, Punkte neu gerechnet', () => {
|
||||
const state = {
|
||||
map: 'de_inferno', status: 'live', warmupEnded: true, score: { A: 3, B: 2 }, winner: 'A', pendingRound: null,
|
||||
rounds: [
|
||||
{ number: 1, winner: 'A' }, { number: 2, winner: 'B' }, { number: 3, winner: 'A' },
|
||||
{ number: 4, winner: 'B' }, { number: 5, winner: 'A' },
|
||||
],
|
||||
};
|
||||
const back = trimLiveState(state, 3);
|
||||
assert.deepEqual(back.rounds.map((r) => r.number), [1, 2, 3]);
|
||||
assert.deepEqual(back.score, { A: 2, B: 1 });
|
||||
assert.equal(back.winner, null);
|
||||
assert.equal(back.status, 'live');
|
||||
assert.equal(back.warmupEnded, true, 'Zustand bleibt erhalten');
|
||||
});
|
||||
|
||||
test('Beschreibung eines Dateinamens', () => {
|
||||
assert.deepEqual(describeBackup('nichts.txt'), { file: 'nichts.txt', map: null, round: null, score: null });
|
||||
});
|
||||
Reference in new issue
Block a user