@torrent-tv/proxy 2.87.8 → 2.87.10

package/services/storage/allowance.js

@@ -1,107 +1,107 @@
-/**
- * @file How much of a machine's resource the stores may hold between them.
- *
- * Written once and used twice, because memory and disk are the same question
- * asked of two resources: what is free now, plus what we already hold, less
- * what everything that is not us has recently been seen to need.
- *
- * It used to exist only for memory, inside the memory store, keyed on module
- * state. Disk had no such rule at all — the spill file grew until the machine
- * did, 14.4 GB in a single viewing on 2026-08-31 — and copying the memory rule
- * across would have made two rules to keep in step. One rule, two readings.
- */
-
-/**
- * How many observations of other processes' demand are kept.
- *
- * A window rather than a high-water: a single spike would otherwise stand for
- * the life of the process and hold the stores down long after whatever caused
- * it had finished.
- */
-const OTHER_DEMAND_SAMPLES = 60;
-
-/**
- * What everything that is not us has recently been seen to need.
- *
- * One instance per resource. A fall in what is free that we did not cause is a
- * measurement of somebody else's demand; a fall we did cause is our own doing
- * and says nothing about the machine.
- */
-export class OtherDemand {
-  /** @type {number[]} */
-  #falls = [];
-
-  #lastFreeBytes = 0;
-
-  #lastHeldBytes = 0;
-
-  /**
-   * Take a reading, and answer what to reserve for others.
-   *
-   * @param {number} freeBytes - What the machine says is free now.
-   * @param {number} heldBytes - What the stores hold of this resource now.
-   * @returns {number} The reserve, in bytes.
-   */
-  note(freeBytes, heldBytes) {
-    if (this.#lastFreeBytes > 0) {
-      const fell = this.#lastFreeBytes - freeBytes;
-      const ours = heldBytes - this.#lastHeldBytes;
-      this.#falls.push(Math.max(0, fell - ours));
-      if (this.#falls.length > OTHER_DEMAND_SAMPLES) {
-        this.#falls.shift();
-      }
-    }
-    this.#lastFreeBytes = freeBytes;
-    this.#lastHeldBytes = heldBytes;
-    return this.reserve();
-  }
-
-  /** @returns {number} */
-  reserve() {
-    return this.#falls.length === 0 ? 0 : Math.max(...this.#falls);
-  }
-
-  /** Forget the readings. For tests, which share a module. */
-  forget() {
-    this.#falls = [];
-    this.#lastFreeBytes = 0;
-    this.#lastHeldBytes = 0;
-  }
-}
-
-/**
- * How much of the resource the stores may hold between them.
- *
- * What the machine reports free is what could be taken ON TOP of what is
- * already held, so the stores' own bytes are added back: the pair is the
- * ceiling the stores could reach.
- *
- * @param {number} freeBytes
- * @param {number} heldBytes
- * @param {number} reserveBytes
- * @returns {number}
- */
-export function machineAllowanceBytes(freeBytes, heldBytes, reserveBytes) {
-  return Math.max(0, Math.max(freeBytes, 0) + Math.max(heldBytes, 0) - Math.max(reserveBytes, 0));
-}
-
-/**
- * Divide what the machine allows between the stores, by what each is asking
- * for.
- *
- * When everyone's ask fits, everyone gets it and the machine's limit never
- * binds. When the asks do not fit, each store is cut in proportion to what it
- * asked, so a store wanting little is not cut to make room for one wanting
- * much.
- *
- * @param {number[]} wantedBytes - What each store is asking for, in order.
- * @param {number} allowanceBytes
- * @returns {number[]} What each store may hold, in the same order.
- */
-export function divideAllowance(wantedBytes, allowanceBytes) {
-  const total = wantedBytes.reduce((sum, want) => sum + Math.max(0, want), 0);
-  if (total <= allowanceBytes || total === 0) {
-    return wantedBytes.map((want) => Math.max(0, want));
-  }
-  return wantedBytes.map((want) => Math.floor(allowanceBytes * (Math.max(0, want) / total)));
-}
+/**
+ * @file How much of a machine's resource the stores may hold between them.
+ *
+ * Written once and used twice, because memory and disk are the same question
+ * asked of two resources: what is free now, plus what we already hold, less
+ * what everything that is not us has recently been seen to need.
+ *
+ * It used to exist only for memory, inside the memory store, keyed on module
+ * state. Disk had no such rule at all — the spill file grew until the machine
+ * did, 14.4 GB in a single viewing on 2026-08-31 — and copying the memory rule
+ * across would have made two rules to keep in step. One rule, two readings.
+ */
+
+/**
+ * How many observations of other processes' demand are kept.
+ *
+ * A window rather than a high-water: a single spike would otherwise stand for
+ * the life of the process and hold the stores down long after whatever caused
+ * it had finished.
+ */
+const OTHER_DEMAND_SAMPLES = 60;
+
+/**
+ * What everything that is not us has recently been seen to need.
+ *
+ * One instance per resource. A fall in what is free that we did not cause is a
+ * measurement of somebody else's demand; a fall we did cause is our own doing
+ * and says nothing about the machine.
+ */
+export class OtherDemand {
+  /** @type {number[]} */
+  #falls = [];
+
+  #lastFreeBytes = 0;
+
+  #lastHeldBytes = 0;
+
+  /**
+   * Take a reading, and answer what to reserve for others.
+   *
+   * @param {number} freeBytes - What the machine says is free now.
+   * @param {number} heldBytes - What the stores hold of this resource now.
+   * @returns {number} The reserve, in bytes.
+   */
+  note(freeBytes, heldBytes) {
+    if (this.#lastFreeBytes > 0) {
+      const fell = this.#lastFreeBytes - freeBytes;
+      const ours = heldBytes - this.#lastHeldBytes;
+      this.#falls.push(Math.max(0, fell - ours));
+      if (this.#falls.length > OTHER_DEMAND_SAMPLES) {
+        this.#falls.shift();
+      }
+    }
+    this.#lastFreeBytes = freeBytes;
+    this.#lastHeldBytes = heldBytes;
+    return this.reserve();
+  }
+
+  /** @returns {number} */
+  reserve() {
+    return this.#falls.length === 0 ? 0 : Math.max(...this.#falls);
+  }
+
+  /** Forget the readings. For tests, which share a module. */
+  forget() {
+    this.#falls = [];
+    this.#lastFreeBytes = 0;
+    this.#lastHeldBytes = 0;
+  }
+}
+
+/**
+ * How much of the resource the stores may hold between them.
+ *
+ * What the machine reports free is what could be taken ON TOP of what is
+ * already held, so the stores' own bytes are added back: the pair is the
+ * ceiling the stores could reach.
+ *
+ * @param {number} freeBytes
+ * @param {number} heldBytes
+ * @param {number} reserveBytes
+ * @returns {number}
+ */
+export function machineAllowanceBytes(freeBytes, heldBytes, reserveBytes) {
+  return Math.max(0, Math.max(freeBytes, 0) + Math.max(heldBytes, 0) - Math.max(reserveBytes, 0));
+}
+
+/**
+ * Divide what the machine allows between the stores, by what each is asking
+ * for.
+ *
+ * When everyone's ask fits, everyone gets it and the machine's limit never
+ * binds. When the asks do not fit, each store is cut in proportion to what it
+ * asked, so a store wanting little is not cut to make room for one wanting
+ * much.
+ *
+ * @param {number[]} wantedBytes - What each store is asking for, in order.
+ * @param {number} allowanceBytes
+ * @returns {number[]} What each store may hold, in the same order.
+ */
+export function divideAllowance(wantedBytes, allowanceBytes) {
+  const total = wantedBytes.reduce((sum, want) => sum + Math.max(0, want), 0);
+  if (total <= allowanceBytes || total === 0) {
+    return wantedBytes.map((want) => Math.max(0, want));
+  }
+  return wantedBytes.map((want) => Math.floor(allowanceBytes * (Math.max(0, want) / total)));
+}

