stream-doctor 0.0.3 → 0.0.5

package/README.md

@@ -0,0 +1,11 @@
+# stream-doctor
+
+Automated end-to-end testing for video infrastructure: publish a stream into
+your pipeline, watch what comes out the other end and assert on the metrics.
+An early proof of concept, currently a single RTMP to HLS scenario with a
+single metric, the audio/video drift.
+
+This is the TypeScript client for the StreamDoctor daemon. It brings the
+daemon binary along, as an optional dependency on `@stream-doctor/<platform>`.
+Setup, usage and the roadmap are described in the
+[StreamDoctor repository](https://github.com/membraneframework-labs/stream_doctor).

package/dist/stream_doctor.d.ts

@@ -1,12 +1,11 @@
 import { type ChildProcess } from "node:child_process";
-export declare function bundledBinary(): string | null;
 export type Status = "streaming" | "receiving" | "waiting_for_playlist" | "ended" | "failed" | "stopped";
 export interface StreamerStatus {
     input: string;
     rtmp_url: string;
     status: Status;
     error: string | null;
-    frames_sent: number;
+    live: boolean;
 }
 export interface AvDrift {
     drift_ms: number | null;
@@ -32,10 +31,12 @@ export declare function session({ server, binary, }?: {
     server?: string;
     binary?: string;
 }): Promise<Session>;
+export declare function bundledBinary(): string | null;
 declare class Session {
     server: string;
     child: ChildProcess | null;
-    constructor(server: string, child: ChildProcess | null);
+    logFile: string | null;
+    constructor(server: string, child: ChildProcess | null, logFile?: string | null);
     publish(rtmpUrl: string, { file }?: {
         file?: string;
     }): Streamer;

package/dist/stream_doctor.js

@@ -1,46 +1,15 @@
-// Client for the stream_doctor server. `session()` spawns the binary (the one
-// bundled for this platform, or `binary`) when no server is listening;
-// `session.close()` stops it.
 import { spawn } from "node:child_process";
 import fs from "node:fs";
 import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
 const DEFAULT_SERVER = "http://localhost:4040";
+const LOG_FILE = path.join(os.tmpdir(), "stream_doctor.log");
 const PLATFORM_PACKAGES = {
     "darwin-arm64": "@stream-doctor/darwin-arm64",
     "linux-arm64": "@stream-doctor/linux-arm64",
     "linux-x64": "@stream-doctor/linux-x64",
 };
-// The daemon ships as one package per platform, all optional dependencies of
-// this one, so only the matching one is installed.
-export function bundledBinary() {
-    const pkg = PLATFORM_PACKAGES[`${process.platform}-${process.arch}`];
-    if (!pkg)
-        return null;
-    try {
-        return createRequire(import.meta.url).resolve(`${pkg}/bin/stream_doctor`);
-    }
-    catch {
-        return null;
-    }
-}
-async function api(method, path, body, server) {
-    let res;
-    try {
-        res = await fetch(server + path, {
-            method,
-            headers: body ? { "content-type": "application/json" } : undefined,
-            body: body ? JSON.stringify(body) : undefined,
-        });
-    }
-    catch (e) {
-        throw new Error(`${method} ${path}: cannot reach ${server} (is the server running?): ${e.message}`);
-    }
-    const text = await res.text();
-    if (!res.ok)
-        throw new Error(`${method} ${path}: HTTP ${res.status}: ${text}`);
-    return JSON.parse(text);
-}
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const TERMINAL_STATUSES = ["ended", "failed", "stopped"];
 export async function session({ server = DEFAULT_SERVER, binary, } = {}) {
     try {
@@ -48,38 +17,37 @@ export async function session({ server = DEFAULT_SERVER, binary, } = {}) {
         return new Session(server, null);
     }
     catch (e) {
-        binary ??= bundledBinary() ?? undefined;
+        let installDir;
         if (!binary) {
-            throw new Error(`${e.message}; no stream_doctor binary bundled for ${process.platform}-${process.arch}, pass one with \`binary\``);
+            binary = bundledBinary() ?? undefined;
+            if (!binary) {
+                throw new Error(`${e.message}; no stream_doctor binary bundled for ${process.platform}-${process.arch}, pass one with \`binary\``);
+            }
+            installDir = path.join(path.dirname(binary), "..", ".burrito");
         }
+        const child = await spawnServer(binary, server, installDir);
+        return new Session(server, child, LOG_FILE);
     }
-    return new Session(server, await spawnServer(binary, server));
 }
-async function spawnServer(binary, server) {
-    if (!fs.existsSync(binary)) {
-        throw new Error(`${binary} not found, build it with: MIX_ENV=prod mix release`);
+export function bundledBinary() {
+    const pkg = PLATFORM_PACKAGES[`${process.platform}-${process.arch}`];
+    if (!pkg)
+        return null;
+    try {
+        return createRequire(import.meta.url).resolve(`${pkg}/bin/stream_doctor`);
     }
-    console.log(`starting ${binary}`);
-    // own process group, so that killing the burrito launcher takes the BEAM with it
-    const child = spawn(binary, [], { stdio: ["ignore", "inherit", "inherit"], detached: true });
-    for (const deadline = Date.now() + 120_000; Date.now() < deadline;) {
-        if (child.exitCode !== null)
-            throw new Error(`server exited with ${child.exitCode}`);
-        await sleep(1000);
-        try {
-            await api("GET", "/status", null, server);
-            return child;
-        }
-        catch { }
+    catch {
+        return null;
     }
-    throw new Error("server didn't come up in 2 minutes");
 }
 class Session {
     server;
     child;
-    constructor(server, child) {
+    logFile;
+    constructor(server, child, logFile = null) {
         this.server = server;
         this.child = child;
+        this.logFile = logFile;
     }
     publish(rtmpUrl, { file = "test.mp4" } = {}) {
         const ready = api("POST", "/streamer", { input: file, rtmp_url: rtmpUrl }, this.server);
@@ -120,7 +88,7 @@ class Streamer {
         const deadline = Date.now() + timeoutMs;
         for (;;) {
             const streamer = await api("GET", "/streamer", null, this.server);
-            if (streamer.frames_sent > 0)
+            if (streamer.live)
                 return streamer;
             if (TERMINAL_STATUSES.includes(streamer.status)) {
                 throw new Error(`streamer ${streamer.status} before going live${streamer.error ? `: ${streamer.error}` : ""}`);
@@ -163,3 +131,46 @@ class Viewer {
         return metrics;
     }
 }
+async function spawnServer(binary, server, installDir) {
+    if (!fs.existsSync(binary)) {
+        throw new Error(`${binary} not found, build it with: MIX_ENV=prod mix release`);
+    }
+    const env = {
+        ...process.env,
+        STREAM_DOCTOR_EXIT_ON_STDIN_EOF: "1",
+        ...(installDir ? { STREAM_DOCTOR_INSTALL_DIR: installDir } : {}),
+    };
+    const log = fs.openSync(LOG_FILE, "a");
+    const child = spawn(binary, [], { stdio: ["pipe", log, log], detached: true, env });
+    child.on("exit", () => fs.closeSync(log));
+    for (const deadline = Date.now() + 120_000; Date.now() < deadline;) {
+        if (child.exitCode !== null) {
+            throw new Error(`server exited with ${child.exitCode}, see ${LOG_FILE}`);
+        }
+        await sleep(1000);
+        try {
+            await api("GET", "/status", null, server);
+            return child;
+        }
+        catch { }
+    }
+    throw new Error(`server didn't come up in 2 minutes, see ${LOG_FILE}`);
+}
+async function api(method, path, body, server) {
+    let res;
+    try {
+        res = await fetch(server + path, {
+            method,
+            headers: body ? { "content-type": "application/json" } : undefined,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+    }
+    catch (e) {
+        throw new Error(`${method} ${path}: cannot reach ${server} (is the server running?): ${e.message}`);
+    }
+    const text = await res.text();
+    if (!res.ok)
+        throw new Error(`${method} ${path}: HTTP ${res.status}: ${text}`);
+    return JSON.parse(text);
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "stream-doctor",
-  "version": "0.0.3",
-  "description": "Measures the audio/video drift of a live stream, end to end",
+  "version": "0.0.5",
+  "description": "Automated end-to-end testing for video infrastructure (early proof of concept)",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -20,8 +20,8 @@
     "build": "tsc -p tsconfig.build.json",
     "prepack": "npm run build",
     "test": "node --test src/*.test.ts",
-    "lint": "tsc --noEmit && eslint src examples && prettier --check src examples",
-    "format": "prettier --write src examples"
+    "lint": "tsc --noEmit && eslint src && prettier --check src",
+    "format": "prettier --write src"
   },
   "devDependencies": {
     "@eslint/js": "^9.0.0",
@@ -33,8 +33,8 @@
     "typescript-eslint": "^8.70.0"
   },
   "optionalDependencies": {
-    "@stream-doctor/darwin-arm64": "0.0.3",
-    "@stream-doctor/linux-arm64": "0.0.3",
-    "@stream-doctor/linux-x64": "0.0.3"
+    "@stream-doctor/darwin-arm64": "0.0.5",
+    "@stream-doctor/linux-arm64": "0.0.5",
+    "@stream-doctor/linux-x64": "0.0.5"
   }
 }