@torrent-tv/proxy 2.100.2 → 2.100.4

package/package.json

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

package/server.js

@@ -972,8 +972,12 @@ export async function startProxyServer({
           const answer = input.read(source.fileIndex, start, end);
           return answer && typeof answer.then !== "function" && answer.end === end ? answer.bytes : null;
         };
+        const holdsUntil = start => {
+          const range = source.input.ranges.find(([first, last]) => first <= start && start <= last);
+          return range ? range[1] + 1 : null;
+        };
         const startedAt = Date.now();
-        void container.learnPackets({ from: source.input.from, to: source.input.to, trackIds: [...sounds] }, read).then(learned =>
+        void container.learnPackets({ from: source.input.from, to: source.input.to, trackIds: [...sounds] }, read, holdsUntil).then(learned =>
           logger.info(`encode input #${from}..#${to} of ${output.outputKey}: soundtrack packets of track(s) ${[...sounds].join(",")} ` +
             `over ${source.input.from.toFixed(3)}-${source.input.to.toFixed(3)}s ` +
             (learned === "walked" ? "walked" : `not all walked (${learned === "memory" ? "memory refused" : "the copy does not hold the rest"})`) +

package/services/encode/quality/HostLoad.js

@@ -654,11 +654,17 @@ export class HostLoad {
     // alone would print something like `ffmpeg=-598%`. Only pids present in
     // BOTH readings are counted, so a process that came or went contributes
     // nothing rather than a lie.
-    const runs = encoding.flatMap((session) => this.#host.liveRunsOf(session)).filter((run) => Number.isInteger(run.process?.pid));
+    // Each run's pid and start are read BEFORE the readings are awaited: a run
+    // that ends meanwhile drops its process, and read after the await it threw
+    // `Cannot read properties of null (reading 'pid')`, seven times in one
+    // field session, each losing that reading (r64, torrent-tv/meta#178).
+    const runs = encoding.flatMap((session) => this.#host.liveRunsOf(session))
+      .filter((run) => Number.isInteger(run.process?.pid))
+      .map((run) => ({ pid: run.process.pid, startedAt: run.startedAt }));
     const [system, endedChildren, ...cpuReadings] = await Promise.all([
       this.#host.readSystemCpu(),
       this.#host.readEndedChildrenCpuSeconds?.() ?? null,
-      ...runs.map((run) => this.#host.readProcessCpuSeconds(run.process.pid))
+      ...runs.map((run) => this.#host.readProcessCpuSeconds(run.pid))
     ]);
     /** @type {Map<number, number>} */
     const byPid = new Map();
@@ -667,8 +673,8 @@ export class HostLoad {
     runs.forEach((run, index) => {
       const seconds = cpuReadings[index];
       if (seconds !== null) {
-        byPid.set(run.process.pid, seconds);
-        startedAt.set(run.process.pid, run.startedAt);
+        byPid.set(run.pid, seconds);
+        startedAt.set(run.pid, run.startedAt);
       }
     });
     const sample = {

package/services/media/container/MatroskaContainer.js

@@ -792,7 +792,7 @@ export class MatroskaContainer extends Container {
    *   `account`, when given, is told how long each track's walk waited for
    *   that track's earlier walks and what it read (`lockMs`, `reads`, `bytes`).
    */
-  async readPacketIndex(interval, { isCurrent, readRange, account } = {}) {
+  async readPacketIndex(interval, { isCurrent, readRange, holdsUntil, account } = {}) {
     if (this.#packets) return this.#packets;
     const layout = await this.#segmentLayout();
     if (!layout) throw new Error("Matroska Segment is absent.");
@@ -812,7 +812,7 @@ export class MatroskaContainer extends Container {
     let whole = true;
     for (const track of requested) {
       const chain = await this.#readTrackPackets(layout, tracks, track, start, interval, isCurrent,
-        readRange ? strictReader(readRange, this.fileSize) : this.readRange, account);
+        readRange ? strictReader(readRange, this.fileSize) : this.readRange, account, readRange ? holdsUntil : null);
       if (!chain) return null;
       streams.set(track.trackNumber, chain.records);
       if (chain.reachesEnd) complete.add(track.trackNumber);
@@ -837,13 +837,14 @@ export class MatroskaContainer extends Container {
    *
    * @param {{ from: number, to: number, trackIds: number[] }} interval
    * @param {(start: number, end: number) => Buffer | null} readRange - Null where it does not hold the bytes.
+   * @param {(start: number) => number | null} [holdsUntil] - One past the last byte held from `start` on, if known.
    * @returns {Promise<"walked" | "missing" | "memory">} Whether the
    *   interval's packets are recorded, or what stopped the walk: bytes the
    *   copy does not hold, or memory refused.
    */
-  async learnPackets(interval, readRange) {
+  async learnPackets(interval, readRange, holdsUntil = null) {
     try {
-      return await this.readPacketIndex(interval, { readRange }) !== null ? "walked" : "missing";
+      return await this.readPacketIndex(interval, { readRange, holdsUntil }) !== null ? "walked" : "missing";
     } catch (error) {
       // The sound's own walk reads the rest later, from where this one stopped.
       if (isUnavailable(error)) return "missing";
@@ -865,7 +866,7 @@ export class MatroskaContainer extends Container {
    *
    * @returns {Promise<{ records: PacketRecordsChain, startAt: number, reachesEnd: boolean }>}
    */
-  async #readTrackPackets(layout, tracks, track, start, interval, isCurrent, reader, account = null) {
+  async #readTrackPackets(layout, tracks, track, start, interval, isCurrent, reader, account = null, holdsUntil = null) {
     const id = track.trackNumber;
     const previous = this.#packetWalks.get(id) ?? Promise.resolve();
     let finished;
@@ -930,7 +931,7 @@ export class MatroskaContainer extends Container {
         const following = readings.find(reading => reading.startAt > current.startAt);
         const outcome = await walkMatroskaPackets({ readRange: read, fileSize: this.fileSize,
           portionBytes: this.portionBytes, layout, tracks, trackIds: [id], interval, packetMemory: this.packetMemory,
-          state: current, until: following?.startAt ?? null, isCovered: covered, readsThrough, isCurrent });
+          state: current, until: following?.startAt ?? null, isCovered: covered, readsThrough, isCurrent, holdsUntil });
         if (outcome === "obsolete") return null;
         if (outcome !== "until") break;
         current.next = following;

package/services/media/container/matroska-packets.js

@@ -49,7 +49,7 @@ function recordedTracks(tracks, trackIds) {
  *
  * @returns {Promise<"covered" | "until" | "end" | "obsolete">}
  */
-export async function walkMatroskaPackets({ readRange, fileSize, portionBytes, layout, tracks, trackIds, interval, packetMemory, state, until = null, isCovered = null, readsThrough = null, isCurrent = null }) {
+export async function walkMatroskaPackets({ readRange, fileSize, portionBytes, layout, tracks, trackIds, interval, packetMemory, state, until = null, isCovered = null, readsThrough = null, isCurrent = null, holdsUntil = null }) {
   // INSIDE A CLUSTER EVERY BLOCK HEADER IS READ, so its bytes are read a
   // portion at a time up to the cluster's end, and never past it. Read a
   // header at a time, each a read of a few bytes from the torrent thread, the
@@ -61,8 +61,14 @@ export async function walkMatroskaPackets({ readRange, fileSize, portionBytes, l
   // (r54). The headers lie throughout the portion, so it is all needed.
   // Between clusters only their headers are read.
   let readableUntil = null;
+  // `holdsUntil` bounds a portion by what the reader holds, so a walk over a
+  // copy reads up to its end what it needs, not a portion past it (r63).
   const reader = new ElementReader({ read: readRange, fileSize, portionBytes, prefetch: true,
-    readableUntil: start => Math.max(readableUntil ?? start, readsThrough?.(start) ?? start) });
+    readableUntil: start => {
+      const reach = Math.max(readableUntil ?? start, readsThrough?.(start) ?? start);
+      const held = holdsUntil?.(start);
+      return Number.isFinite(held) ? Math.min(reach, held) : reach;
+    } });
   const declared = recordedTracks(tracks, trackIds);
   if (!state.packets) {
     state.packets = new Map([...declared.keys()].map(id => [id, new PacketRecords(packetMemory)]));