Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix(media-server): restart ranged downloads as one stream when the first range is capped or unplaceable

Richie McIlroy08a9687c0677
diff --git a/apps/media-server/src/__tests__/lib/parallel-download.test.ts b/apps/media-server/src/__tests__/lib/parallel-download.test.ts
index 6fbb1254d..ce8290f87 100644
--- a/apps/media-server/src/__tests__/lib/parallel-download.test.ts
+++ b/apps/media-server/src/__tests__/lib/parallel-download.test.ts
@@ -26,6 +26,19 @@ beforeAll(async () => {
return new Response(payload, { headers: { ETag: '"v1"' } });
}
rangeRequests++;
+ if (url.pathname === "/no-total" || url.pathname === "/capped") {
+ const end =
+ url.pathname === "/capped" ? 64 * 1024 - 1 : Number(range[2]);
+ return new Response(payload.subarray(0, end + 1), {
+ status: 206,
+ headers: {
+ "Content-Range":
+ url.pathname === "/capped"
+ ? `bytes 0-${end}/${payload.length}`
+ : `bytes 0-${end}/*`,
+ },
+ });
+ }
if (url.pathname === "/huge") {
return new Response(payload.subarray(0, MB), {
status: 206,
@@ -124,6 +137,24 @@ describe("parallel download", () => {
).rejects.toThrow("Ranged download part failed: 412");
});
+ test.each(["no-total", "capped"])(
+ "restarts as one stream when the first range can't be used (%s)",
+ async (name) => {
+ const path = join(dir, `${name}.bin`);
+ const result = await downloadUrlToPathParallel(
+ `http://localhost:${server.port}/${name}`,
+ path,
+ { concurrency: 4, partBytes: MB },
+ );
+ expect(result).toEqual({
+ bytes: payload.length,
+ parts: 1,
+ ranged: false,
+ });
+ expect(Buffer.compare(await readFile(path), payload)).toBe(0);
+ },
+ );
+
test("rejects an absurd Content-Range total before planning parts", async () => {
const before = rangeRequests;
await expect(
diff --git a/apps/media-server/src/lib/parallel-download.ts b/apps/media-server/src/lib/parallel-download.ts
index fb97fbf7f..f582f3537 100644
--- a/apps/media-server/src/lib/parallel-download.ts
+++ b/apps/media-server/src/lib/parallel-download.ts
@@ -52,11 +52,19 @@ export function planRanges(
};
}
-function parseTotalFromContentRange(value: string | null): number | null {
+function parseContentRange(
+ value: string | null,
+): { start: number; end: number; total: number } | null {
const match = value?.match(/^bytes\s+(\d+)-(\d+)\/(\d+)$/i);
if (!match) return null;
- const total = Number(match[3]);
- return Number.isSafeInteger(total) ? total : null;
+ const [start, end, total] = match.slice(1).map(Number) as [
+ number,
+ number,
+ number,
+ ];
+ return Number.isSafeInteger(total) && start <= end && end < total
+ ? { start, end, total }
+ : null;
}
async function readInto(
@@ -107,44 +115,54 @@ export async function downloadUrlToPathParallel(
written += bytesWritten;
}
};
- try {
- const first = await fetchImpl(url, {
- headers: { Range: `bytes=0-${partBytes - 1}` },
- signal: options.signal,
- });
- if (!first.ok) {
- await first.body?.cancel().catch(() => {});
+ const controller = new AbortController();
+ const signal = options.signal
+ ? AbortSignal.any([options.signal, controller.signal])
+ : controller.signal;
+ const fetchOk = async (headers?: Record<string, string>) => {
+ const response = await fetchImpl(url, { headers, signal });
+ if (!response.ok) {
+ await response.body?.cancel().catch(() => {});
throw new Error(
- `Failed to download video: ${first.status} ${first.statusText}`,
+ `Failed to download video: ${response.status} ${response.statusText}`,
);
}
- const total =
- first.status === 206
- ? parseTotalFromContentRange(first.headers.get("content-range"))
- : null;
- if (total === null) {
+ return response;
+ };
+ try {
+ const first = await fetchOk({ Range: `bytes=0-${partBytes - 1}` });
+ if (first.status !== 206) {
const bytes = await readInto(first, write, 0, null);
return { bytes, parts: 1, ranged: false };
}
+ const range = parseContentRange(first.headers.get("content-range"));
+ if (
+ range === null ||
+ range.start !== 0 ||
+ range.end + 1 < Math.min(partBytes, range.total)
+ ) {
+ // A partial reply we can't place or that the server capped below our
+ // part size: start over as one stream rather than keep a fragment.
+ await first.body?.cancel().catch(() => {});
+ const bytes = await readInto(await fetchOk(), write, 0, null);
+ return { bytes, parts: 1, ranged: false };
+ }
+ const { total } = range;
if (total > MAX_RANGED_TOTAL_BYTES) {
await first.body?.cancel().catch(() => {});
throw new Error(`Ranged download reported an invalid size: ${total}`);
}
- const firstBytes = Math.min(partBytes, total);
+ const firstBytes = range.end + 1;
const etag = first.headers.get("etag");
const ranges = planRanges(total, firstBytes, partBytes);
- const controller = new AbortController();
- const signal = options.signal
- ? AbortSignal.any([options.signal, controller.signal])
- : controller.signal;
let next = 0;
const worker = async () => {
while (next < ranges.count) {
signal.throwIfAborted();
- const range = ranges.at(next++);
+ const part = ranges.at(next++);
const response = await fetchImpl(url, {
headers: {
- Range: `bytes=${range.start}-${range.end}`,
+ Range: `bytes=${part.start}-${part.end}`,
...(etag ? { "If-Match": etag } : {}),
},
signal,
@@ -155,12 +173,7 @@ export async function downloadUrlToPathParallel(
`Ranged download part failed: ${response.status} ${response.statusText}`,
);
}
- await readInto(
- response,
- write,
- range.start,
- range.end - range.start + 1,
- );
+ await readInto(response, write, part.start, part.end - part.start + 1);
}
};
const workers = Array.from(