404 lines
19 KiB
JavaScript
404 lines
19 KiB
JavaScript
const assert = require("assert");
|
|
const crypto = require("crypto");
|
|
const fs = require("fs");
|
|
const os = require("os");
|
|
const path = require("path");
|
|
const { EventEmitter } = require("events");
|
|
const { spawn } = require("child_process");
|
|
const AdmZip = require("adm-zip");
|
|
|
|
const root = path.join(__dirname, "..");
|
|
const {
|
|
ArtifactManager,
|
|
safeArchivePath,
|
|
validateManifestEntry
|
|
} = require("../src/services/artifact-manager");
|
|
const {
|
|
MediaMtxRuntime,
|
|
parseMetrics,
|
|
readResponseText,
|
|
renderConfig,
|
|
sha256Credential,
|
|
validateHlsAsset
|
|
} = require("../src/services/mediamtx-runtime");
|
|
const {
|
|
StreamTestingService,
|
|
INACTIVITY_MS,
|
|
isPrivateAddress,
|
|
resolveIngestConfiguration,
|
|
rewriteManifest,
|
|
sourceFor,
|
|
validateHostname
|
|
} = require("../src/services/stream-testing");
|
|
const protocol = require("../plugins/lumi_transcription/backend/companion/protocol");
|
|
|
|
class FakeRuntime extends EventEmitter {
|
|
constructor() {
|
|
super();
|
|
this.session = null;
|
|
this.running = false;
|
|
this.cleared = 0;
|
|
this.pathReady = true;
|
|
this.inboundBytes = 4096;
|
|
}
|
|
status() {
|
|
return {
|
|
available: true,
|
|
installed: true,
|
|
valid: true,
|
|
version: "v1.18.2",
|
|
tested_version: "v1.18.2",
|
|
source: "managed by Lumi",
|
|
managed_install_supported: true,
|
|
detail: "MediaMTX v1.18.2 is ready.",
|
|
process: { state: this.running ? "ready" : "stopped", running: this.running, restart_count: 0, log_tail: "" }
|
|
};
|
|
}
|
|
async configureSession(session) { this.session = session; this.running = true; }
|
|
async clearSession() { this.session = null; this.cleared += 1; }
|
|
async diagnostics(sessionPath) {
|
|
return {
|
|
path: { name: sessionPath, ready: this.pathReady, tracks: ["H264", "MPEG4Audio"], bytes_received: this.inboundBytes, bytes_sent: 2048, readers: 1 },
|
|
metrics: { paths_inbound_bytes: this.inboundBytes, paths_outbound_bytes: 2048, hls_sessions: 1 },
|
|
process: { state: "ready", running: true }
|
|
};
|
|
}
|
|
async install() { return this.status(); }
|
|
async repair() { return this.status(); }
|
|
async healthCheck() { return { ok: true, version: "v1.18.2", api_status: 200, metrics_status: 200, hls_status: 404 }; }
|
|
async close() { this.running = false; }
|
|
}
|
|
|
|
async function verifyArtifactManager(tempRoot) {
|
|
assert.throws(() => validateManifestEntry({ id: "bad", url: "http://example.invalid/a.zip", sha256: "0".repeat(64) }), /invalid/);
|
|
assert.throws(() => safeArchivePath("../escape.exe"), /unsafe path/);
|
|
const zip = new AdmZip();
|
|
zip.addFile("LICENSE", Buffer.from("MIT"));
|
|
zip.addFile("mediamtx.exe", Buffer.from("fake executable"));
|
|
zip.addFile("mediamtx.yml", Buffer.from("paths: {}"));
|
|
const archive = zip.toBuffer();
|
|
const entry = {
|
|
id: "fake-mediamtx",
|
|
install_id: "mediamtx",
|
|
backend: "mediamtx",
|
|
version: "v1.18.2",
|
|
url: "https://example.invalid/mediamtx.zip",
|
|
filename: "mediamtx.zip",
|
|
sha256: crypto.createHash("sha256").update(archive).digest("hex"),
|
|
bytes: archive.length,
|
|
max_bytes: archive.length + 1,
|
|
max_extracted_bytes: 1024,
|
|
expected_entries: ["LICENSE", "mediamtx.exe", "mediamtx.yml"]
|
|
};
|
|
const manager = new ArtifactManager(path.join(tempRoot, "artifacts"), {
|
|
fetch: async () => new Response(archive, {
|
|
status: 200,
|
|
headers: { "Content-Length": String(archive.length) }
|
|
})
|
|
});
|
|
await assert.rejects(() => manager.download(entry), /explicit setup confirmation/);
|
|
const downloaded = await manager.download(entry, { confirmed: true });
|
|
assert(downloaded.valid, "downloaded artifact must match its pinned SHA-256");
|
|
const installed = manager.installZip(entry, downloaded.path, {
|
|
verify: (staged) => assert(fs.existsSync(path.join(staged, "mediamtx.exe")))
|
|
});
|
|
assert(fs.existsSync(path.join(installed.path, "mediamtx.exe")), "validated archive must install atomically");
|
|
const originalExecutable = fs.readFileSync(path.join(installed.path, "mediamtx.exe"), "utf8");
|
|
const replacementZip = new AdmZip();
|
|
replacementZip.addFile("LICENSE", Buffer.from("MIT replacement"));
|
|
replacementZip.addFile("mediamtx.exe", Buffer.from("broken replacement"));
|
|
replacementZip.addFile("mediamtx.yml", Buffer.from("paths: {}"));
|
|
const replacementArchive = replacementZip.toBuffer();
|
|
const replacementPath = path.join(tempRoot, "replacement.zip");
|
|
fs.writeFileSync(replacementPath, replacementArchive);
|
|
const replacementEntry = {
|
|
...entry,
|
|
sha256: crypto.createHash("sha256").update(replacementArchive).digest("hex"),
|
|
bytes: replacementArchive.length
|
|
};
|
|
assert.throws(
|
|
() => manager.installZip(replacementEntry, replacementPath, {
|
|
verifyInstalled: () => { throw new Error("replacement probe failed"); }
|
|
}),
|
|
/replacement probe failed/
|
|
);
|
|
assert.equal(
|
|
fs.readFileSync(path.join(installed.path, "mediamtx.exe"), "utf8"),
|
|
originalExecutable,
|
|
"a failed post-install probe must restore the last known-good runtime"
|
|
);
|
|
assert.throws(
|
|
() => manager.installZip({ ...entry, sha256: "0".repeat(64) }, downloaded.path),
|
|
/Checksum mismatch/
|
|
);
|
|
}
|
|
|
|
async function verifyManagedRuntime(tempRoot) {
|
|
const runtimeRoot = path.join(tempRoot, "runtime");
|
|
const executable = path.join(runtimeRoot, "mediamtx", "mediamtx.exe");
|
|
fs.mkdirSync(path.dirname(executable), { recursive: true });
|
|
fs.writeFileSync(executable, "fake");
|
|
const fixture = path.join(root, "scripts", "fixtures", "fake-mediamtx.js");
|
|
const runtime = new MediaMtxRuntime({
|
|
runtimeRoot,
|
|
configRoot: path.join(tempRoot, "config"),
|
|
platform: "win32",
|
|
arch: "x64",
|
|
spawn: (_executable, args, options) => spawn(process.execPath, [fixture, args[0]], options),
|
|
spawnSync: () => ({ status: 0, stdout: "v1.18.2\n", stderr: "" })
|
|
});
|
|
await assert.rejects(() => runtime.install(), /administrator confirmation/);
|
|
await assert.rejects(() => runtime.repair(), /administrator confirmation/);
|
|
assert.equal(runtime.probeExecutable(executable).version, "v1.18.2", "manual executable probes must remain bounded and versioned");
|
|
const health = await runtime.healthCheck();
|
|
assert(health.ok && health.restart_verified && health.api_status === 200 && health.metrics_status === 200, "fake MediaMTX listeners and supervised restart must pass the runtime health check");
|
|
const session = {
|
|
path: "lumi-test/00000000-0000-4000-8000-000000000001",
|
|
username: "private-user",
|
|
password: "private-password",
|
|
transport: "rtmp",
|
|
ingestPort: 29350
|
|
};
|
|
await runtime.configureSession(session);
|
|
const generated = fs.readFileSync(runtime.configPath, "utf8");
|
|
assert(!generated.includes(session.username) && !generated.includes(session.password), "generated MediaMTX config must not persist plaintext publisher credentials");
|
|
assert(generated.includes(sha256Credential(session.username)) && generated.includes(sha256Credential(session.password)));
|
|
assert.match(generated, /rtsp: false/);
|
|
assert.match(generated, /webrtc: false/);
|
|
assert.match(generated, /srt: false/);
|
|
assert.match(generated, /hlsVariant: lowLatency/);
|
|
assert.match(generated, /maxReaders: 4/);
|
|
assert.match(generated, /rtmpAddress: "127\.0\.0\.1:29350"/);
|
|
const diagnostic = await runtime.diagnostics(session.path);
|
|
assert.equal(diagnostic.path.name, session.path);
|
|
const playlist = await runtime.fetchHls(session.path, "index.m3u8");
|
|
assert.equal(playlist.status, 200);
|
|
assert.match(await playlist.text(), /segment0\.mp4/);
|
|
assert.throws(() => validateHlsAsset("../secret"), /Invalid media path/);
|
|
await runtime.clearSession();
|
|
const denyConfig = fs.readFileSync(runtime.configPath, "utf8");
|
|
assert.match(denyConfig, /paths: \{\}/);
|
|
assert(!denyConfig.includes("private-user"));
|
|
await runtime.close();
|
|
}
|
|
|
|
async function verifyStreamService() {
|
|
const old = {
|
|
host: process.env.LUMI_STREAM_TEST_INGEST_HOST,
|
|
transport: process.env.LUMI_STREAM_TEST_TRANSPORT,
|
|
insecure: process.env.LUMI_STREAM_TEST_ALLOW_INSECURE_REMOTE
|
|
};
|
|
delete process.env.LUMI_STREAM_TEST_INGEST_HOST;
|
|
process.env.LUMI_STREAM_TEST_TRANSPORT = "rtmp";
|
|
delete process.env.LUMI_STREAM_TEST_ALLOW_INSECURE_REMOTE;
|
|
const runtime = new FakeRuntime();
|
|
const service = new StreamTestingService({ runtime, timer: false });
|
|
const sent = [];
|
|
try {
|
|
const created = await service.create(
|
|
{ id: "device-1", name: "Studio PC", pairing_host: "http://localhost:3000" },
|
|
{ source: { width: 2560, height: 1440, fps: 60 } },
|
|
(type, payload) => sent.push({ type, payload })
|
|
);
|
|
assert.match(created.ingest.server, /^rtmp:\/\/localhost:19350\/lumi-test$/);
|
|
assert.match(created.ingest.key, /^[0-9a-f-]{36}\?user=/);
|
|
assert.equal(created.source.variants.length, 1, "MediaMTX handoff must preserve source quality without a synthetic ladder");
|
|
assert.equal(runtime.session.path, `lumi-test/${created.id}`);
|
|
assert(runtime.session.username && runtime.session.password);
|
|
assert.equal(runtime.session.bindHost, "127.0.0.1", "LAN-only RTMP must bind to the resolved private interface");
|
|
await assert.rejects(
|
|
() => service.create({ id: "device-2", pairing_host: "http://localhost:3000" }, {}),
|
|
(error) => error.code === "STREAM_TEST_ACTIVE"
|
|
);
|
|
await service.sweep();
|
|
const status = service.publicStatus();
|
|
assert.equal(status.session.state, "receiving");
|
|
assert.equal(status.session.metrics.receiver.path_ready, true);
|
|
assert(Object.hasOwn(status.receiver.process, "log_tail"), "admin diagnostics must include a bounded sanitized MediaMTX log tail");
|
|
assert(!JSON.stringify(status).includes("127.0.0.1:"), "browser status must not expose loopback MediaMTX origins");
|
|
service.updateObs("device-1", {
|
|
session_id: created.id,
|
|
bitrate_kbps: 6000,
|
|
dropped_frames: 2,
|
|
total_frames: 10000,
|
|
congestion: 0
|
|
});
|
|
service.addCaption("device-1", { session_id: created.id, text: "Private caption", delay_ms: 120 });
|
|
assert.throws(
|
|
() => service.addCaption("device-2", { session_id: created.id, text: "Wrong device" }),
|
|
/not active for this Companion/
|
|
);
|
|
service.reportPlayer({ session_id: created.id, latency_seconds: 1.2, buffer_seconds: 1.5, stalls: 0, errors: 0 });
|
|
assert.match(service.captionFile(created.id), /Private caption/);
|
|
const endedSession = service.active;
|
|
await service.stop({ session_id: created.id, reason: "Verification complete." });
|
|
assert.equal(runtime.cleared, 1);
|
|
assert.equal(endedSession.username, null);
|
|
assert.equal(endedSession.password, null);
|
|
assert.equal(sent.at(-1).type, "stream_test_ended");
|
|
await assert.rejects(
|
|
() => service.create({ id: "device-1", pairing_host: "http://localhost:3000" }, {}),
|
|
(error) => error.code === "STREAM_TEST_RATE_LIMIT"
|
|
);
|
|
|
|
const expiring = await service.create(
|
|
{ id: "device-2", pairing_host: "http://localhost:3000" },
|
|
{}
|
|
);
|
|
service.active.expiresAt = Date.now() - 1;
|
|
await service.sweep();
|
|
assert.equal(service.active, null, "session expiry must revoke the MediaMTX path and end the session");
|
|
|
|
const inactive = await service.create(
|
|
{ id: "device-3", pairing_host: "http://localhost:3000" },
|
|
{}
|
|
);
|
|
service.active.lastInboundBytes = runtime.inboundBytes;
|
|
service.active.lastMediaAt = Date.now() - INACTIVITY_MS - 1;
|
|
await service.sweep();
|
|
assert.equal(service.active, null, "stalled inbound bytes must trigger the inactivity recovery path");
|
|
|
|
const failed = await service.create(
|
|
{ id: "device-4", pairing_host: "http://localhost:3000" },
|
|
{}
|
|
);
|
|
runtime.emit("failed", new Error("fixture process exited"));
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
assert.equal(service.active, null, "an unexpected MediaMTX exit must end the session and request OBS recovery");
|
|
assert([created.id, expiring.id, inactive.id, failed.id].every(Boolean));
|
|
} finally {
|
|
await service.close();
|
|
if (old.host === undefined) delete process.env.LUMI_STREAM_TEST_INGEST_HOST; else process.env.LUMI_STREAM_TEST_INGEST_HOST = old.host;
|
|
if (old.transport === undefined) delete process.env.LUMI_STREAM_TEST_TRANSPORT; else process.env.LUMI_STREAM_TEST_TRANSPORT = old.transport;
|
|
if (old.insecure === undefined) delete process.env.LUMI_STREAM_TEST_ALLOW_INSECURE_REMOTE; else process.env.LUMI_STREAM_TEST_ALLOW_INSECURE_REMOTE = old.insecure;
|
|
}
|
|
}
|
|
|
|
async function main() {
|
|
const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "lumi-stream-testing-"));
|
|
try {
|
|
assert.equal(validateHostname("stream.example.com"), "stream.example.com");
|
|
assert.equal(validateHostname("https://stream.example.com"), "");
|
|
assert.equal(validateHostname("[::1]"), "[::1]");
|
|
assert(isPrivateAddress("127.0.0.1") && isPrivateAddress("192.168.1.20") && !isPrivateAddress("8.8.8.8"));
|
|
assert.deepStrictEqual(sourceFor({ width: 1920, height: 1080, fps: 60 }).variants.map((item) => item.name), ["source"]);
|
|
assert.match(rewriteManifest(
|
|
"#EXTM3U\n#EXT-X-MAP:URI=\"init.mp4\"\nsegment0.mp4\n",
|
|
"/admin/stream-testing/media/test/",
|
|
"lumi-test/test"
|
|
), /URI="\/admin\/stream-testing\/media\/test\/init\.mp4"[\s\S]*\/admin\/stream-testing\/media\/test\/segment0\.mp4/);
|
|
assert.throws(() => rewriteManifest("../secret", "/proxy/", "lumi-test/test"), /unsafe playlist URI/);
|
|
assert.throws(() => rewriteManifest("https://foreign.invalid/segment.mp4", "/proxy/", "lumi-test/test"), /foreign playlist URI/);
|
|
assert.deepStrictEqual(
|
|
parseMetrics('paths_inbound_bytes{name="lumi-test/id"} 42\nunapproved_metric 9000\n', "lumi-test/id"),
|
|
{ paths_inbound_bytes: 42 }
|
|
);
|
|
await assert.rejects(
|
|
() => readResponseText(new Response("x".repeat(32), { headers: { "Content-Length": "32" } }), 16),
|
|
/oversized diagnostic response/
|
|
);
|
|
const config = renderConfig({
|
|
apiPort: 10001,
|
|
metricsPort: 10002,
|
|
hlsPort: 10003,
|
|
session: { path: "lumi-test/id", username: "user", password: "pass", transport: "rtmp", ingestPort: 19350 }
|
|
});
|
|
assert(!config.includes('\n pass: "pass"') && config.includes("sha256:"));
|
|
assert(!config.includes("ffmpeg"));
|
|
assert.match(config, /record: false/);
|
|
assert.match(config, /maxReaders: 4/);
|
|
assert.match(config, /paths:\n "lumi-test\/id":/);
|
|
assert(!/action: publish[\s\S]*path: all/.test(config));
|
|
|
|
const oldNetwork = {
|
|
host: process.env.LUMI_STREAM_TEST_INGEST_HOST,
|
|
transport: process.env.LUMI_STREAM_TEST_TRANSPORT,
|
|
cert: process.env.LUMI_STREAM_TEST_TLS_CERT,
|
|
key: process.env.LUMI_STREAM_TEST_TLS_KEY,
|
|
insecure: process.env.LUMI_STREAM_TEST_ALLOW_INSECURE_REMOTE
|
|
};
|
|
try {
|
|
delete process.env.LUMI_STREAM_TEST_INGEST_HOST;
|
|
process.env.LUMI_STREAM_TEST_TRANSPORT = "rtmp";
|
|
delete process.env.LUMI_STREAM_TEST_ALLOW_INSECURE_REMOTE;
|
|
await assert.rejects(
|
|
() => resolveIngestConfiguration({ pairing_host: "https://8.8.8.8" }),
|
|
(error) => error.code === "STREAM_TEST_INSECURE_REMOTE"
|
|
);
|
|
const cert = path.join(tempRoot, "cert.pem");
|
|
const key = path.join(tempRoot, "key.pem");
|
|
fs.writeFileSync(cert, "test certificate");
|
|
fs.writeFileSync(key, "test key");
|
|
process.env.LUMI_STREAM_TEST_TRANSPORT = "rtmps";
|
|
process.env.LUMI_STREAM_TEST_TLS_CERT = cert;
|
|
process.env.LUMI_STREAM_TEST_TLS_KEY = key;
|
|
const secure = await resolveIngestConfiguration({ pairing_host: "https://lumi.example.test" });
|
|
assert.equal(secure.transport, "rtmps");
|
|
assert.equal(secure.host, "lumi.example.test");
|
|
} finally {
|
|
for (const [key, value] of Object.entries({
|
|
LUMI_STREAM_TEST_INGEST_HOST: oldNetwork.host,
|
|
LUMI_STREAM_TEST_TRANSPORT: oldNetwork.transport,
|
|
LUMI_STREAM_TEST_TLS_CERT: oldNetwork.cert,
|
|
LUMI_STREAM_TEST_TLS_KEY: oldNetwork.key,
|
|
LUMI_STREAM_TEST_ALLOW_INSECURE_REMOTE: oldNetwork.insecure
|
|
})) {
|
|
if (value === undefined) delete process.env[key]; else process.env[key] = value;
|
|
}
|
|
}
|
|
|
|
for (const type of ["stream_test_create", "stream_test_obs_metrics", "stream_test_caption", "stream_test_stop"]) {
|
|
const parsed = protocol.parseEnvelope(Buffer.from(JSON.stringify(protocol.envelope(type, {}, null))));
|
|
assert.strictEqual(parsed.type, type);
|
|
}
|
|
|
|
await verifyArtifactManager(tempRoot);
|
|
await verifyManagedRuntime(tempRoot);
|
|
await verifyStreamService();
|
|
|
|
const server = fs.readFileSync(path.join(root, "src/web/server.js"), "utf8");
|
|
const service = fs.readFileSync(path.join(root, "src/services/stream-testing.js"), "utf8");
|
|
const runtime = fs.readFileSync(path.join(root, "src/services/mediamtx-runtime.js"), "utf8");
|
|
const gateway = fs.readFileSync(path.join(root, "plugins/lumi_transcription/backend/companion/gateway.js"), "utf8");
|
|
const nativeBridge = fs.readFileSync(path.join(root, "companion/native/obs-bridge/src/plugin.cpp"), "utf8");
|
|
const companion = fs.readFileSync(path.join(root, "companion/src/Lumi.Companion.App/CompanionRuntime.cs"), "utf8");
|
|
const webUi = fs.readFileSync(path.join(root, "src/web/views/admin-stream-testing.ejs"), "utf8");
|
|
assert.match(server, /admin\/stream-testing\/runtime\/install/);
|
|
assert.match(server, /admin\/stream-testing\/media\/:id\/\*/);
|
|
assert.match(server, /admin\/stream-testing\/media\/:id\/\*[\s\S]{0,500}requireRole\("admin"\)/);
|
|
assert.match(server, /streamTestingService\.proxyMedia/);
|
|
assert.match(service, /INACTIVITY_MS/);
|
|
assert.match(service, /caption_delay/);
|
|
assert.match(service, /LUMI_STREAM_TEST_ALLOW_INSECURE_REMOTE/);
|
|
assert(!/FFMPEG|ffmpegArgs|h264_nvenc|libx264/.test(service));
|
|
assert(!/shell:\s*true/.test(runtime));
|
|
assert.match(gateway, /await service\.create/);
|
|
assert.match(gateway, /Companion disconnected; the private receiver was stopped/);
|
|
assert.match(nativeBridge, /stream_test_snapshot/);
|
|
assert.match(nativeBridge, /stream_test_restore/);
|
|
assert.match(nativeBridge, /obs_process_id/);
|
|
assert.match(nativeBridge, /obs_output_start\(output\)/);
|
|
assert(!nativeBridge.includes("obs_frontend_streaming_start();"));
|
|
assert(!nativeBridge.includes("obs_encoder_release(encoder);"));
|
|
assert.match(companion, /StreamTestRecoveryStore/);
|
|
assert.match(companion, /RestoreObsAfterStreamTestAsync/);
|
|
assert.match(companion, /StreamTestObsRestartRequired/);
|
|
assert.match(companion, /LastObsProcessId/);
|
|
assert.match(companion, /Restart OBS before trying again/);
|
|
assert.match(webUi, /data-runtime-install/);
|
|
assert.match(webUi, /data-runtime-health/);
|
|
assert.match(webUi, /layout-bottom[\s\S]*admin\/stream-testing\/hls\.js[\s\S]*stream-testing\.js/);
|
|
assert(!webUi.includes("Run test pattern"));
|
|
} finally {
|
|
fs.rmSync(tempRoot, { recursive: true, force: true });
|
|
const { streamTestingService } = require("../src/services/stream-testing");
|
|
await streamTestingService.close();
|
|
}
|
|
console.log("Managed MediaMTX Stream Testing verification passed.");
|
|
}
|
|
|
|
main().catch((error) => {
|
|
console.error(error);
|
|
process.exitCode = 1;
|
|
});
|