@torrent-tv/proxy 2.86.0 → 2.87.0

package/routes/transcode/variant-file/get.js

@@ -13,15 +13,22 @@
  * no variant is ever asked for unless the viewer picked it.
  */
 
-import { serveSessionFile } from "../session-file/get.js";
+import {
+  consumerOf,
+  refusedAsStale,
+  replyAssignmentLost,
+  replyOutputUnavailable,
+  serveSessionFile,
+  statedGenerationOf
+} from "../session-file/get.js";
 
 /**
  * @param {import("fastify").FastifyRequest} req
  * @param {import("fastify").FastifyReply} reply
- * @param {{ hlsSessionManager: import("../../../services/hls-session-manager.js").HlsSessionManager }} deps
+ * @param {{ renditions: object, serving: object, viewerRequests: object }} deps
  * @returns {Promise<void>}
  */
-export async function handleTranscodeVariantFileGet(req, reply, { hlsSessionManager }) {
+export async function handleTranscodeVariantFileGet(req, reply, { renditions, serving, viewerRequests }) {
   const baseSessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
   const height = Number(req.params.height);
   const fileName = typeof req.params.fileName === "string" ? req.params.fileName : "";
@@ -29,13 +36,45 @@ export async function handleTranscodeVariantFileGet(req, reply, { hlsSessionMana
   // Which viewer is asking. Two viewers of one picture can be on two rungs, and
   // a segment request is what says which rung a viewer is watching — read as
   // the session's own, one of them would take the other off their step.
-  const consumerId = typeof req.query?.consumer === "string" ? req.query.consumer : "";
-  const resolved = await hlsSessionManager.resolveVariantFile(
+  const consumerId = consumerOf(req);
+  // Before resolving: resolving can make a step and registers this viewer on
+  // it, which a request for a viewing they have already left must not do.
+  if (refusedAsStale(req, reply, viewerRequests, fileName)) {
+    return reply;
+  }
+  const resolved = await renditions.resolveVariantFile(
     baseSessionId,
     height,
     fileName,
-    consumerId
+    consumerId,
+    // Which viewing this request was made in: a repeat within it is answered
+    // by whatever answered it the first time.
+    statedGenerationOf(req)
   );
+  if (resolved.unavailable) {
+    return replyOutputUnavailable(reply, resolved.unavailable);
+  }
+  if (resolved.lost) {
+    return replyAssignmentLost(reply, resolved.lost);
+  }
+  if (resolved.recover) {
+    // The very piece that was given, from what its gone output left in the
+    // store — held for as long as it is being sent, like any other answer.
+    const stored = await serving.storedPieceOf(resolved.recover.key, resolved.recover.likeId, fileName);
+    if (!stored) {
+      return replyAssignmentLost(reply, { reason: "the stored piece went while it was being fetched" });
+    }
+    const release = viewerRequests.holdResponseForKey(resolved.recover.key, consumerId);
+    reply.raw?.once?.("finish", release);
+    reply.raw?.once?.("close", release);
+    reply.raw?.once?.("error", release);
+    if (!reply.raw || reply.raw.destroyed || reply.raw.writableEnded) {
+      release();
+    }
+    reply.header("Cache-Control", "public, max-age=60");
+    reply.header("Content-Type", stored.contentType);
+    return reply.send(stored.stream);
+  }
   if (resolved.error) {
     // Preparing the variant failed — a probe, a keyframe index, an input that
     // is not there yet. Retryable, like every other not-ready answer on this
@@ -49,7 +88,8 @@ export async function handleTranscodeVariantFileGet(req, reply, { hlsSessionMana
   }
 
   return serveSessionFile(req, reply, {
-    hlsSessionManager,
+    serving,
+    viewerRequests,
     sessionId: resolved.sessionId,
     fileName
   });

package/routes/transcode/variant-warm/get.js

@@ -13,7 +13,8 @@
  * knowing there is something to fetch.
  */
 
-import { waitForSessionFile } from "../session-file/get.js";
+import { replyOutputUnavailable, waitForSessionFile } from "../session-file/get.js";
+import { OUTPUT_UNAVAILABLE } from "../../../services/encode/output/index.js";
 
 /** How long to hold the warm-up request before telling the caller to retry. */
 const WARM_WAIT_MS = 30_000;
@@ -21,10 +22,10 @@ const WARM_WAIT_MS = 30_000;
 /**
  * @param {import("fastify").FastifyRequest} req
  * @param {import("fastify").FastifyReply} reply
- * @param {{ hlsSessionManager: import("../../../services/hls-session-manager.js").HlsSessionManager }} deps
+ * @param {{ renditions: object, serving: object, viewerRequests: object }} deps
  * @returns {Promise<void>}
  */
-export async function handleTranscodeVariantWarmGet(req, reply, { hlsSessionManager }) {
+export async function handleTranscodeVariantWarmGet(req, reply, { renditions, serving, viewerRequests }) {
   const baseSessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
   const height = Number(req.params.height);
   const positionSeconds = Number(req.query?.position);
@@ -32,11 +33,22 @@ export async function handleTranscodeVariantWarmGet(req, reply, { hlsSessionMana
   if (!Number.isInteger(height) || height <= 0 || !Number.isFinite(positionSeconds) || positionSeconds < 0) {
     return reply.code(400).send({ error: "A height and a non-negative position are required." });
   }
+  // Whose warm-up this is. It was not passed at all, so every warm-up was
+  // written onto a nameless viewer instead of the person who asked for it.
+  const consumerId = typeof req.query?.consumer === "string" ? req.query.consumer : "";
+  if (!consumerId) {
+    return reply.code(400).send({ error: "A consumer is required." });
+  }
 
   let prepared;
   try {
-    prepared = await hlsSessionManager.prepareVariant(baseSessionId, height, positionSeconds);
+    prepared = await renditions.prepareVariant(baseSessionId, height, positionSeconds, consumerId);
   } catch (error) {
+    if (error?.code === OUTPUT_UNAVAILABLE) {
+      // Nothing at that height suits this viewer's link. Said at once and not
+      // as "retry": the page tells the viewer and keeps what is playing.
+      return replyOutputUnavailable(reply, error.details);
+    }
     const message = error instanceof Error ? error.message : String(error);
     reply.header("Retry-After", "1");
     return reply.code(503).send({ error: `Could not prepare the quality variant: ${message}` });
@@ -46,10 +58,10 @@ export async function handleTranscodeVariantWarmGet(req, reply, { hlsSessionMana
   }
 
   const result = await waitForSessionFile(
-    hlsSessionManager,
+    serving,
     prepared.sessionId,
     prepared.fileName,
-    WARM_WAIT_MS
+    { holdMs: WARM_WAIT_MS }
   );
   if (result.kind === "file") {
     // The bytes are not sent — the player fetches them itself the moment it

package/scripts/render-run-graph.js

@@ -103,7 +103,7 @@ export function renderRunGraphMarkdown() {
     "# The encoder run — states and transitions",
     "",
     "One run of one ffmpeg inside one transcode session. The table this is drawn",
-    "from is executed by `services/hls-session-manager.js`; every transition a real",
+    "from is executed by `services/encode/EncodeRuns.js`; every transition a real",
     "run makes is logged as state, event and target, so a run that takes an edge",
     "absent here is a violation the log names.",
     "",