@torrent-tv/proxy 2.101.21 → 2.101.23

package/package.json

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

package/services/server/OutputLifecycle.js

@@ -219,7 +219,7 @@ export class OutputLifecycle {
     const maxBytes = this.#host.machineBudget.segmentBytes();
     const inventory = this.#host.segmentStore.inventory();
     let held = inventory.reduce((bytes, output) => bytes + output.bytes, 0);
-    if (!Number.isFinite(maxBytes) || maxBytes <= 0 || held <= maxBytes) return;
+    if (!Number.isFinite(maxBytes) || maxBytes < 0 || held <= maxBytes) return;
     const candidates = leastNeededSegments(inventory.map(output => ({
       ...output,
       positions: this.#host.viewerSegmentsOn(output.key),

package/services/storage/files/CompletedFiles.js

@@ -54,8 +54,13 @@ export class CompletedFiles {
 
   /** Assemblies in flight, so two passes cannot write one file at once. @type {Set<string>} */
   #writing = new Set();
+  /** Bytes promised to assemblies that have not yet become held files. @type {Map<string, number>} */
+  #reservations = new Map();
+  /** Serialize allowance changes and admission decisions. @type {Promise<unknown>} */
+  #admission = Promise.resolve();
   #readers = new Map();
   #removeAfterRead = new Set();
+  #removing = new Set();
 
   /**
    * What this store may hold, handed to it by the owner of the disk.
@@ -76,6 +81,8 @@ export class CompletedFiles {
 
   /** When each held file was last asked for. @type {Map<string, number>} */
   #lastRead = new Map();
+  /** Monotonic access order, so reads in the same clock tick remain ordered. */
+  #accessOrder = 0;
 
   /**
    * @param {object} params
@@ -142,17 +149,22 @@ export class CompletedFiles {
    */
   find(infoHash, fileIndex) {
     const key = this.#keyOf(infoHash, fileIndex);
-    if (this.#removeAfterRead.has(key)) return null;
+    if (this.#removeAfterRead.has(key) || this.#removing.has(key)) return null;
     const file = this.#held.get(key) ?? null;
     if (file) {
       // WHEN IT WAS LAST WANTED, which is the order it leaves in. A whole file
       // nobody has asked for in the longest is the one whose loss costs least:
       // it can be downloaded again, and a read of it falls back to the pieces.
-      this.#lastRead.set(key, Date.now());
+      this.#touch(key);
     }
     return file;
   }
 
+  /** Mark a file as more recently wanted than every earlier access. */
+  #touch(key) {
+    this.#lastRead.set(key, ++this.#accessOrder);
+  }
+
   /** Pin a completed file against eviction until all its offset reads finish. */
   acquire(infoHash, fileIndex) {
     const key = this.#keyOf(infoHash, fileIndex);
@@ -186,20 +198,38 @@ export class CompletedFiles {
    *   many files went.
    */
   async allow(bytes) {
-    this.#allowanceBytes = Number.isFinite(bytes) && bytes >= 0 ? bytes : null;
-    let removed = 0;
-    if (this.#allowanceBytes === null) {
+    return this.#withAdmission(async () => {
+      this.#allowanceBytes = Number.isFinite(bytes) && bytes >= 0 ? bytes : null;
+      const removed = await this.#trimToAllowance();
       return { bytes: this.bytes, removed };
-    }
-    while (this.bytes > this.#allowanceBytes) {
+    });
+  }
+
+  /** Run one storage decision at a time. @param {() => Promise<unknown> | unknown} action */
+  #withAdmission(action) {
+    const result = this.#admission.then(action, action);
+    this.#admission = result.catch(() => undefined);
+    return result;
+  }
+
+  /** Include bytes currently being assembled when enforcing the allowance. */
+  #reservedBytes() {
+    let total = 0;
+    for (const length of this.#reservations.values()) total += length;
+    return total;
+  }
+
+  /** Remove eligible unused files until held and reserved bytes fit. */
+  async #trimToAllowance() {
+    let removed = 0;
+    if (this.#allowanceBytes === null) return removed;
+    while (this.bytes + this.#reservedBytes() > this.#allowanceBytes) {
       const victim = this.#longestUnread();
-      if (!victim) {
-        break;
-      }
-      await this.#remove(victim);
+      if (!victim) break;
+      if (!await this.#remove(victim)) break;
       removed += 1;
     }
-    return { bytes: this.bytes, removed };
+    return removed;
   }
 
   /**
@@ -215,7 +245,7 @@ export class CompletedFiles {
     if (this.#allowanceBytes === null) {
       return true;
     }
-    return this.bytes + Math.max(0, Number(length) || 0) <= this.#allowanceBytes;
+    return this.bytes + this.#reservedBytes() + Math.max(0, Number(length) || 0) <= this.#allowanceBytes;
   }
 
   /**
@@ -227,7 +257,7 @@ export class CompletedFiles {
     let oldest = null;
     let oldestAt = Number.POSITIVE_INFINITY;
     for (const key of this.#held.keys()) {
-      if (this.#writing.has(key) || this.#readers.has(key)) {
+      if (this.#writing.has(key) || this.#readers.has(key) || this.#removing.has(key)) {
         continue;
       }
       const at = this.#lastRead.get(key) ?? 0;
@@ -243,17 +273,24 @@ export class CompletedFiles {
    * Take one whole file off the disk.
    *
    * @param {string} key
-   * @returns {Promise<void>}
+   * @returns {Promise<boolean>} Whether the file was removed.
    */
   async #remove(key) {
-    if (this.#readers.has(key)) { this.#removeAfterRead.add(key); return; }
+    if (this.#removing.has(key)) return false;
+    if (this.#readers.has(key)) { this.#removeAfterRead.add(key); return false; }
     const file = this.#held.get(key);
+    if (!file) return true;
+    this.#removing.add(key);
+    try {
+      await fs.rm(file.path, REMOVAL);
+    } catch {
+      this.#removing.delete(key);
+      return false;
+    }
     this.#held.delete(key);
     this.#lastRead.delete(key);
-    if (!file) {
-      return;
-    }
-    await fs.rm(file.path, REMOVAL).catch(() => undefined);
+    this.#removing.delete(key);
+    return true;
   }
 
   /**
@@ -344,18 +381,30 @@ export class CompletedFiles {
   async keep({ infoHash, fileIndex, length, name, open }) {
     const key = this.#keyOf(infoHash, fileIndex);
     const held = this.#held.get(key);
-    if (held) {
+    if (held && !this.#removing.has(key)) {
       return held;
     }
+    if (this.#removing.has(key)) return null;
     if (this.#writing.has(key)) {
       return null;
     }
-    if (!this.hasRoomFor(length)) {
-      // Assembling it and then removing it is the same bytes written for
-      // nothing. The pieces still serve the read; this file simply is not kept.
+    this.#writing.add(key);
+    const admitted = await this.#withAdmission(async () => {
+      if (this.#held.has(key)) return false;
+      if (this.#allowanceBytes !== null && length > this.#allowanceBytes) return false;
+      while (this.#allowanceBytes !== null &&
+        this.bytes + this.#reservedBytes() + length > this.#allowanceBytes) {
+        const victim = this.#longestUnread();
+        if (!victim) return false;
+        if (!await this.#remove(victim)) return false;
+      }
+      this.#reservations.set(key, length);
+      return true;
+    });
+    if (!admitted) {
+      await this.#withAdmission(() => { this.#writing.delete(key); });
       return null;
     }
-    this.#writing.add(key);
     const directory = path.join(this.#root, String(infoHash));
     const where = path.join(directory, String(fileIndex));
     const partial = `${where}.partial`;
@@ -367,6 +416,9 @@ export class CompletedFiles {
       let written = 0;
       try {
         for await (const chunk of source) {
+          if (written + chunk.length > length) {
+            throw new Error("Whole-file read exceeded its declared length");
+          }
           await handle.write(chunk);
           written += chunk.length;
         }
@@ -382,14 +434,24 @@ export class CompletedFiles {
       }
       await fs.rename(partial, where);
       const file = { path: where, length, name: String(name ?? fileIndex) };
-      this.#held.set(key, file);
+      await this.#withAdmission(async () => {
+        this.#reservations.delete(key);
+        this.#held.set(key, file);
+        this.#touch(key);
+        this.#writing.delete(key);
+        await this.#trimToAllowance();
+      });
       await this.#writeManifest(infoHash);
-      return file;
+      return this.#held.get(key) ?? null;
     } catch {
       await fs.rm(partial, REMOVAL).catch(() => undefined);
       return null;
     } finally {
-      this.#writing.delete(key);
+      await this.#withAdmission(async () => {
+        this.#reservations.delete(key);
+        this.#writing.delete(key);
+        await this.#trimToAllowance();
+      });
     }
   }
 

package/services/storage/wire.js

@@ -56,9 +56,9 @@ import { availableMemoryBytes } from "./machine-memory.js";
  * @param {import("./MachineBudget.js").BudgetPolicy} [params.policy] - What the
  *   operator has said this proxy may take. Absent, the measured default.
  * @param {{ info: Function, warn?: Function }} [params.logger]
- * @returns {{ revise: () => Promise<unknown>, segmentBytes: () => number, diagnostics: object | null, describe: () => string }}
- *   What the segments may hold is asked for rather than pushed: zero until the
- *   first revision, and zero stops growth rather than licensing it.
+ * @returns {{ revise: () => Promise<unknown>, segmentBytes: () => number | null, diagnostics: object | null, describe: () => string }}
+ *   What the segments may hold is asked for rather than pushed: null until the
+ *   first revision, then the measured allowance, including a measured zero.
  */
 export function wireMachineBudget({
   segmentStore,
@@ -101,7 +101,7 @@ export function wireMachineBudget({
   const segmentsOn = deviceOf(segmentStore.root);
   defineDisk(segmentsOn, segmentStore.root);
 
-  let segmentBytes = 0;
+  let segmentBytes = null;
   budget.register({
     name: "segments",
     resource: segmentsOn,