twotalesanimation
211 lines
9.0 KiB
TypeScript
211 lines
9.0 KiB
TypeScript
import { NextRequest, NextResponse } from "next/server";
|
||
import fs from "fs";
|
||
import path from "path";
|
||
import { generateHetznerStreamUrl, hetznerKeyExists } from "@/lib/storage";
|
||
|
||
// ── Tuning constants ──────────────────────────────────────────────────────────
|
||
//
|
||
// CHUNK_SIZE — maximum bytes returned per Range response.
|
||
//
|
||
// Target workload: 2–20 s H.264 MP4 clips at 30–50 Mbps = ~7–125 MB per file,
|
||
// 1–3 concurrent reviewers on a LAN/office network.
|
||
//
|
||
// At 2 MB each chunk:
|
||
// • A 7 MB clip (2 s @ 30 Mbps) arrives in ~4 requests.
|
||
// • A 75 MB clip (20 s @ 30 Mbps) needs ~38 requests total.
|
||
// • A 125 MB clip (20 s @ 50 Mbps) needs ~63 requests total.
|
||
//
|
||
// Keeps time-to-first-frame low: the player can start after the first
|
||
// 2 MB chunk rather than waiting for a full 8 MB download.
|
||
const CHUNK_SIZE = 2 * 1024 * 1024; // 2 MB
|
||
|
||
// READ_HIGH_WATER_MARK — libuv/Node.js internal read-buffer size per stream.
|
||
//
|
||
// Default is 64 KB, meaning an 8 MB chunk requires ~128 kernel→userspace copy
|
||
// iterations. 512 KB reduces that to ~16 iterations, lowering V8 GC pressure
|
||
// and improving throughput for large sequential reads. Still small enough that
|
||
// 3 concurrent streams only hold ~1.5 MB of read buffers in total.
|
||
const READ_HIGH_WATER_MARK = 512 * 1024; // 512 KB
|
||
|
||
export async function GET(
|
||
req: NextRequest,
|
||
{ params }: { params: Promise<{ key: string[] }> }
|
||
) {
|
||
const { key } = await params;
|
||
// key is a catch-all segment array, e.g. ["videos", "uuid-filename.mp4"]
|
||
const relativePath = key.join("/");
|
||
|
||
// ── Path traversal sanitisation ───────────────────────────────────────────
|
||
const uploadDir = path.resolve(process.env.LOCAL_UPLOAD_DIR ?? "./uploads");
|
||
const filePath = path.resolve(path.join(uploadDir, relativePath));
|
||
|
||
// Append path.sep so "/uploads2/evil.mp4".startsWith("/uploads") cannot
|
||
// pass — the resolved path must be strictly inside the upload directory.
|
||
if (!filePath.startsWith(uploadDir + path.sep)) {
|
||
return new NextResponse("Forbidden", { status: 403 });
|
||
}
|
||
|
||
// ── Storage routing ───────────────────────────────────────────────────────
|
||
// Videos: check Hetzner first — bypasses ISP throttling for large streams.
|
||
// Fallback to local disk if the file hasn't been migrated yet.
|
||
// Images / other assets: local disk only — avoids presigned-URL 400 errors
|
||
// seen on Hetzner for non-video content.
|
||
const videoExts = new Set([".mp4", ".mov", ".avi", ".mxf", ".webm"]);
|
||
const isVideo = videoExts.has(path.extname(relativePath).toLowerCase());
|
||
|
||
if (isVideo) {
|
||
try {
|
||
if (await hetznerKeyExists(relativePath)) {
|
||
const hetznerUrl = await generateHetznerStreamUrl(relativePath, 3600);
|
||
return NextResponse.redirect(hetznerUrl, 302);
|
||
}
|
||
} catch {
|
||
// Hetzner unavailable — fall through to local disk
|
||
}
|
||
}
|
||
|
||
// Local disk (all non-video files, and video files not yet on Hetzner)
|
||
let stat: fs.Stats;
|
||
try {
|
||
stat = fs.statSync(filePath);
|
||
} catch {
|
||
// Not on local disk and not a video served above — try Hetzner as last resort
|
||
try {
|
||
const hetznerUrl = await generateHetznerStreamUrl(relativePath, 3600);
|
||
|
||
if (isVideo) {
|
||
// Videos aren't rendered through next/image — a redirect lets the
|
||
// browser/<video> stream directly from Hetzner (range requests,
|
||
// no extra hop through this server).
|
||
return NextResponse.redirect(hetznerUrl, 302);
|
||
}
|
||
|
||
// Images/other assets may be requested by Next's built-in image
|
||
// optimizer (/_next/image) for thumbnails. That optimizer does NOT
|
||
// follow redirects on this Next.js version (`images.maximumRedirects`
|
||
// only exists in much newer Next releases) and returns a bare 400 for
|
||
// any 3xx response. Proxy the bytes through instead so the optimizer
|
||
// (and any other consumer) sees a normal 200 response.
|
||
const upstream = await fetch(hetznerUrl);
|
||
if (!upstream.ok || !upstream.body) {
|
||
return new NextResponse("Not found", { status: 404 });
|
||
}
|
||
const proxyHeaders = new Headers();
|
||
const upstreamType = upstream.headers.get("content-type");
|
||
const upstreamLength = upstream.headers.get("content-length");
|
||
if (upstreamType) proxyHeaders.set("Content-Type", upstreamType);
|
||
if (upstreamLength) proxyHeaders.set("Content-Length", upstreamLength);
|
||
proxyHeaders.set("Cache-Control", "public, max-age=3600, immutable");
|
||
return new NextResponse(upstream.body, { status: 200, headers: proxyHeaders });
|
||
} catch {
|
||
return new NextResponse("Not found", { status: 404 });
|
||
}
|
||
}
|
||
|
||
// Guard against directory traversal that resolves to a directory
|
||
if (!stat.isFile()) {
|
||
return new NextResponse("Not found", { status: 404 });
|
||
}
|
||
|
||
// ── Content-Type ──────────────────────────────────────────────────────────
|
||
const ext = path.extname(filePath).toLowerCase();
|
||
const mimeMap: Record<string, string> = {
|
||
".mp4": "video/mp4",
|
||
".mov": "video/quicktime",
|
||
".avi": "video/x-msvideo",
|
||
".mxf": "application/mxf",
|
||
".webm": "video/webm",
|
||
};
|
||
const contentType = mimeMap[ext] ?? "application/octet-stream";
|
||
|
||
// ── Caching headers ───────────────────────────────────────────────────────
|
||
// ETag: stable because uploaded files are immutable — re-uploads produce
|
||
// a new UUID filename, so mtime and size never change for a given path.
|
||
const etag = `"${stat.size.toString(36)}-${stat.mtimeMs.toString(36)}"`;
|
||
const lastModified = stat.mtime.toUTCString();
|
||
|
||
const sharedHeaders = {
|
||
"Content-Type": contentType,
|
||
"Accept-Ranges": "bytes",
|
||
"Cache-Control": "public, max-age=3600, immutable",
|
||
"ETag": etag,
|
||
"Last-Modified": lastModified,
|
||
};
|
||
|
||
const rangeHeader = req.headers.get("range");
|
||
|
||
// ── Range request path (RFC 7233) ─────────────────────────────────────────
|
||
if (rangeHeader) {
|
||
// RFC 7233 §3.2 — If-Range: only honour Range if the representation is
|
||
// unchanged. If the validator doesn't match, fall through to a full 200.
|
||
const ifRange = req.headers.get("if-range");
|
||
const rangeIsValid = !ifRange || ifRange === etag || ifRange === lastModified;
|
||
|
||
if (rangeIsValid) {
|
||
// Parse "bytes=<start>-<end>" with regex to handle surrounding whitespace
|
||
const rangeMatch = /bytes\s*=\s*(\d*)-(\d*)/i.exec(rangeHeader);
|
||
if (!rangeMatch) {
|
||
// Malformed Range header → 416 Range Not Satisfiable
|
||
return new NextResponse(null, {
|
||
status: 416,
|
||
headers: { ...sharedHeaders, "Content-Range": `bytes */${stat.size}` },
|
||
});
|
||
}
|
||
|
||
const start = rangeMatch[1] ? parseInt(rangeMatch[1], 10) : 0;
|
||
|
||
// RFC 7233 §2.1: start byte past EOF → 416
|
||
if (start >= stat.size) {
|
||
return new NextResponse(null, {
|
||
status: 416,
|
||
headers: { ...sharedHeaders, "Content-Range": `bytes */${stat.size}` },
|
||
});
|
||
}
|
||
|
||
// Cap end: honour explicit client requests but never exceed CHUNK_SIZE
|
||
// beyond start, and never past EOF.
|
||
const requestedEnd = rangeMatch[2] ? parseInt(rangeMatch[2], 10) : stat.size - 1;
|
||
const end = Math.min(requestedEnd, start + CHUNK_SIZE - 1, stat.size - 1);
|
||
const chunkSize = end - start + 1;
|
||
|
||
const stream = fs.createReadStream(filePath, {
|
||
start,
|
||
end,
|
||
highWaterMark: READ_HIGH_WATER_MARK,
|
||
}) as unknown as ReadableStream;
|
||
|
||
return new NextResponse(stream, {
|
||
status: 206,
|
||
headers: {
|
||
...sharedHeaders,
|
||
"Content-Range": `bytes ${start}-${end}/${stat.size}`,
|
||
"Content-Length": String(chunkSize),
|
||
},
|
||
});
|
||
}
|
||
// If-Range mismatch: fall through to full-file response below
|
||
}
|
||
|
||
// ── Full-file response (no Range header, or If-Range mismatch) ────────────
|
||
// RFC 7232: 304 Not Modified applies only to full-file (non-range) requests
|
||
const ifNoneMatch = req.headers.get("if-none-match");
|
||
const ifModifiedSince = req.headers.get("if-modified-since");
|
||
if (
|
||
(ifNoneMatch && ifNoneMatch === etag) ||
|
||
(!ifNoneMatch && ifModifiedSince && new Date(ifModifiedSince) >= stat.mtime)
|
||
) {
|
||
return new NextResponse(null, { status: 304 });
|
||
}
|
||
|
||
const stream = fs.createReadStream(filePath, {
|
||
highWaterMark: READ_HIGH_WATER_MARK,
|
||
}) as unknown as ReadableStream;
|
||
|
||
return new NextResponse(stream, {
|
||
headers: {
|
||
...sharedHeaders,
|
||
"Content-Length": String(stat.size),
|
||
},
|
||
});
|
||
}
|