nixamp 0.7.35 → 0.7.36

package/dist/audio.js

@@ -190,7 +190,9 @@ export class Stream {
             this.output.stdin?.on("error", () => { });
         }
         let stderr = "";
-        this.decoder.stderr?.on("data", (c) => { stderr += c.toString(); });
+        // The tail only: what went wrong is on the last line, and a film with a
+        // damaged audio track can say so once a frame for two hours.
+        this.decoder.stderr?.on("data", (c) => { stderr = (stderr + c.toString()).slice(-2000); });
         this.decoder.stdout?.on("data", (chunk) => {
             if (this.stopped || generation !== this.generation)
                 return;

package/dist/channels.d.ts

@@ -23,11 +23,23 @@ export interface ChannelInfo {
     kind?: "audio" | "video";
     /** For a channel we pull ourselves: where from. Never shown to a listener. */
     source?: string;
+    /** The last thing ffmpeg complained about, for whoever administers this. */
+    error?: string;
+    /** How many times the source has been dialled again since it started. */
+    redials?: number;
 }
 /** How long to wait before dialling a dropped source again. */
 export declare const REDIAL = 2000;
 /** How many times in a row a source may fail without ever sending anything. */
 export declare const GIVE_UP = 5;
+/**
+ * How long a pulled source may say nothing before it is treated as gone.
+ *
+ * ffmpeg's own reconnect covers a connection that errors. It does not cover
+ * one that simply stops sending, and neither does anything else: a television
+ * channel that is quiet for half a minute is not being quiet, it is dead.
+ */
+export declare const STALL = 30000;
 /** A name that can sit in a URL and be read back in a list. */
 export declare function cleanId(value: unknown, fallback?: string): string;
 export interface ChannelOptions {
@@ -54,6 +66,10 @@ export declare class Channel {
     private redial;
     private failures;
     private timer;
+    /** Fires when a pulled source has said nothing for STALL. */
+    private watchdog;
+    private stall;
+    private stderr;
     constructor(info: ChannelInfo, options: ChannelOptions, onGone: (id: string) => void);
     start(format: string): void;
     /**
@@ -69,7 +85,33 @@ export declare class Channel {
      * because you looked away, and a room where the picture depends on who is
      * in it is not a room anybody can be invited to.
      */
-    pull(source: string, encode: string[], paced?: boolean): void;
+    pull(source: string, encode: string[], paced?: boolean, stall?: number): void;
+    /**
+     * Start the source over, now.
+     *
+     * For a pulled channel only: a publisher's stream cannot be dialled again
+     * from this end. The current ffmpeg is killed and a new one started at
+     * once, with the count of failures cleared -- somebody asking for this has
+     * decided the thing is worth another go, and should not inherit the four
+     * strikes a dead CDN ran up an hour ago.
+     */
+    restart(): boolean;
+    /**
+     * The stream that was is over; the next ffmpeg is a new one.
+     *
+     * New opening boxes, timestamps from zero again. Whoever was listening
+     * cannot follow that mid-picture, and a newcomer must not be handed the old
+     * opening boxes in front of the new fragments -- so the header is dropped
+     * and the audience is ended, to come back to the stream as it now is. The
+     * player rejoins on its own. Done the moment the source is known to be
+     * gone, not when the redial happens: somebody joining in between gets the
+     * new beginning as it is written, rather than a stale one first.
+     */
+    private startOver;
+    /** Expect output within STALL, or treat the source as gone and dial again. */
+    private rearm;
+    /** End everybody listening; the stream they were on is over. */
+    private hangUp;
     /**
      * A source that stopped. Try it again, unless it never worked at all.
      *
@@ -130,7 +172,15 @@ export declare class Channels {
      * about it is the same too, which is the point -- a re-stream stops being a
      * special case and becomes one more thing that is on.
      */
-    pull(id: string, name: string, source: string, encode: string[], kind: "audio" | "video", paced?: boolean): Channel | null;
+    pull(id: string, name: string, source: string, encode: string[], kind: "audio" | "video", paced?: boolean, stall?: number): Channel | null;
+    /**
+     * Dial a pulled channel's source again, now. False for a channel that is
+     * not there or is not ours to dial: a publisher's stream restarts at the
+     * publisher's end.
+     */
+    restart(id: string): boolean;
+    /** Whether a channel is one we fetch ourselves, and so can start over. */
+    pulled(id: string): boolean;
     /** What a listener should be told this channel is. */
     contentType(id: string): string;
     /** Attach a listener, or null when nothing is playing on that channel. */

package/dist/channels.js

@@ -21,6 +21,40 @@ import { Fragments } from "./fragments.js";
 export const REDIAL = 2000;
 /** How many times in a row a source may fail without ever sending anything. */
 export const GIVE_UP = 5;
+/**
+ * How long a pulled source may say nothing before it is treated as gone.
+ *
+ * ffmpeg's own reconnect covers a connection that errors. It does not cover
+ * one that simply stops sending, and neither does anything else: a television
+ * channel that is quiet for half a minute is not being quiet, it is dead.
+ */
+export const STALL = 30_000;
+/** How much of what ffmpeg said to keep, for the last line when it dies. */
+const TAIL = 2000;
+/**
+ * Read everything a child says on stderr, keeping only the end of it.
+ *
+ * This is not optional. A pipe nobody reads fills, at 64 KiB on Linux, and
+ * the child then blocks on its next write to it -- every thread it has waits
+ * on the one that is stuck, and it produces nothing more, for ever, without
+ * exiting. A channel carrying an IPTV transport stream logs a line for every
+ * corrupt packet, and over twelve hours that is more than 64 KiB. Measured on
+ * the real server: CNN "on the air" with a full stderr socket, its decoder
+ * thread asleep in the kernel on that write, its byte count frozen, and a
+ * listener handed the opening boxes and then nothing at all.
+ */
+function drain(stream, keep) {
+    let tail = "";
+    stream?.on("data", (chunk) => {
+        tail = (tail + chunk.toString("utf8")).slice(-TAIL);
+        keep(tail);
+    });
+    stream?.on("error", () => undefined);
+}
+/** The last thing ffmpeg said, which is where it says what went wrong. */
+function lastLine(tail) {
+    return tail.trim().split("\n").pop() ?? "";
+}
 /** A name that can sit in a URL and be read back in a list. */
 export function cleanId(value, fallback = "main") {
     if (typeof value !== "string")
@@ -47,6 +81,10 @@ export class Channel {
     redial = null;
     failures = 0;
     timer = null;
+    /** Fires when a pulled source has said nothing for STALL. */
+    watchdog = null;
+    stall = STALL;
+    stderr = "";
     constructor(info, options, onGone) {
         this.info = info;
         this.options = options;
@@ -72,6 +110,7 @@ export class Channel {
             this.info.bytes += chunk.byteLength;
             this.send(chunk);
         });
+        drain(child.stderr, (tail) => { this.stderr = tail; });
         // A publisher that hangs up mid-write breaks the pipe, and an unhandled
         // EPIPE takes the whole server with it.
         child.stdin?.on("error", () => this.close());
@@ -94,7 +133,8 @@ export class Channel {
      * because you looked away, and a room where the picture depends on who is
      * in it is not a room anybody can be invited to.
      */
-    pull(source, encode, paced = true) {
+    pull(source, encode, paced = true, stall = STALL) {
+        this.stall = stall;
         if (this.info.kind === "video")
             this.fragments = new Fragments();
         const [command, ...prefix] = this.options.ffmpeg;
@@ -102,6 +142,7 @@ export class Channel {
         const dial = () => {
             if (this.closing)
                 return;
+            this.stderr = "";
             const child = spawn(command, [
                 ...prefix,
                 "-hide_banner",
@@ -110,6 +151,11 @@ export class Channel {
                 // the first time a CDN hiccups is not a channel anybody can rely
                 // on. ffmpeg redials on its own before we have to.
                 ...(remote ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5"] : []),
+                // A connection that stops answering is an error after this long,
+                // and an error is a thing the reconnect above knows what to do
+                // with. Without it a silent socket is waited on for ever. In
+                // microseconds, as ffmpeg wants it.
+                ...(remote ? ["-rw_timeout", String(stall * 1000)] : []),
                 // Real time, always. A file read as fast as the disk allows is an
                 // hour of film in ninety seconds and a room that cannot be in it
                 // together; a live source is already paced and loses nothing.
@@ -119,20 +165,102 @@ export class Channel {
                 "pipe:1",
             ], { stdio: ["ignore", "pipe", "pipe"] });
             let sent = false;
+            this.child = child;
+            this.rearm(child);
             child.stdout?.on("data", (chunk) => {
+                // An ffmpeg that was replaced can still have a chunk in the pipe.
+                if (this.child !== child)
+                    return;
                 sent = true;
                 this.info.bytes += chunk.byteLength;
+                this.rearm(child);
                 this.emit(chunk);
             });
             child.stdout?.on("error", () => undefined);
-            child.on("error", () => this.dropped(sent));
-            child.on("close", () => this.dropped(sent));
-            this.child = child;
+            drain(child.stderr, (tail) => { this.stderr = tail; });
+            // Only the ffmpeg we are currently running gets to say the source
+            // dropped. One that was killed to make way for a restart is not news.
+            child.on("error", () => { if (this.child === child)
+                this.dropped(sent); });
+            child.on("close", () => { if (this.child === child)
+                this.dropped(sent); });
         };
         this.redial = dial;
         dial();
         this.options.onStart?.(this.info);
     }
+    /**
+     * Start the source over, now.
+     *
+     * For a pulled channel only: a publisher's stream cannot be dialled again
+     * from this end. The current ffmpeg is killed and a new one started at
+     * once, with the count of failures cleared -- somebody asking for this has
+     * decided the thing is worth another go, and should not inherit the four
+     * strikes a dead CDN ran up an hour ago.
+     */
+    restart() {
+        const dial = this.redial;
+        if (!dial || this.closing)
+            return false;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        if (this.watchdog)
+            clearTimeout(this.watchdog);
+        this.watchdog = null;
+        this.failures = 0;
+        this.info.redials = (this.info.redials ?? 0) + 1;
+        this.info.error = undefined;
+        const old = this.child;
+        this.child = null;
+        old?.kill("SIGKILL");
+        this.startOver();
+        dial();
+        return true;
+    }
+    /**
+     * The stream that was is over; the next ffmpeg is a new one.
+     *
+     * New opening boxes, timestamps from zero again. Whoever was listening
+     * cannot follow that mid-picture, and a newcomer must not be handed the old
+     * opening boxes in front of the new fragments -- so the header is dropped
+     * and the audience is ended, to come back to the stream as it now is. The
+     * player rejoins on its own. Done the moment the source is known to be
+     * gone, not when the redial happens: somebody joining in between gets the
+     * new beginning as it is written, rather than a stale one first.
+     */
+    startOver() {
+        if (this.info.kind === "video")
+            this.fragments = new Fragments();
+        this.hangUp();
+    }
+    /** Expect output within STALL, or treat the source as gone and dial again. */
+    rearm(child) {
+        if (this.watchdog)
+            clearTimeout(this.watchdog);
+        this.watchdog = setTimeout(() => {
+            this.watchdog = null;
+            if (this.child !== child || this.closing)
+                return;
+            this.info.error = `no data from the source for ${Math.round(this.stall / 1000)}s`;
+            // Its close handler is what dials again.
+            child.kill("SIGKILL");
+        }, this.stall);
+        this.watchdog.unref?.();
+    }
+    /** End everybody listening; the stream they were on is over. */
+    hangUp() {
+        for (const listener of this.listeners) {
+            try {
+                listener.end();
+            }
+            catch {
+                // Gone already.
+            }
+        }
+        this.listeners.clear();
+        this.info.listeners = 0;
+    }
     /**
      * A source that stopped. Try it again, unless it never worked at all.
      *
@@ -144,11 +272,19 @@ export class Channel {
         if (this.closing || !this.redial)
             return;
         this.child = null;
+        if (this.watchdog)
+            clearTimeout(this.watchdog);
+        this.watchdog = null;
+        const said = lastLine(this.stderr);
+        if (said)
+            this.info.error = said;
         this.failures = sent ? 0 : this.failures + 1;
         if (this.failures >= GIVE_UP) {
             this.close();
             return;
         }
+        this.info.redials = (this.info.redials ?? 0) + 1;
+        this.startOver();
         const dial = this.redial;
         this.timer = setTimeout(() => {
             this.timer = null;
@@ -234,6 +370,12 @@ export class Channel {
         if (this.timer)
             clearTimeout(this.timer);
         this.timer = null;
+        if (this.watchdog)
+            clearTimeout(this.watchdog);
+        this.watchdog = null;
+        const said = lastLine(this.stderr);
+        if (said && !this.info.error)
+            this.info.error = said;
         const child = this.child;
         this.child = null;
         try {
@@ -318,7 +460,7 @@ export class Channels {
      * about it is the same too, which is the point -- a re-stream stops being a
      * special case and becomes one more thing that is on.
      */
-    pull(id, name, source, encode, kind, paced = true) {
+    pull(id, name, source, encode, kind, paced = true, stall = STALL) {
         if (this.open.has(id))
             return null;
         const channel = new Channel({
@@ -333,9 +475,21 @@ export class Channels {
             source,
         }, this.options, (gone) => this.open.delete(gone));
         this.open.set(id, channel);
-        channel.pull(source, encode, paced);
+        channel.pull(source, encode, paced, stall);
         return channel;
     }
+    /**
+     * Dial a pulled channel's source again, now. False for a channel that is
+     * not there or is not ours to dial: a publisher's stream restarts at the
+     * publisher's end.
+     */
+    restart(id) {
+        return this.open.get(id)?.restart() ?? false;
+    }
+    /** Whether a channel is one we fetch ourselves, and so can start over. */
+    pulled(id) {
+        return this.open.get(id)?.info.via === "pull";
+    }
     /** What a listener should be told this channel is. */
     contentType(id) {
         return this.open.get(id)?.info.kind === "video" ? "video/mp4" : "audio/mpeg";

package/dist/rtmp-in.js

@@ -59,6 +59,10 @@ export class RtmpListeners {
             channel?.feed(chunk);
         });
         child.stdout?.on("error", () => child.kill("SIGKILL"));
+        // Read and dropped. A pipe nobody reads fills at 64 KiB, and ffmpeg then
+        // blocks on its next complaint and stops producing anything -- a
+        // publisher whose stream hiccups enough would take the slot down with it.
+        child.stderr?.resume();
         child.on("error", () => this.done(slot, child, channel));
         child.on("close", () => this.done(slot, child, channel));
     }

package/dist/server.js

@@ -1774,6 +1774,12 @@ export function createHandler(engine, options) {
                     via: one.via,
                     listeners: one.listeners,
                     startedAt: one.startedAt,
+                    // Whether it has a picture, so the page puts it in the element
+                    // that can show one. Never the source: that is the owner's.
+                    kind: one.kind ?? "audio",
+                    // How it has been going, for whoever may do something about it.
+                    redials: one.redials ?? 0,
+                    error: one.error ?? "",
                 })),
                 // Anything re-streamed into this server is a live stream too, and was
                 // sitting in the middle of the playlist among the files -- which is
@@ -1797,7 +1803,13 @@ export function createHandler(engine, options) {
         // devices can publish at once, each to their own channel, and a listener
         // picks which to hear.
         if (path === "/api/channels" && options.channels) {
-            json(response, 200, { channels: options.channels.list(), listeners: options.channels.listeners });
+            // Without the source. Anyone holding the listen link may ask what is
+            // on, and the address a channel is pulled from is the one thing about
+            // it that is not theirs to have.
+            json(response, 200, {
+                channels: options.channels.list().map(({ source: _source, ...shown }) => shown),
+                listeners: options.channels.listeners,
+            });
             return;
         }
         // Publishing. Anyone with the control link may; listening to the result is
@@ -1852,6 +1864,27 @@ export function createHandler(engine, options) {
                 json(response, 405, { error: "GET, POST or DELETE" });
                 return;
             }
+            /**
+             * Dial the source again, now.
+             *
+             * The thing an administrator reaches for when a channel says it is on
+             * the air and shows nobody anything. It is what fixed CNN by hand --
+             * take it off, put it back -- without having to know the source, which
+             * a browser is never told.
+             */
+            if (action === "restart") {
+                if (!channels.has(id)) {
+                    json(response, 404, { error: "nothing is playing on that channel" });
+                    return;
+                }
+                if (!channels.pulled(id)) {
+                    json(response, 409, { error: "that channel is published into this server; restart it at the publisher" });
+                    return;
+                }
+                const restarted = channels.restart(id);
+                json(response, restarted ? 200 : 409, { ok: restarted });
+                return;
+            }
             /**
              * Carry a source of our own, rather than waiting to be sent one.
              *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.7.35",
+  "version": "0.7.36",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",

package/src/audio.ts

@@ -218,7 +218,9 @@ export class Stream {
     }
 
     let stderr = "";
-    this.decoder.stderr?.on("data", (c: Buffer) => { stderr += c.toString(); });
+    // The tail only: what went wrong is on the last line, and a film with a
+    // damaged audio track can say so once a frame for two hours.
+    this.decoder.stderr?.on("data", (c: Buffer) => { stderr = (stderr + c.toString()).slice(-2000); });
 
     this.decoder.stdout?.on("data", (chunk: Buffer) => {
       if (this.stopped || generation !== this.generation) return;