diff --git a/src/inline-engine.ts b/src/inline-engine.ts index c156b0fa36..194c436b38 100644 --- a/src/inline-engine.ts +++ b/src/inline-engine.ts @@ -28,7 +28,6 @@ export const INLINE_ORIGIN = "http://billion-context.inline"; const INLINE_HOSTNAME = new URL(INLINE_ORIGIN).hostname; type FetchInput = string | URL | Request; -type BodyLike = string | URLSearchParams | Blob | ArrayBuffer | ArrayBufferView | ReadableStream | AsyncIterable; export interface InlineEngine { origin: string; @@ -69,22 +68,6 @@ function normalizeHeaderPairs(value: Record * undici recomputes length and framing from the actual stream. */ const HOP_HEADERS = new Set(["connection", "keep-alive", "proxy-authenticate", "proxy-authorization", "te", "trailer", "transfer-encoding", "upgrade", "host", "content-length"]); -async function bodyToBuffer(body: BodyLike | null | undefined): Promise { - if (body === null || body === undefined) return Buffer.alloc(0); - if (typeof body === "string") return Buffer.from(body); - if (body instanceof URLSearchParams) return Buffer.from(body.toString()); - if (body instanceof Blob) return Buffer.from(await body.arrayBuffer()); - if (body instanceof ArrayBuffer) return Buffer.from(body); - if (ArrayBuffer.isView(body)) return Buffer.from(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength)); - const iterator = (body as { [Symbol.asyncIterator]?: unknown })[Symbol.asyncIterator]; - if (typeof iterator === "function") { - const parts: Buffer[] = []; - for await (const chunk of body as AsyncIterable) parts.push(Buffer.from(chunk)); - return Buffer.concat(parts); - } - throw new Error(`inline engine: unsupported request body type ${Object.prototype.toString.call(body)}`); -} - /** Minimal duck-type of http.IncomingMessage covering everything the pipeline * reads: url/method/headers/socket identity plus the readBody event surface. * Body delivery is LAZY (microtask after listener registration) — readBody @@ -224,38 +207,27 @@ class InlineRes extends EventEmitter { } async function toInlineReq(input: FetchInput, init?: RequestInit): Promise { - let url: string; - let baseHeaders: Headers | [string, string][] | Record | undefined; - let requestMethod: string | undefined; - let requestBody: BodyLike | null | undefined; - if (typeof input === "string") url = input; - else if (input instanceof URL) url = input.href; - else { - url = input.url; - baseHeaders = input.headers; - requestMethod = input.method; - requestBody = await input.arrayBuffer().catch(() => null); - } - const headers = new Headers(baseHeaders); - if (init?.headers !== undefined) new Headers(init.headers).forEach((v, k) => headers.set(k, v)); + // Only normalize body/header semantics here; the dispatcher owns and + // detaches the caller's cancellation listener. A dependent Request signal + // would leave a second listener behind. Inherit dictionary members so + // prototype and non-enumerable RequestInit fields retain Fetch semantics. + const request = new Request(input, Object.create(init ?? null, { signal: { value: null } }) as RequestInit); const headerMap: Record = {}; - headers.forEach((value, key) => { + request.headers.forEach((value, key) => { const existing = headerMap[key]; headerMap[key] = existing === undefined ? value : Array.isArray(existing) ? [...existing, value] : [existing, value]; }); - const method = (init?.method ?? requestMethod ?? "GET").toUpperCase(); - const bodySource = init?.body !== undefined ? init.body as BodyLike | null : requestBody; - const body = await bodyToBuffer(bodySource); + const body = Buffer.from(await request.arrayBuffer()); // The pipeline reads req.url as an ORIGIN-FORM request target ("/bili/…" — // what node:http hands a server for a normal connection). An absolute-form // URL would fall into resolveUpstream's forward-proxy branch and be routed // to its own authority — the pseudo-origin — instead of the embedded host. - const parsed = new URL(url); + const parsed = new URL(request.url); // Pseudo-origin traffic is same-process by definition — present the // loopback identity so the admin surface's DNS-rebinding Host gate passes // without weakening the gate itself. Other origins keep their real host. if (headerMap["host"] === undefined) headerMap["host"] = parsed.hostname === INLINE_HOSTNAME ? "127.0.0.1" : parsed.host; - return new InlineReq(parsed.pathname + parsed.search, method, headerMap, body); + return new InlineReq(parsed.pathname + parsed.search, request.method, headerMap, body); } function responseFrom(res: InlineRes): Response { diff --git a/tests/e2e/e2e-update-state.test.ts b/tests/e2e/e2e-update-state.test.ts index 03f2b1db22..e31baf7659 100644 --- a/tests/e2e/e2e-update-state.test.ts +++ b/tests/e2e/e2e-update-state.test.ts @@ -299,6 +299,11 @@ test("self-update keeps live compression state: folds survive the OLD→NEW hop envBase.BILI_UPDATE_POLICY_URL = "http://127.0.0.1:1/no-policy.json"; envBase.BILI_PERSIST_DEBOUNCE_MS = "200"; envBase.BILI_SESSIONS_DIR = sessionsDir; + // Pure-sqlite default (5a80e2b8e, #6480) turns the JSON envelope + // writer OFF, but this lane asserts on the on-disk .json session file + // (state survival across the update). Pin the writer ON so the + // envelope this test was written for is still produced. + envBase.BILI_STORAGE_JSON_WRITER = "on"; const port = await freePort(); proxy = spawnProxy(installDir, port, envBase); diff --git a/tests/inline-request-init.test.ts b/tests/inline-request-init.test.ts new file mode 100644 index 0000000000..6697554281 --- /dev/null +++ b/tests/inline-request-init.test.ts @@ -0,0 +1,274 @@ +import { after, test } from "node:test"; +import assert from "node:assert/strict"; +import { getEventListeners } from "node:events"; +import http from "node:http"; +import type { AddressInfo } from "node:net"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; + +const root = fs.mkdtempSync(path.join(os.tmpdir(), "bili-inline-request-init-")); +const previous = new Map(); +for (const name of ["XDG_DATA_HOME", "XDG_STATE_HOME", "XDG_CONFIG_HOME"]) { + previous.set(name, process.env[name]); + process.env[name] = path.join(root, name); +} +const { getInlineEngine, INLINE_ORIGIN, _resetInlineEngineForTest } = await import("../src/inline-engine.ts"); +const engine = await getInlineEngine(); +let hits = 0; +const streamResponses: http.ServerResponse[] = []; +const upstream = http.createServer((req, res) => { + const chunks: Buffer[] = []; + req.on("data", chunk => chunks.push(Buffer.from(chunk))); + req.on("end", () => { + hits++; + if (req.url === "/signal-stream") { + streamResponses.push(res); + res.writeHead(200, { "content-type": "text/plain" }); + res.write("first"); + return; + } + res.writeHead(200, { "content-type": "application/json" }); + res.end(JSON.stringify({ method: req.method, headers: req.headers, body: Buffer.concat(chunks).toString() })); + }); +}); +await new Promise(resolve => upstream.listen(0, "127.0.0.1", resolve)); +const target = `${INLINE_ORIGIN}/bili/http://127.0.0.1:${(upstream.address() as AddressInfo).port}/echo`; +const streamTarget = target.replace(/\/echo$/, "/signal-stream"); +after(async () => { + upstream.closeAllConnections(); + await new Promise(resolve => upstream.close(() => resolve())); + _resetInlineEngineForTest(); + for (const [name, value] of previous) { + if (value === undefined) delete process.env[name]; + else process.env[name] = value; + } + fs.rmSync(root, { recursive: true, force: true }); +}); + +interface Echo { method: string; headers: Record; body: string } +async function dispatch(input: string | URL | Request, init?: RequestInit): Promise { + const response = await engine.dispatch(input, init, globalThis.fetch); + assert.equal(response.status, 200); + return await response.json() as Echo; +} +function original(): Request { + return new Request(target, { method: "POST", headers: { authorization: "Bearer original", "x-original": "old", "content-type": "application/custom" }, body: "original" }); +} + +const headerCases: [string, NonNullable][] = [ + ["empty object", {}], + ["object", { "x-replacement": "new" }], + ["Headers", new Headers({ "x-replacement": "new" })], + ["tuples", [["x-replacement", "new"]]], +]; +for (const [name, headers] of headerCases) { + test(`RequestInit headers replace Request headers (${name})`, async () => { + const result = await dispatch(original(), { headers }); + assert.equal(result.headers.authorization, undefined); + assert.equal(result.headers["x-original"], undefined); + assert.equal(result.headers["content-type"], undefined); + assert.equal(result.headers["x-replacement"], new Headers(headers).get("x-replacement") ?? undefined); + assert.equal(result.body, "original"); + }); +} + +for (const body of [undefined, null]) { + test(`a ${body} body override inherits the Request body`, async () => { + const input = original(); + const result = await dispatch(input, { body }); + assert.equal(result.body, "original"); + assert.equal(result.headers.authorization, "Bearer original"); + assert.equal(input.bodyUsed, true); + }); +} + +for (const body of ["replacement", ""]) { + test(`an explicit ${body ? "nonempty" : "empty"} body override does not consume the original`, async () => { + const input = original(); + const result = await dispatch(input, { body }); + assert.equal(result.body, body); + assert.equal(await input.text(), "original"); + }); +} + +test("a body override does not wait for an unused original stream", { timeout: 10_000 }, async () => { + let finish!: () => void; + const body = new ReadableStream({ start(controller) { finish = () => controller.close(); } }); + const input = new Request(target, { method: "POST", body, duplex: "half" } as RequestInit); + const request = dispatch(input, { body: "replacement" }); + let timedOut = false; + const timeout = setTimeout(() => { timedOut = true; finish(); }, 1000); + try { + assert.equal((await request).body, "replacement"); + assert.equal(timedOut, false, "the overridden body must never delay dispatch"); + assert.equal(input.bodyUsed, false); + } finally { + clearTimeout(timeout); + if (!timedOut) finish(); + } +}); + +test("a consumed Request body fails before any upstream call", async () => { + const input = original(); + await input.text(); + const before = hits; + await assert.rejects(dispatch(input), TypeError); + assert.equal(hits, before); +}); + +test("a failing Request body propagates its error without sending an empty request", async () => { + const failure = new Error("source stream failed"); + const body = new ReadableStream({ start(controller) { controller.error(failure); } }); + const input = new Request(target, { method: "POST", body, duplex: "half" } as RequestInit); + const before = hits; + await assert.rejects(dispatch(input), error => error === failure); + assert.equal(hits, before); +}); + +test("explicit body replacement permits a previously consumed Request", async () => { + const input = original(); + await input.text(); + assert.equal((await dispatch(input, { body: "replacement" })).body, "replacement"); +}); + +test("string and URL inputs retain fetch body encoding and inferred content types", async () => { + for (const input of [target, new URL(target)]) { + const text = await dispatch(input, { method: "POST", body: "hello" }); + assert.equal(text.body, "hello"); + assert.equal(text.headers["content-type"], "text/plain;charset=UTF-8"); + const form = await dispatch(input, { method: "POST", body: new URLSearchParams({ query: "中文 & hello" }) }); + assert.equal(form.body, "query=%E4%B8%AD%E6%96%87+%26+hello"); + assert.equal(form.headers["content-type"], "application/x-www-form-urlencoded;charset=UTF-8"); + } +}); + +test("FormData receives the matching multipart boundary", async () => { + const form = new FormData(); + form.set("prompt", "hello"); + form.set("file", new Blob(["content"], { type: "text/plain" }), "notes.txt"); + const result = await dispatch(target, { method: "POST", body: form }); + const boundary = result.headers["content-type"]?.match(/^multipart\/form-data; boundary=(.+)$/)?.[1]; + assert.ok(boundary); + assert.ok(result.body.startsWith(`--${boundary}\r\n`)); + assert.ok(result.body.includes('name="file"; filename="notes.txt"')); + assert.ok(result.body.includes("content\r\n")); +}); + +test("GET body validation rejects before reaching the upstream", async () => { + const before = hits; + await assert.rejects(dispatch(target, { method: "GET", body: "invalid" }), TypeError); + assert.equal(hits, before); +}); + +async function openStream(input: string | URL | Request, init?: RequestInit) { + const response = await engine.dispatch(input, init, globalThis.fetch); + const reader = response.body!.getReader(); + assert.equal(Buffer.from((await reader.read()).value!).toString(), "first"); + return { reader, source: streamResponses.at(-1)! }; +} + +async function finishStream(stream: Awaited>): Promise { + stream.source.end("last"); + let tail = ""; + for (;;) { + const chunk = await stream.reader.read(); + if (chunk.done) break; + tail += Buffer.from(chunk.value).toString(); + } + assert.equal(tail, "last"); +} + +async function closeStream(stream: Awaited>): Promise { + if (!stream.source.writableEnded) stream.source.end(); + await stream.reader.cancel().catch(() => {}); +} + +for (const kind of ["string", "URL"] as const) { + test(`normalizing a ${kind} input leaves cancellation with the dispatcher`, async () => { + const controller = new AbortController(); + const ownListener = (): void => {}; + controller.signal.addEventListener("abort", ownListener); + const stream = await openStream(kind === "string" ? streamTarget : new URL(streamTarget), { signal: controller.signal }); + try { + assert.equal(getEventListeners(controller.signal, "abort").length, 2, "only the caller and dispatcher own listeners"); + await finishStream(stream); + assert.deepEqual(getEventListeners(controller.signal, "abort"), [ownListener]); + } finally { + controller.abort(); + await closeStream(stream); + } + }); +} + +test("normalizing a Request does not retain a dependency on its signal", async () => { + const controller = new AbortController(); + const input = new Request(streamTarget, { signal: controller.signal }); + const before = getEventListeners(input.signal, "abort"); + const stream = await openStream(input); + try { + // Request-only dispatch signal inheritance is a separate transport + // concern; the temporary body/header normalizer must not own it. + await finishStream(stream); + assert.deepEqual(getEventListeners(input.signal, "abort"), before); + } finally { + controller.abort(); + await closeStream(stream); + } +}); + +test("an explicit init signal owns cancellation instead of the Request signal", async () => { + const original = new AbortController(); + const replacement = new AbortController(); + const input = new Request(streamTarget, { signal: original.signal }); + const stream = await openStream(input, { signal: replacement.signal }); + try { + assert.equal(getEventListeners(input.signal, "abort").length, 0); + assert.equal(getEventListeners(replacement.signal, "abort").length, 1); + original.abort(new Error("original request cancelled")); + assert.equal(replacement.signal.aborted, false); + replacement.abort(new Error("effective signal cancelled")); + await assert.rejects(stream.reader.read(), /client aborted/); + assert.equal(getEventListeners(replacement.signal, "abort").length, 0); + } finally { + original.abort(); + replacement.abort(); + await closeStream(stream); + } +}); + +test("an explicit null signal keeps an aborted Request override independent", async () => { + const original = new AbortController(); + const input = new Request(streamTarget, { signal: original.signal }); + original.abort(new Error("overridden request cancellation")); + const stream = await openStream(input, { signal: null }); + try { + await finishStream(stream); + assert.equal(getEventListeners(input.signal, "abort").length, 0); + } finally { await closeStream(stream); } +}); + +test("a body read failure does not retain the init signal before dispatch starts", async () => { + const controller = new AbortController(); + const failure = new Error("normalization body failed"); + const body = new ReadableStream({ start(stream) { stream.error(failure); } }); + const before = hits; + try { + await assert.rejects(dispatch(target, { method: "POST", body, duplex: "half", signal: controller.signal } as RequestInit), error => error === failure); + assert.equal(hits, before); + assert.equal(getEventListeners(controller.signal, "abort").length, 0); + } finally { controller.abort(); } +}); + +for (const kind of ["inherited", "non-enumerable"] as const) { + test(`RequestInit keeps ${kind} body, method, and header members`, async () => { + const fields: RequestInit = { method: "POST", body: "dictionary body", headers: { "x-dictionary": kind } }; + const init: RequestInit = kind === "inherited" + ? Object.create(fields) as RequestInit + : Object.create(null, Object.fromEntries(Object.entries(fields).map(([key, value]) => [key, { value }]))) as RequestInit; + const result = await dispatch(target, init); + assert.equal(result.method, "POST"); + assert.equal(result.body, "dictionary body"); + assert.equal(result.headers["x-dictionary"], kind); + }); +}