@torrent-tv/proxy 2.97.22 → 2.97.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.97.22",
+  "version": "2.97.23",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "repository": {

package/services/encode/EncodeRun.js

@@ -123,6 +123,8 @@ export class EncodeRun {
    */
   #pendingAtStop = null;
   #closedTimings = new Map();
+  /** When the encoder named each closed piece on its channel, until it is published. */
+  #namedAt = new Map();
   #publicationError = null;
   #publicationCode = null;
   #inputTruncated = false;
@@ -622,6 +624,7 @@ export class EncodeRun {
       if (name.length === 0) {
         continue;
       }
+      this.#namedAt.set(name, this.now());
       if (this.#publicationError) continue;
       if (this.#stopping) {
         // Flushed by our stop. Never published; it tells where the piece closed
@@ -681,7 +684,8 @@ export class EncodeRun {
       // name a request can actually ask for.
       let served;
       try {
-        served = this.onClosed(name, following, this.#closedTimings.get(name) ?? null, { tentative });
+        served = this.onClosed(name, following, this.#closedTimings.get(name) ?? null,
+          { tentative, namedAt: this.#namedAt.get(name) ?? null });
       } catch (error) {
         if (quiet) {
           // A piece closed before our stop that cannot be proved whole is not
@@ -702,7 +706,10 @@ export class EncodeRun {
       } finally {
         // A piece not proved whole on its own keeps its timing for the file
         // after it.
-        if (!tentative || served) this.#closedTimings.delete(name);
+        if (!tentative || served) {
+          this.#closedTimings.delete(name);
+          this.#namedAt.delete(name);
+        }
       }
 
       if (!served) return false;

package/services/encode/EncodeRuns.js

@@ -1121,7 +1121,7 @@ export class EncodeRuns {
       // from it — a re-encoded picture, or sound served as its own output. Such
       // a piece is published on its own line (torrent-tv/meta#178).
       publishesAlone: this.publishesAlone(session),
-      onClosed: (name, following, timing, { tentative = false } = {}) => {
+      onClosed: (name, following, timing, { tentative = false, namedAt = null } = {}) => {
 
         const index = session.segmentFormat.segmentIndexFromName(
           session.segmentFormat.servedNameOf?.(name) ?? name);
@@ -1131,6 +1131,8 @@ export class EncodeRuns {
         if (Number.isInteger(index) && (index < safeIndex || index > run.to)) return null;
         let bytes = null;
         const address = session.outputKey ?? "";
+        // Read before anything rewrites it: when the encoder finished it.
+        const writtenAt = this.#host.segmentFiles.writtenAtOf?.(address, name) ?? null;
         const fmp4 = admittedInput && session.segmentFormat.id === "fmp4" && session.spec.carries !== "audio-only";
         // The first piece of a run that read the picture from its keyframe:
         // its leading pictures are the ones the run before made, or none.
@@ -1157,6 +1159,14 @@ export class EncodeRuns {
         const published = this.#host.segmentFiles.publish(address, name, session.segmentFormat, { mediaRanges, bytes });
         if (!published) throw new Error(`Closed piece #${index} could not be stored.`);
         this.#leadingByOutput.get(address)?.delete(index);
+        // WHERE A LATE PIECE'S TIME WENT: the encoder writing it, this process
+        // getting to its name, or its publication waiting for the file after
+        // it. A piece 5.7 s apart from the one before stopped a viewer inside a
+        // running run, and nothing said which (torrent-tv/meta#178).
+        const since = at => (Number.isFinite(at) ? `+${Math.round(at - run.startedAt)}ms` : "unknown");
+        this.#host.logger.info(`encode-run #${run.from}..#${run.to} on ${address}: #${index} written by the encoder ${since(writtenAt)}, ` +
+          `named ${since(namedAt)}, published ${since(run.now())} ` +
+          (following ? `when ${following} closed` : tentative ? "on its own" : "at the run's end"));
         return published;
 
       },

package/services/storage/segment-store/SegmentStore.js

@@ -594,6 +594,23 @@ export class SegmentStore {
     return readFileSync(path.join(this.#root, directoryNameFor(key), makingName));
   }
 
+  /**
+   * When the encoder last wrote a file it has closed under its working name,
+   * on the kernel's clock and so apart from when this process got to it; null
+   * when it is not there.
+   *
+   * @param {string} key
+   * @param {string} makingName
+   * @returns {number | null}
+   */
+  writtenAtOf(key, makingName) {
+    try {
+      return statSync(path.join(this.#root, directoryNameFor(key), makingName)).mtimeMs;
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * The media intervals a stored piece holds, read once from its bytes and kept
    * with them, or undefined where its format reads none or it is not here.