package/services/storage/core-dumps.js

@@ -1,106 +1,106 @@
-/**
- * @file Keep the last few core dumps and no more.
- *
- * A native fault on the torrent worker writes the whole address space out: on
- * the field host that is **4.18 GB each**, and four of them had nearly filled a
- * 235 GB disk by 2026-08-21. The dumps are worth having — the one read that day
- * named a fault three days of reasoning had not — but only the recent ones are,
- * and a full disk costs more than an old dump is worth.
- *
- * Deliberately not "delete them all": the newest are the evidence for the fault
- * that is still open (roadmap item 7).
- */
-
-import { readdir, rm, stat } from "node:fs/promises";
-import path from "node:path";
-
-import { logger } from "../../utils/logger.js";
-
-/** How many to keep, newest first. */
-export const CORE_DUMPS_KEPT = 2;
-
-/**
- * Which dumps to remove, given what is there.
- *
- * Pure, so the rule can be tested without a filesystem: newest first by the
- * time they were written, keep `keep`, name the rest.
- *
- * @param {Array<{ name: string, writtenAt: number }>} dumps
- * @param {number} [keep]
- * @returns {string[]} Names to delete, oldest first.
- */
-export function dumpsToRemove(dumps, keep = CORE_DUMPS_KEPT) {
-  const sorted = [...(Array.isArray(dumps) ? dumps : [])]
-    .filter((dump) => typeof dump?.name === "string" && Number.isFinite(dump?.writtenAt))
-    .sort((left, right) => right.writtenAt - left.writtenAt);
-  return sorted.slice(Math.max(0, keep)).map((dump) => dump.name).reverse();
-}
-
-/**
- * Whether a file name is a core dump this host wrote.
- *
- * The kernel's pattern on the addon host produces `core.<thread>.<pid>.<epoch>`
- * — every one seen so far is `core.WorkerThread.81.…`, the thread the torrent
- * client runs on. Matched loosely on the `core.` prefix so a differently
- * configured host is still swept.
- *
- * @param {string} name
- * @returns {boolean}
- */
-export function isCoreDump(name) {
-  return typeof name === "string" && /^core\.[^/\\]+$/.test(name);
-}
-
-/**
- * Delete all but the newest few core dumps in `dir`.
- *
- * Best-effort and never fatal: a proxy that cannot tidy its dumps still has to
- * serve video.
- *
- * @param {string} dir
- * @param {number} [keep]
- * @returns {Promise<void>}
- */
-export async function pruneCoreDumps(dir, keep = CORE_DUMPS_KEPT) {
-  if (typeof dir !== "string" || dir.length === 0) {
-    return;
-  }
-  /** @type {Array<{ name: string, writtenAt: number, bytes: number }>} */
-  const dumps = [];
-  try {
-    for (const name of await readdir(dir)) {
-      if (!isCoreDump(name)) {
-        continue;
-      }
-      try {
-        const info = await stat(path.join(dir, name));
-        if (info.isFile()) {
-          dumps.push({ name, writtenAt: info.mtimeMs, bytes: info.size });
-        }
-      } catch {
-        // silent-ok: it went away between listing and reading, which is the
-        // outcome this function wanted anyway.
-      }
-    }
-  } catch {
-    return; // No such directory, or unreadable. Nothing to tidy.
-  }
-  if (dumps.length === 0) {
-    return;
-  }
-  const doomed = dumpsToRemove(dumps, keep);
-  const freed = dumps
-    .filter((dump) => doomed.includes(dump.name))
-    .reduce((total, dump) => total + dump.bytes, 0);
-  for (const name of doomed) {
-    try {
-      await rm(path.join(dir, name), { force: true });
-    } catch {
-      // silent-ok: best effort, and the next start tries again.
-    }
-  }
-  logger.info(
-    `core dumps: ${dumps.length} present, keeping the newest ${Math.min(keep, dumps.length)}` +
-      (doomed.length > 0 ? `, removed ${doomed.length} (${(freed / 1e9).toFixed(2)} GB)` : "")
-  );
-}
+/**
+ * @file Keep the last few core dumps and no more.
+ *
+ * A native fault on the torrent worker writes the whole address space out: on
+ * the field host that is **4.18 GB each**, and four of them had nearly filled a
+ * 235 GB disk by 2026-08-21. The dumps are worth having — the one read that day
+ * named a fault three days of reasoning had not — but only the recent ones are,
+ * and a full disk costs more than an old dump is worth.
+ *
+ * Deliberately not "delete them all": the newest are the evidence for the fault
+ * that is still open (roadmap item 7).
+ */
+
+import { readdir, rm, stat } from "node:fs/promises";
+import path from "node:path";
+
+import { logger } from "../../utils/logger.js";
+
+/** How many to keep, newest first. */
+export const CORE_DUMPS_KEPT = 2;
+
+/**
+ * Which dumps to remove, given what is there.
+ *
+ * Pure, so the rule can be tested without a filesystem: newest first by the
+ * time they were written, keep `keep`, name the rest.
+ *
+ * @param {Array<{ name: string, writtenAt: number }>} dumps
+ * @param {number} [keep]
+ * @returns {string[]} Names to delete, oldest first.
+ */
+export function dumpsToRemove(dumps, keep = CORE_DUMPS_KEPT) {
+  const sorted = [...(Array.isArray(dumps) ? dumps : [])]
+    .filter((dump) => typeof dump?.name === "string" && Number.isFinite(dump?.writtenAt))
+    .sort((left, right) => right.writtenAt - left.writtenAt);
+  return sorted.slice(Math.max(0, keep)).map((dump) => dump.name).reverse();
+}
+
+/**
+ * Whether a file name is a core dump this host wrote.
+ *
+ * The kernel's pattern on the addon host produces `core.<thread>.<pid>.<epoch>`
+ * — every one seen so far is `core.WorkerThread.81.…`, the thread the torrent
+ * client runs on. Matched loosely on the `core.` prefix so a differently
+ * configured host is still swept.
+ *
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function isCoreDump(name) {
+  return typeof name === "string" && /^core\.[^/\\]+$/.test(name);
+}
+
+/**
+ * Delete all but the newest few core dumps in `dir`.
+ *
+ * Best-effort and never fatal: a proxy that cannot tidy its dumps still has to
+ * serve video.
+ *
+ * @param {string} dir
+ * @param {number} [keep]
+ * @returns {Promise<void>}
+ */
+export async function pruneCoreDumps(dir, keep = CORE_DUMPS_KEPT) {
+  if (typeof dir !== "string" || dir.length === 0) {
+    return;
+  }
+  /** @type {Array<{ name: string, writtenAt: number, bytes: number }>} */
+  const dumps = [];
+  try {
+    for (const name of await readdir(dir)) {
+      if (!isCoreDump(name)) {
+        continue;
+      }
+      try {
+        const info = await stat(path.join(dir, name));
+        if (info.isFile()) {
+          dumps.push({ name, writtenAt: info.mtimeMs, bytes: info.size });
+        }
+      } catch {
+        // silent-ok: it went away between listing and reading, which is the
+        // outcome this function wanted anyway.
+      }
+    }
+  } catch {
+    return; // No such directory, or unreadable. Nothing to tidy.
+  }
+  if (dumps.length === 0) {
+    return;
+  }
+  const doomed = dumpsToRemove(dumps, keep);
+  const freed = dumps
+    .filter((dump) => doomed.includes(dump.name))
+    .reduce((total, dump) => total + dump.bytes, 0);
+  for (const name of doomed) {
+    try {
+      await rm(path.join(dir, name), { force: true });
+    } catch {
+      // silent-ok: best effort, and the next start tries again.
+    }
+  }
+  logger.info(
+    `core dumps: ${dumps.length} present, keeping the newest ${Math.min(keep, dumps.length)}` +
+      (doomed.length > 0 ? `, removed ${doomed.length} (${(freed / 1e9).toFixed(2)} GB)` : "")
+  );
+}