Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix(media-server): restore the audio stream idle timeout on its first chunk instead of on return

Richie McIlroy98c2cbd94342
diff --git a/apps/media-server/src/__tests__/lib/lifecycle.test.ts b/apps/media-server/src/__tests__/lib/lifecycle.test.ts
index bd6f9454c..bf1aa4f7e 100644
--- a/apps/media-server/src/__tests__/lib/lifecycle.test.ts
+++ b/apps/media-server/src/__tests__/lib/lifecycle.test.ts
@@ -7,6 +7,7 @@ import {
getShutdownGraceMs,
isDraining,
isIdle,
+ restoreIdleTimeoutOnFirstChunk,
setDraining,
setRequestIdleTimeout,
trackBackgroundTask,
@@ -172,3 +173,35 @@ describe("shutdown handler", () => {
await task;
});
});
+
+describe("streamed response idle timeout", () => {
+ test("comes back once, on the first chunk, and cancel still reaches the source", async () => {
+ let restores = 0;
+ let cancelled = false;
+ let push: ReadableStreamDefaultController<Uint8Array> | undefined;
+ const source = new ReadableStream<Uint8Array>({
+ start(controller) {
+ push = controller;
+ },
+ cancel() {
+ cancelled = true;
+ },
+ });
+ const reader = restoreIdleTimeoutOnFirstChunk(source, () => {
+ restores++;
+ }).getReader();
+
+ const first = reader.read();
+ await Bun.sleep(10);
+ expect(restores).toBe(0);
+
+ push?.enqueue(new Uint8Array([1]));
+ expect((await first).value).toEqual(new Uint8Array([1]));
+ push?.enqueue(new Uint8Array([2]));
+ await reader.read();
+ expect(restores).toBe(1);
+
+ await reader.cancel();
+ expect(cancelled).toBe(true);
+ });
+});
diff --git a/apps/media-server/src/lib/lifecycle.ts b/apps/media-server/src/lib/lifecycle.ts
index d23ff92ff..fd60e537a 100644
--- a/apps/media-server/src/lib/lifecycle.ts
+++ b/apps/media-server/src/lib/lifecycle.ts
@@ -30,6 +30,26 @@ export function getIdleTimeoutSeconds(): number {
: MAX_IDLE_TIMEOUT_SECONDS;
}
+// A streamed response can stay silent while ffmpeg opens its input, so the
+// idle timeout only comes back once the first bytes are on their way.
+export function restoreIdleTimeoutOnFirstChunk(
+ stream: ReadableStream<Uint8Array>,
+ restore: () => void,
+): ReadableStream<Uint8Array> {
+ let restored = false;
+ return stream.pipeThrough(
+ new TransformStream<Uint8Array, Uint8Array>({
+ transform(chunk, controller) {
+ if (!restored) {
+ restored = true;
+ restore();
+ }
+ controller.enqueue(chunk);
+ },
+ }),
+ );
+}
+
type IdleTimeoutServer = {
timeout?: (request: Request, seconds: number) => void;
};
diff --git a/apps/media-server/src/routes/audio.ts b/apps/media-server/src/routes/audio.ts
index 29245155f..bd4c3a12c 100644
--- a/apps/media-server/src/routes/audio.ts
+++ b/apps/media-server/src/routes/audio.ts
@@ -6,6 +6,7 @@ import {
DRAINING_DETAILS,
getIdleTimeoutSeconds,
isDraining,
+ restoreIdleTimeoutOnFirstChunk,
setRequestIdleTimeout,
} from "../lib/lifecycle";
import {
@@ -146,6 +147,9 @@ audio.post("/extract", async (c) => {
const { videoUrl, stream: useStreaming } = result.data;
if (isDraining()) return drainingResponse(c);
setRequestIdleTimeout(c.env, c.req.raw, 0);
+ const restoreIdleTimeout = () =>
+ setRequestIdleTimeout(c.env, c.req.raw, getIdleTimeoutSeconds());
+ let streaming = false;
try {
const hasAudio = await checkHasAudioTrack(videoUrl);
@@ -163,12 +167,16 @@ audio.post("/extract", async (c) => {
cleanup();
});
- return new Response(stream, {
- headers: {
- "Content-Type": "audio/mpeg",
- "Transfer-Encoding": "chunked",
+ streaming = true;
+ return new Response(
+ restoreIdleTimeoutOnFirstChunk(stream, restoreIdleTimeout),
+ {
+ headers: {
+ "Content-Type": "audio/mpeg",
+ "Transfer-Encoding": "chunked",
+ },
},
- });
+ );
}
const audioData = await extractAudio(videoUrl);
@@ -213,9 +221,7 @@ audio.post("/extract", async (c) => {
500,
);
} finally {
- // Only the setup above can sit silent; once bytes flow, a dead client
- // should be reaped again.
- setRequestIdleTimeout(c.env, c.req.raw, getIdleTimeoutSeconds());
+ if (!streaming) restoreIdleTimeout();
}
});
@@ -241,6 +247,9 @@ audio.post("/convert", async (c) => {
const { audioUrl, bitrate } = result.data;
if (isDraining()) return drainingResponse(c);
setRequestIdleTimeout(c.env, c.req.raw, 0);
+ const restoreIdleTimeout = () =>
+ setRequestIdleTimeout(c.env, c.req.raw, getIdleTimeoutSeconds());
+ let streaming = false;
try {
const { stream, cleanup } = extractAudioStream(audioUrl, {
@@ -252,12 +261,16 @@ audio.post("/convert", async (c) => {
cleanup();
});
- return new Response(stream, {
- headers: {
- "Content-Type": "audio/mpeg",
- "Transfer-Encoding": "chunked",
+ streaming = true;
+ return new Response(
+ restoreIdleTimeoutOnFirstChunk(stream, restoreIdleTimeout),
+ {
+ headers: {
+ "Content-Type": "audio/mpeg",
+ "Transfer-Encoding": "chunked",
+ },
},
- });
+ );
} catch (err) {
console.error("[audio/convert] Error:", err);
@@ -292,9 +305,7 @@ audio.post("/convert", async (c) => {
500,
);
} finally {
- // Only the setup above can sit silent; once bytes flow, a dead client
- // should be reaped again.
- setRequestIdleTimeout(c.env, c.req.raw, getIdleTimeoutSeconds());
+ if (!streaming) restoreIdleTimeout();
}
});