mirror of
https://github.com/denoland/deno
synced 2024-09-13 21:31:18 +00:00
2857 lines
84 KiB
TypeScript
2857 lines
84 KiB
TypeScript
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
|
|
import { Buffer, BufReader, BufWriter } from "@std/io/mod.ts";
|
|
import { TextProtoReader } from "../testdata/run/textproto.ts";
|
|
import {
|
|
assert,
|
|
assertEquals,
|
|
assertRejects,
|
|
assertStrictEquals,
|
|
assertThrows,
|
|
delay,
|
|
fail,
|
|
} from "./test_util.ts";
|
|
import { join } from "@std/path/mod.ts";
|
|
|
|
const listenPort = 4507;
|
|
const listenPort2 = 4508;
|
|
|
|
const {
|
|
buildCaseInsensitiveCommaValueFinder,
|
|
// @ts-expect-error TypeScript (as of 3.7) does not support indexing namespaces by symbol
|
|
} = Deno[Deno.internal];
|
|
|
|
async function writeRequestAndReadResponse(conn: Deno.Conn): Promise<string> {
|
|
const encoder = new TextEncoder();
|
|
const decoder = new TextDecoder();
|
|
|
|
const w = new BufWriter(conn);
|
|
const r = new BufReader(conn);
|
|
const body = `GET / HTTP/1.1\r\nHost: 127.0.0.1:${listenPort}\r\n\r\n`;
|
|
const writeResult = await w.write(encoder.encode(body));
|
|
assertEquals(body.length, writeResult);
|
|
await w.flush();
|
|
const tpr = new TextProtoReader(r);
|
|
const statusLine = await tpr.readLine();
|
|
assert(statusLine !== null);
|
|
const headers = await tpr.readMimeHeader();
|
|
assert(headers !== null);
|
|
|
|
const chunkedReader = chunkedBodyReader(headers, r);
|
|
const buf = new Uint8Array(5);
|
|
const dest = new Buffer();
|
|
let result: number | null;
|
|
while ((result = await chunkedReader.read(buf)) !== null) {
|
|
const len = Math.min(buf.byteLength, result);
|
|
await dest.write(buf.subarray(0, len));
|
|
}
|
|
return decoder.decode(dest.bytes());
|
|
}
|
|
|
|
Deno.test({ permissions: { net: true } }, async function httpServerBasic() {
|
|
let httpConn: Deno.HttpConn;
|
|
const promise = (async () => {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const conn = await listener.accept();
|
|
listener.close();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const reqEvent = await httpConn.nextRequest();
|
|
assert(reqEvent);
|
|
const { request, respondWith } = reqEvent;
|
|
assertEquals(new URL(request.url).href, `http://127.0.0.1:${listenPort}/`);
|
|
assertEquals(await request.text(), "");
|
|
await respondWith(
|
|
new Response("Hello World", { headers: { "foo": "bar" } }),
|
|
);
|
|
})();
|
|
|
|
const resp = await fetch(`http://127.0.0.1:${listenPort}/`, {
|
|
headers: { "connection": "close" },
|
|
});
|
|
const clone = resp.clone();
|
|
const text = await resp.text();
|
|
assertEquals(text, "Hello World");
|
|
assertEquals(resp.headers.get("foo"), "bar");
|
|
const cloneText = await clone.text();
|
|
assertEquals(cloneText, "Hello World");
|
|
await promise;
|
|
|
|
httpConn!.close();
|
|
});
|
|
|
|
// https://github.com/denoland/deno/issues/15107
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpLazyHeadersIssue15107() {
|
|
let headers: Headers;
|
|
const promise = (async () => {
|
|
const listener = Deno.listen({ port: 2333 });
|
|
const conn = await listener.accept();
|
|
listener.close();
|
|
const httpConn = Deno.serveHttp(conn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request } = e;
|
|
request.text();
|
|
headers = request.headers;
|
|
httpConn!.close();
|
|
})();
|
|
|
|
const conn = await Deno.connect({ port: 2333 });
|
|
// Send GET request with a body + content-length.
|
|
const encoder = new TextEncoder();
|
|
const body =
|
|
`GET / HTTP/1.1\r\nHost: 127.0.0.1:2333\r\nContent-Length: 5\r\n\r\n12345`;
|
|
const writeResult = await conn.write(encoder.encode(body));
|
|
assertEquals(body.length, writeResult);
|
|
await promise;
|
|
conn.close();
|
|
assertEquals(headers!.get("content-length"), "5");
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpReadHeadersAfterClose() {
|
|
const promise = (async () => {
|
|
const listener = Deno.listen({ port: 2334 });
|
|
const conn = await listener.accept();
|
|
listener.close();
|
|
const httpConn = Deno.serveHttp(conn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
|
|
await request.text(); // Read body
|
|
await respondWith(new Response("Hello World")); // Closes request
|
|
|
|
assertThrows(() => request.headers, TypeError, "request closed");
|
|
httpConn!.close();
|
|
})();
|
|
|
|
const conn = await Deno.connect({ port: 2334 });
|
|
// Send GET request with a body + content-length.
|
|
const encoder = new TextEncoder();
|
|
const body =
|
|
`GET / HTTP/1.1\r\nHost: 127.0.0.1:2333\r\nContent-Length: 5\r\n\r\n12345`;
|
|
const writeResult = await conn.write(encoder.encode(body));
|
|
assertEquals(body.length, writeResult);
|
|
await promise;
|
|
conn.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerGetRequestBody() {
|
|
let httpConn: Deno.HttpConn;
|
|
const promise = (async () => {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const conn = await listener.accept();
|
|
listener.close();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.body, null);
|
|
await respondWith(new Response("", { headers: {} }));
|
|
})();
|
|
|
|
const conn = await Deno.connect({ port: listenPort });
|
|
// Send GET request with a body + content-length.
|
|
const encoder = new TextEncoder();
|
|
const body =
|
|
`GET / HTTP/1.1\r\nHost: 127.0.0.1:${listenPort}\r\nContent-Length: 5\r\n\r\n12345`;
|
|
const writeResult = await conn.write(encoder.encode(body));
|
|
assertEquals(body.length, writeResult);
|
|
|
|
const resp = new Uint8Array(200);
|
|
const readResult = await conn.read(resp);
|
|
assertEquals(readResult, 138);
|
|
|
|
conn.close();
|
|
|
|
await promise;
|
|
httpConn!.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerStreamResponse() {
|
|
const stream = new TransformStream();
|
|
const writer = stream.writable.getWriter();
|
|
writer.write(new TextEncoder().encode("hello "));
|
|
writer.write(new TextEncoder().encode("world"));
|
|
writer.close();
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const promise = (async () => {
|
|
const conn = await listener.accept();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const evt = await httpConn.nextRequest();
|
|
assert(evt);
|
|
const { request, respondWith } = evt;
|
|
assert(!request.body);
|
|
await respondWith(new Response(stream.readable));
|
|
})();
|
|
|
|
const resp = await fetch(`http://127.0.0.1:${listenPort}/`);
|
|
const respBody = await resp.text();
|
|
assertEquals("hello world", respBody);
|
|
await promise;
|
|
httpConn!.close();
|
|
listener.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerStreamRequest() {
|
|
const stream = new TransformStream();
|
|
const writer = stream.writable.getWriter();
|
|
writer.write(new TextEncoder().encode("hello "));
|
|
writer.write(new TextEncoder().encode("world"));
|
|
writer.close();
|
|
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const promise = (async () => {
|
|
const conn = await listener.accept();
|
|
const httpConn = Deno.serveHttp(conn);
|
|
const evt = await httpConn.nextRequest();
|
|
assert(evt);
|
|
const { request, respondWith } = evt;
|
|
const reqBody = await request.text();
|
|
assertEquals("hello world", reqBody);
|
|
await respondWith(new Response(""));
|
|
|
|
// TODO(ry) If we don't call httpConn.nextRequest() here we get "error sending
|
|
// request for url (https://localhost:${listenPort}/): connection closed before
|
|
// message completed".
|
|
assertEquals(await httpConn.nextRequest(), null);
|
|
|
|
listener.close();
|
|
})();
|
|
|
|
const resp = await fetch(`http://127.0.0.1:${listenPort}/`, {
|
|
body: stream.readable,
|
|
method: "POST",
|
|
headers: { "connection": "close" },
|
|
});
|
|
|
|
await resp.arrayBuffer();
|
|
await promise;
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerStreamDuplex() {
|
|
let httpConn: Deno.HttpConn;
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const promise = (async () => {
|
|
const conn = await listener.accept();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const evt = await httpConn.nextRequest();
|
|
assert(evt);
|
|
const { request, respondWith } = evt;
|
|
assert(request.body);
|
|
await respondWith(new Response(request.body));
|
|
})();
|
|
|
|
const ts = new TransformStream();
|
|
const writable = ts.writable.getWriter();
|
|
const resp = await fetch(`http://127.0.0.1:${listenPort}/`, {
|
|
method: "POST",
|
|
body: ts.readable,
|
|
});
|
|
assert(resp.body);
|
|
const reader = resp.body.getReader();
|
|
await writable.write(new Uint8Array([1]));
|
|
const chunk1 = await reader.read();
|
|
assert(!chunk1.done);
|
|
assertEquals(chunk1.value, new Uint8Array([1]));
|
|
await writable.write(new Uint8Array([2]));
|
|
const chunk2 = await reader.read();
|
|
assert(!chunk2.done);
|
|
assertEquals(chunk2.value, new Uint8Array([2]));
|
|
|
|
await writable.close();
|
|
const chunk3 = await reader.read();
|
|
assert(chunk3.done);
|
|
await promise;
|
|
httpConn!.close();
|
|
listener.close();
|
|
},
|
|
);
|
|
|
|
Deno.test({ permissions: { net: true } }, async function httpServerClose() {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const client = await Deno.connect({ port: listenPort });
|
|
const httpConn = Deno.serveHttp(await listener.accept());
|
|
client.close();
|
|
const evt = await httpConn.nextRequest();
|
|
assertEquals(evt, null);
|
|
// Note httpConn is automatically closed when "done" is reached.
|
|
listener.close();
|
|
});
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerInvalidMethod() {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const client = await Deno.connect({ port: listenPort });
|
|
const httpConn = Deno.serveHttp(await listener.accept());
|
|
await client.write(new Uint8Array([1, 2, 3]));
|
|
await assertRejects(
|
|
async () => {
|
|
await httpConn.nextRequest();
|
|
},
|
|
Deno.errors.Http,
|
|
"invalid HTTP method parsed",
|
|
);
|
|
// Note httpConn is automatically closed when it errors.
|
|
client.close();
|
|
listener.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { read: true, net: true } },
|
|
async function httpServerWithTls() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
const promise = (async () => {
|
|
const listener = Deno.listenTls({
|
|
hostname,
|
|
port,
|
|
cert: Deno.readTextFileSync("tests/testdata/tls/localhost.crt"),
|
|
key: Deno.readTextFileSync("tests/testdata/tls/localhost.key"),
|
|
});
|
|
const conn = await listener.accept();
|
|
const httpConn = Deno.serveHttp(conn);
|
|
const evt = await httpConn.nextRequest();
|
|
assert(evt);
|
|
const { respondWith } = evt;
|
|
await respondWith(new Response("Hello World"));
|
|
|
|
// TODO(ry) If we don't call httpConn.nextRequest() here we get "error sending
|
|
// request for url (https://localhost:${listenPort}/): connection closed before
|
|
// message completed".
|
|
assertEquals(await httpConn.nextRequest(), null);
|
|
|
|
listener.close();
|
|
})();
|
|
|
|
const caCert = Deno.readTextFileSync("tests/testdata/tls/RootCA.pem");
|
|
const client = Deno.createHttpClient({ caCerts: [caCert] });
|
|
const resp = await fetch(`https://${hostname}:${port}/`, {
|
|
headers: { "connection": "close" },
|
|
client,
|
|
});
|
|
client.close();
|
|
const respBody = await resp.text();
|
|
assertEquals("Hello World", respBody);
|
|
await promise;
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerRegressionHang() {
|
|
let httpConn: Deno.HttpConn;
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const promise = (async () => {
|
|
const conn = await listener.accept();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const event = await httpConn.nextRequest();
|
|
assert(event);
|
|
const { request, respondWith } = event;
|
|
const reqBody = await request.text();
|
|
assertEquals("request", reqBody);
|
|
await respondWith(new Response("response"));
|
|
})();
|
|
|
|
const resp = await fetch(`http://127.0.0.1:${listenPort}/`, {
|
|
method: "POST",
|
|
body: "request",
|
|
});
|
|
const respBody = await resp.text();
|
|
assertEquals("response", respBody);
|
|
await promise;
|
|
|
|
httpConn!.close();
|
|
listener.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerCancelBodyOnResponseFailure() {
|
|
const promise = (async () => {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const conn = await listener.accept();
|
|
const httpConn = Deno.serveHttp(conn);
|
|
const event = await httpConn.nextRequest();
|
|
assert(event);
|
|
const { respondWith } = event;
|
|
let cancelReason: string;
|
|
await assertRejects(
|
|
async () => {
|
|
let interval = 0;
|
|
await respondWith(
|
|
new Response(
|
|
new ReadableStream({
|
|
start(controller) {
|
|
interval = setInterval(() => {
|
|
const message = `data: ${Date.now()}\n\n`;
|
|
controller.enqueue(new TextEncoder().encode(message));
|
|
}, 200);
|
|
},
|
|
cancel(reason) {
|
|
cancelReason = reason;
|
|
clearInterval(interval);
|
|
},
|
|
}),
|
|
),
|
|
);
|
|
},
|
|
Deno.errors.Http,
|
|
cancelReason!,
|
|
);
|
|
assert(cancelReason!);
|
|
httpConn!.close();
|
|
listener.close();
|
|
})();
|
|
|
|
const resp = await fetch(`http://127.0.0.1:${listenPort}/`);
|
|
await resp.body!.cancel();
|
|
await promise;
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerNextRequestErrorExposedInResponse() {
|
|
const promise = (async () => {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const conn = await listener.accept();
|
|
const httpConn = Deno.serveHttp(conn);
|
|
const event = await httpConn.nextRequest();
|
|
assert(event);
|
|
// Start polling for the next request before awaiting response.
|
|
const nextRequestPromise = httpConn.nextRequest();
|
|
const { respondWith } = event;
|
|
await assertRejects(
|
|
async () => {
|
|
let interval = 0;
|
|
await respondWith(
|
|
new Response(
|
|
new ReadableStream({
|
|
start(controller) {
|
|
interval = setInterval(() => {
|
|
const message = `data: ${Date.now()}\n\n`;
|
|
controller.enqueue(new TextEncoder().encode(message));
|
|
}, 200);
|
|
},
|
|
cancel() {
|
|
clearInterval(interval);
|
|
},
|
|
}),
|
|
),
|
|
);
|
|
},
|
|
Deno.errors.Http,
|
|
"connection closed",
|
|
);
|
|
// The error from `op_http_accept` reroutes to `respondWith()`.
|
|
assertEquals(await nextRequestPromise, null);
|
|
listener.close();
|
|
})();
|
|
|
|
const resp = await fetch(`http://127.0.0.1:${listenPort}/`);
|
|
await resp.body!.cancel();
|
|
await promise;
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerEmptyBlobResponse() {
|
|
let httpConn: Deno.HttpConn;
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const promise = (async () => {
|
|
const conn = await listener.accept();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const event = await httpConn.nextRequest();
|
|
assert(event);
|
|
const { respondWith } = event;
|
|
await respondWith(new Response(new Blob([])));
|
|
})();
|
|
|
|
const resp = await fetch(`http://127.0.0.1:${listenPort}/`);
|
|
const respBody = await resp.text();
|
|
assertEquals("", respBody);
|
|
await promise;
|
|
httpConn!.close();
|
|
listener.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerNextRequestResolvesOnClose() {
|
|
const httpConnList: Deno.HttpConn[] = [];
|
|
|
|
async function serve(l: Deno.Listener) {
|
|
for await (const conn of l) {
|
|
(async () => {
|
|
const c = Deno.serveHttp(conn);
|
|
httpConnList.push(c);
|
|
for await (const { respondWith } of c) {
|
|
respondWith(new Response("hello"));
|
|
}
|
|
})();
|
|
}
|
|
}
|
|
|
|
const l = Deno.listen({ port: listenPort });
|
|
serve(l);
|
|
|
|
await delay(300);
|
|
const res = await fetch(`http://localhost:${listenPort}/`);
|
|
const _text = await res.text();
|
|
|
|
// Close connection and listener.
|
|
httpConnList.forEach((conn) => conn.close());
|
|
l.close();
|
|
|
|
await delay(300);
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
// Issue: https://github.com/denoland/deno/issues/10870
|
|
async function httpServerHang() {
|
|
// Quick and dirty way to make a readable stream from a string. Alternatively,
|
|
// `readableStreamFromReader(file)` could be used.
|
|
function stream(s: string): ReadableStream<Uint8Array> {
|
|
return new Response(s).body!;
|
|
}
|
|
|
|
const httpConns: Deno.HttpConn[] = [];
|
|
const promise = (async () => {
|
|
let count = 0;
|
|
const listener = Deno.listen({ port: listenPort });
|
|
for await (const conn of listener) {
|
|
(async () => {
|
|
const httpConn = Deno.serveHttp(conn);
|
|
httpConns.push(httpConn);
|
|
for await (const { respondWith } of httpConn) {
|
|
respondWith(new Response(stream("hello")));
|
|
|
|
count++;
|
|
if (count >= 2) {
|
|
listener.close();
|
|
}
|
|
}
|
|
})();
|
|
}
|
|
})();
|
|
|
|
const clientConn = await Deno.connect({ port: listenPort });
|
|
|
|
const r1 = await writeRequestAndReadResponse(clientConn);
|
|
assertEquals(r1, "hello");
|
|
|
|
const r2 = await writeRequestAndReadResponse(clientConn);
|
|
assertEquals(r2, "hello");
|
|
|
|
clientConn.close();
|
|
await promise;
|
|
for (const conn of httpConns) {
|
|
conn.close();
|
|
}
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
// Issue: https://github.com/denoland/deno/issues/10930
|
|
async function httpServerStreamingResponse() {
|
|
// This test enqueues a single chunk for readable
|
|
// stream and waits for client to read that chunk and signal
|
|
// it before enqueueing subsequent chunk. Issue linked above
|
|
// presented a situation where enqueued chunks were not
|
|
// written to the HTTP connection until the next chunk was enqueued.
|
|
|
|
let counter = 0;
|
|
|
|
const deferreds = [
|
|
Promise.withResolvers<void>(),
|
|
Promise.withResolvers<void>(),
|
|
Promise.withResolvers<void>(),
|
|
];
|
|
|
|
async function writeRequest(conn: Deno.Conn) {
|
|
const encoder = new TextEncoder();
|
|
const decoder = new TextDecoder();
|
|
|
|
const w = new BufWriter(conn);
|
|
const r = new BufReader(conn);
|
|
const body = `GET / HTTP/1.1\r\nHost: 127.0.0.1:${listenPort}\r\n\r\n`;
|
|
const writeResult = await w.write(encoder.encode(body));
|
|
assertEquals(body.length, writeResult);
|
|
await w.flush();
|
|
const tpr = new TextProtoReader(r);
|
|
const statusLine = await tpr.readLine();
|
|
assert(statusLine !== null);
|
|
const headers = await tpr.readMimeHeader();
|
|
assert(headers !== null);
|
|
|
|
const chunkedReader = chunkedBodyReader(headers, r);
|
|
const buf = new Uint8Array(5);
|
|
const dest = new Buffer();
|
|
let result: number | null;
|
|
while ((result = await chunkedReader.read(buf)) !== null) {
|
|
const len = Math.min(buf.byteLength, result);
|
|
await dest.write(buf.subarray(0, len));
|
|
// Resolve a deferred - this will make response stream to
|
|
// enqueue next chunk.
|
|
deferreds[counter - 1].resolve();
|
|
}
|
|
return decoder.decode(dest.bytes());
|
|
}
|
|
|
|
function periodicStream() {
|
|
return new ReadableStream({
|
|
start(controller) {
|
|
controller.enqueue(`${counter}\n`);
|
|
counter++;
|
|
},
|
|
|
|
async pull(controller) {
|
|
if (counter >= 3) {
|
|
return controller.close();
|
|
}
|
|
|
|
await deferreds[counter - 1].promise;
|
|
|
|
controller.enqueue(`${counter}\n`);
|
|
counter++;
|
|
},
|
|
}).pipeThrough(new TextEncoderStream());
|
|
}
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const finished = (async () => {
|
|
const conn = await listener.accept();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const requestEvent = await httpConn.nextRequest();
|
|
const { respondWith } = requestEvent!;
|
|
await respondWith(new Response(periodicStream()));
|
|
})();
|
|
|
|
// start a client
|
|
const clientConn = await Deno.connect({ port: listenPort });
|
|
|
|
const r1 = await writeRequest(clientConn);
|
|
assertEquals(r1, "0\n1\n2\n");
|
|
|
|
await finished;
|
|
clientConn.close();
|
|
|
|
httpConn!.close();
|
|
listener.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpRequestLatin1Headers() {
|
|
let httpConn: Deno.HttpConn;
|
|
const promise = (async () => {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const conn = await listener.accept();
|
|
listener.close();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const reqEvent = await httpConn.nextRequest();
|
|
assert(reqEvent);
|
|
const { request, respondWith } = reqEvent;
|
|
assertEquals(request.headers.get("X-Header-Test"), "á");
|
|
await respondWith(
|
|
new Response("", { headers: { "X-Header-Test": "Æ" } }),
|
|
);
|
|
})();
|
|
|
|
const clientConn = await Deno.connect({ port: listenPort });
|
|
const requestText =
|
|
`GET / HTTP/1.1\r\nHost: 127.0.0.1:${listenPort}\r\nX-Header-Test: á\r\n\r\n`;
|
|
const requestBytes = new Uint8Array(requestText.length);
|
|
for (let i = 0; i < requestText.length; i++) {
|
|
requestBytes[i] = requestText.charCodeAt(i);
|
|
}
|
|
let written = 0;
|
|
while (written < requestBytes.byteLength) {
|
|
written += await clientConn.write(requestBytes.slice(written));
|
|
}
|
|
|
|
let responseText = "";
|
|
const buf = new Uint8Array(1024);
|
|
let read;
|
|
|
|
while ((read = await clientConn.read(buf)) !== null) {
|
|
httpConn!.close();
|
|
for (let i = 0; i < read; i++) {
|
|
responseText += String.fromCharCode(buf[i]);
|
|
}
|
|
}
|
|
|
|
clientConn.close();
|
|
|
|
assert(/\r\n[Xx]-[Hh]eader-[Tt]est: Æ\r\n/.test(responseText));
|
|
|
|
await promise;
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerRequestWithoutPath() {
|
|
let httpConn: Deno.HttpConn;
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const promise = (async () => {
|
|
const conn = await listener.accept();
|
|
listener.close();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const reqEvent = await httpConn.nextRequest();
|
|
assert(reqEvent);
|
|
const { request, respondWith } = reqEvent;
|
|
assertEquals(
|
|
new URL(request.url).href,
|
|
`http://127.0.0.1:${listenPort}/`,
|
|
);
|
|
assertEquals(await request.text(), "");
|
|
await respondWith(new Response());
|
|
})();
|
|
|
|
const clientConn = await Deno.connect({ port: listenPort });
|
|
|
|
async function writeRequest(conn: Deno.Conn) {
|
|
const encoder = new TextEncoder();
|
|
|
|
const w = new BufWriter(conn);
|
|
const r = new BufReader(conn);
|
|
const body =
|
|
`CONNECT 127.0.0.1:${listenPort} HTTP/1.1\r\nHost: 127.0.0.1:${listenPort}\r\n\r\n`;
|
|
const writeResult = await w.write(encoder.encode(body));
|
|
assertEquals(body.length, writeResult);
|
|
await w.flush();
|
|
const tpr = new TextProtoReader(r);
|
|
const statusLine = await tpr.readLine();
|
|
assert(statusLine !== null);
|
|
const m = statusLine.match(/^(.+?) (.+?) (.+?)$/);
|
|
assert(m !== null, "must be matched");
|
|
const [_, _proto, status, _ok] = m;
|
|
assertEquals(status, "200");
|
|
const headers = await tpr.readMimeHeader();
|
|
assert(headers !== null);
|
|
}
|
|
|
|
await writeRequest(clientConn);
|
|
clientConn.close();
|
|
await promise;
|
|
httpConn!.close();
|
|
},
|
|
);
|
|
|
|
Deno.test({ permissions: { net: true } }, async function httpServerWebSocket() {
|
|
const promise = (async () => {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const conn = await listener.accept();
|
|
listener.close();
|
|
const httpConn = Deno.serveHttp(conn);
|
|
const reqEvent = await httpConn.nextRequest();
|
|
assert(reqEvent);
|
|
const { request, respondWith } = reqEvent;
|
|
const {
|
|
response,
|
|
socket,
|
|
} = Deno.upgradeWebSocket(request);
|
|
socket.onerror = () => fail();
|
|
socket.onmessage = (m) => {
|
|
socket.send(m.data);
|
|
socket.close(1001);
|
|
};
|
|
const close = new Promise<void>((resolve) => {
|
|
socket.onclose = () => resolve();
|
|
});
|
|
await respondWith(response);
|
|
await close;
|
|
})();
|
|
|
|
const def = Promise.withResolvers<void>();
|
|
const ws = new WebSocket(`ws://localhost:${listenPort}`);
|
|
ws.onmessage = (m) => assertEquals(m.data, "foo");
|
|
ws.onerror = () => fail();
|
|
ws.onclose = () => def.resolve();
|
|
ws.onopen = () => ws.send("foo");
|
|
await def.promise;
|
|
await promise;
|
|
});
|
|
|
|
Deno.test(function httpUpgradeWebSocket() {
|
|
const request = new Request("https://deno.land/", {
|
|
headers: {
|
|
connection: "Upgrade",
|
|
upgrade: "websocket",
|
|
"sec-websocket-key": "dGhlIHNhbXBsZSBub25jZQ==",
|
|
},
|
|
});
|
|
const { response } = Deno.upgradeWebSocket(request);
|
|
assertEquals(response.status, 101);
|
|
assertEquals(response.headers.get("connection"), "Upgrade");
|
|
assertEquals(response.headers.get("upgrade"), "websocket");
|
|
assertEquals(
|
|
response.headers.get("sec-websocket-accept"),
|
|
"s3pPLMBiTxaQ9kYGzzhZRbK+xOo=",
|
|
);
|
|
});
|
|
|
|
Deno.test(function httpUpgradeWebSocketMultipleConnectionOptions() {
|
|
const request = new Request("https://deno.land/", {
|
|
headers: {
|
|
connection: "keep-alive, upgrade",
|
|
upgrade: "websocket",
|
|
"sec-websocket-key": "dGhlIHNhbXBsZSBub25jZQ==",
|
|
},
|
|
});
|
|
const { response } = Deno.upgradeWebSocket(request);
|
|
assertEquals(response.status, 101);
|
|
});
|
|
|
|
Deno.test(function httpUpgradeWebSocketMultipleUpgradeOptions() {
|
|
const request = new Request("https://deno.land/", {
|
|
headers: {
|
|
connection: "upgrade",
|
|
upgrade: "websocket, foo",
|
|
"sec-websocket-key": "dGhlIHNhbXBsZSBub25jZQ==",
|
|
},
|
|
});
|
|
const { response } = Deno.upgradeWebSocket(request);
|
|
assertEquals(response.status, 101);
|
|
});
|
|
|
|
Deno.test(function httpUpgradeWebSocketCaseInsensitiveUpgradeHeader() {
|
|
const request = new Request("https://deno.land/", {
|
|
headers: {
|
|
connection: "upgrade",
|
|
upgrade: "Websocket",
|
|
"sec-websocket-key": "dGhlIHNhbXBsZSBub25jZQ==",
|
|
},
|
|
});
|
|
const { response } = Deno.upgradeWebSocket(request);
|
|
assertEquals(response.status, 101);
|
|
});
|
|
|
|
Deno.test(function httpUpgradeWebSocketInvalidUpgradeHeader() {
|
|
assertThrows(
|
|
() => {
|
|
const request = new Request("https://deno.land/", {
|
|
headers: {
|
|
connection: "upgrade",
|
|
upgrade: "invalid",
|
|
"sec-websocket-key": "dGhlIHNhbXBsZSBub25jZQ==",
|
|
},
|
|
});
|
|
Deno.upgradeWebSocket(request);
|
|
},
|
|
TypeError,
|
|
"Invalid Header: 'upgrade' header must contain 'websocket'",
|
|
);
|
|
});
|
|
|
|
Deno.test(function httpUpgradeWebSocketWithoutUpgradeHeader() {
|
|
assertThrows(
|
|
() => {
|
|
const request = new Request("https://deno.land/", {
|
|
headers: {
|
|
connection: "upgrade",
|
|
"sec-websocket-key": "dGhlIHNhbXBsZSBub25jZQ==",
|
|
},
|
|
});
|
|
Deno.upgradeWebSocket(request);
|
|
},
|
|
TypeError,
|
|
"Invalid Header: 'upgrade' header must contain 'websocket'",
|
|
);
|
|
});
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpCookieConcatenation() {
|
|
let httpConn: Deno.HttpConn;
|
|
const promise = (async () => {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const conn = await listener.accept();
|
|
listener.close();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const reqEvent = await httpConn.nextRequest();
|
|
assert(reqEvent);
|
|
const { request, respondWith } = reqEvent;
|
|
assertEquals(
|
|
new URL(request.url).href,
|
|
`http://127.0.0.1:${listenPort}/`,
|
|
);
|
|
assertEquals(await request.text(), "");
|
|
assertEquals(request.headers.get("cookie"), "foo=bar; bar=foo");
|
|
await respondWith(new Response("ok"));
|
|
})();
|
|
|
|
const resp = await fetch(`http://127.0.0.1:${listenPort}/`, {
|
|
headers: [
|
|
["connection", "close"],
|
|
["cookie", "foo=bar"],
|
|
["cookie", "bar=foo"],
|
|
],
|
|
});
|
|
const text = await resp.text();
|
|
assertEquals(text, "ok");
|
|
await promise;
|
|
httpConn!.close();
|
|
},
|
|
);
|
|
|
|
// https://github.com/denoland/deno/issues/11651
|
|
Deno.test({ permissions: { net: true } }, async function httpServerPanic() {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const client = await Deno.connect({ port: listenPort });
|
|
const conn = await listener.accept();
|
|
const httpConn = Deno.serveHttp(conn);
|
|
|
|
// This message is incomplete on purpose, we'll forcefully close client connection
|
|
// after it's flushed to cause connection to error out on the server side.
|
|
const encoder = new TextEncoder();
|
|
await client.write(encoder.encode("GET / HTTP/1.1"));
|
|
|
|
httpConn.nextRequest();
|
|
await client.write(encoder.encode("\r\n\r\n"));
|
|
httpConn!.close();
|
|
|
|
client.close();
|
|
listener.close();
|
|
});
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true, write: true, read: true } },
|
|
async function httpServerCorrectSizeResponse() {
|
|
const tmpFile = await Deno.makeTempFile();
|
|
using file = await Deno.open(tmpFile, { write: true, read: true });
|
|
await file.write(new Uint8Array(70 * 1024).fill(1)); // 70kb sent in 64kb + 6kb chunks
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const promise = (async () => {
|
|
const conn = await listener.accept();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const ev = await httpConn.nextRequest();
|
|
const { respondWith } = ev!;
|
|
const f = await Deno.open(tmpFile, { read: true });
|
|
await respondWith(new Response(f.readable, { status: 200 }));
|
|
})();
|
|
const resp = await fetch(`http://127.0.0.1:${listenPort}/`);
|
|
const body = await resp.arrayBuffer();
|
|
assertEquals(body.byteLength, 70 * 1024);
|
|
await promise;
|
|
httpConn!.close();
|
|
listener.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true, write: true, read: true } },
|
|
async function httpServerClosedStream() {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
|
|
const client = await Deno.connect({ port: listenPort });
|
|
await client.write(new TextEncoder().encode(
|
|
`GET / HTTP/1.0\r\n\r\n`,
|
|
));
|
|
|
|
const conn = await listener.accept();
|
|
const httpConn = Deno.serveHttp(conn);
|
|
const ev = await httpConn.nextRequest();
|
|
const { respondWith } = ev!;
|
|
|
|
const tmpFile = await Deno.makeTempFile();
|
|
const file = await Deno.open(tmpFile, { write: true, read: true });
|
|
await file.write(new TextEncoder().encode("hello"));
|
|
|
|
const reader = await file.readable.getReader();
|
|
while (true) {
|
|
const { done, value } = await reader.read();
|
|
if (done) break;
|
|
assert(value);
|
|
}
|
|
|
|
let didThrow = false;
|
|
try {
|
|
await respondWith(new Response(file.readable));
|
|
} catch {
|
|
// pass
|
|
didThrow = true;
|
|
}
|
|
|
|
assert(didThrow);
|
|
httpConn!.close();
|
|
listener.close();
|
|
client.close();
|
|
},
|
|
);
|
|
|
|
// https://github.com/denoland/deno/issues/11595
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerIncompleteMessage() {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
|
|
const client = await Deno.connect({ port: listenPort });
|
|
await client.write(new TextEncoder().encode(
|
|
`GET / HTTP/1.0\r\n\r\n`,
|
|
));
|
|
|
|
const conn = await listener.accept();
|
|
const httpConn = Deno.serveHttp(conn);
|
|
const ev = await httpConn.nextRequest();
|
|
const { respondWith } = ev!;
|
|
|
|
const errors: Error[] = [];
|
|
|
|
const readable = new ReadableStream({
|
|
async pull(controller) {
|
|
client.close();
|
|
await delay(1000);
|
|
controller.enqueue(new TextEncoder().encode(
|
|
"written to the writable side of a TransformStream",
|
|
));
|
|
controller.close();
|
|
},
|
|
cancel(error) {
|
|
errors.push(error);
|
|
},
|
|
});
|
|
|
|
const res = new Response(readable);
|
|
|
|
await respondWith(res).catch((error: Error) => errors.push(error));
|
|
|
|
httpConn!.close();
|
|
listener.close();
|
|
|
|
assert(errors.length >= 1);
|
|
for (const error of errors) {
|
|
assertEquals(error.name, "Http");
|
|
assert(error.message.includes("connection"));
|
|
}
|
|
},
|
|
);
|
|
|
|
// https://github.com/denoland/deno/issues/11743
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerDoesntLeakResources() {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const [conn, clientConn] = await Promise.all([
|
|
listener.accept(),
|
|
Deno.connect({ port: listenPort }),
|
|
]);
|
|
const httpConn = Deno.serveHttp(conn);
|
|
|
|
await Promise.all([
|
|
httpConn.nextRequest(),
|
|
clientConn.write(new TextEncoder().encode(
|
|
`GET / HTTP/1.1\r\nHost: 127.0.0.1:${listenPort}\r\n\r\n`,
|
|
)),
|
|
]);
|
|
|
|
httpConn!.close();
|
|
listener.close();
|
|
clientConn.close();
|
|
},
|
|
);
|
|
|
|
// https://github.com/denoland/deno/issues/11926
|
|
// verify that the only new resource is "httpConnection", to make
|
|
// sure "request" resource is closed even if its body was not read
|
|
// by server handler
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerDoesntLeakResources2() {
|
|
let listener: Deno.Listener;
|
|
let httpConn: Deno.HttpConn;
|
|
|
|
const promise = (async () => {
|
|
listener = Deno.listen({ port: listenPort });
|
|
for await (const conn of listener) {
|
|
httpConn = Deno.serveHttp(conn);
|
|
for await (const { request, respondWith } of httpConn) {
|
|
assertEquals(
|
|
new URL(request.url).href,
|
|
`http://127.0.0.1:${listenPort}/`,
|
|
);
|
|
// not reading request body on purpose
|
|
respondWith(new Response("ok"));
|
|
}
|
|
}
|
|
})();
|
|
|
|
const response = await fetch(`http://127.0.0.1:${listenPort}`, {
|
|
method: "POST",
|
|
body: "hello world",
|
|
});
|
|
await response.text();
|
|
|
|
listener!.close();
|
|
httpConn!.close();
|
|
await promise;
|
|
},
|
|
);
|
|
|
|
// https://github.com/denoland/deno/pull/12216
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function droppedConnSenderNoPanic() {
|
|
async function server() {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const conn = await listener.accept();
|
|
const http = Deno.serveHttp(conn);
|
|
const evt = await http.nextRequest();
|
|
http.close();
|
|
try {
|
|
await evt!.respondWith(new Response("boom"));
|
|
} catch {
|
|
// Ignore error.
|
|
}
|
|
listener.close();
|
|
}
|
|
|
|
async function client() {
|
|
try {
|
|
const resp = await fetch(`http://127.0.0.1:${listenPort}/`);
|
|
await resp.body?.cancel();
|
|
} catch {
|
|
// Ignore error
|
|
}
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
},
|
|
);
|
|
|
|
// https://github.com/denoland/deno/issues/12193
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpConnConcurrentNextRequestCalls() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
const listener = Deno.listen({ hostname, port });
|
|
async function server() {
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const promises = new Array(10).fill(null).map(async (_, i) => {
|
|
const event = await httpConn.nextRequest();
|
|
assert(event);
|
|
const { pathname } = new URL(event.request.url);
|
|
assertStrictEquals(pathname, `/${i}`);
|
|
const response = new Response(`Response #${i}`);
|
|
await event.respondWith(response);
|
|
});
|
|
await Promise.all(promises);
|
|
}
|
|
|
|
async function client() {
|
|
for (let i = 0; i < 10; i++) {
|
|
const response = await fetch(`http://${hostname}:${port}/${i}`);
|
|
const body = await response.text();
|
|
assertStrictEquals(body, `Response #${i}`);
|
|
}
|
|
}
|
|
|
|
await Promise.all([server(), delay(100).then(client)]);
|
|
httpConn!.close();
|
|
listener.close();
|
|
},
|
|
);
|
|
|
|
// https://github.com/denoland/deno/pull/12704
|
|
// https://github.com/denoland/deno/pull/12732
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpConnAutoCloseDelayedOnUpgrade() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
async function server() {
|
|
const listener = Deno.listen({ hostname, port });
|
|
const tcpConn = await listener.accept();
|
|
const httpConn = Deno.serveHttp(tcpConn);
|
|
|
|
const event1 = await httpConn.nextRequest() as Deno.RequestEvent;
|
|
const event2Promise = httpConn.nextRequest();
|
|
|
|
const { socket, response } = Deno.upgradeWebSocket(event1.request);
|
|
socket.onmessage = (event) => socket.send(event.data);
|
|
const socketClosed = new Promise<void>((resolve) => {
|
|
socket.onclose = () => resolve();
|
|
});
|
|
event1.respondWith(response);
|
|
|
|
const event2 = await event2Promise;
|
|
assertStrictEquals(event2, null);
|
|
|
|
listener.close();
|
|
await socketClosed;
|
|
}
|
|
|
|
async function client() {
|
|
const socket = new WebSocket(`ws://${hostname}:${port}/`);
|
|
socket.onopen = () => socket.send("bla bla");
|
|
const closed = new Promise<void>((resolve) => {
|
|
socket.onclose = () => resolve();
|
|
});
|
|
const { data } = await new Promise<MessageEvent<string>>((res) =>
|
|
socket.onmessage = res
|
|
);
|
|
assertStrictEquals(data, "bla bla");
|
|
socket.close();
|
|
await closed;
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
},
|
|
);
|
|
|
|
// https://github.com/denoland/deno/issues/12741
|
|
// https://github.com/denoland/deno/pull/12746
|
|
// https://github.com/denoland/deno/pull/12798
|
|
Deno.test(
|
|
{ permissions: { net: true, run: true } },
|
|
async function httpServerDeleteRequestHasBody() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
const listener = Deno.listen({ hostname, port });
|
|
async function server() {
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const event = await httpConn.nextRequest() as Deno.RequestEvent;
|
|
assert(event.request.body);
|
|
const response = new Response();
|
|
await event.respondWith(response);
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const args = ["-X", "DELETE", url];
|
|
const { success } = await new Deno.Command("curl", {
|
|
args,
|
|
stdout: "null",
|
|
stderr: "null",
|
|
}).output();
|
|
assert(success);
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
httpConn!.close();
|
|
listener.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerRespondNonAsciiUint8Array() {
|
|
let httpConn: Deno.HttpConn;
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const promise = (async () => {
|
|
const conn = await listener.accept();
|
|
listener.close();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.body, null);
|
|
await respondWith(
|
|
new Response(new Uint8Array([128]), {}),
|
|
);
|
|
})();
|
|
|
|
const resp = await fetch(`http://localhost:${listenPort}/`);
|
|
assertEquals(resp.status, 200);
|
|
const body = await resp.arrayBuffer();
|
|
assertEquals(new Uint8Array(body), new Uint8Array([128]));
|
|
|
|
await promise;
|
|
httpConn!.close();
|
|
},
|
|
);
|
|
|
|
function tmpUnixSocketPath(): string {
|
|
const folder = Deno.makeTempDirSync();
|
|
return join(folder, "socket");
|
|
}
|
|
|
|
// https://github.com/denoland/deno/pull/13628
|
|
Deno.test(
|
|
{
|
|
ignore: Deno.build.os === "windows",
|
|
permissions: { read: true, write: true },
|
|
},
|
|
async function httpServerOnUnixSocket() {
|
|
const filePath = tmpUnixSocketPath();
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
const promise = (async () => {
|
|
const listener = Deno.listen({ path: filePath, transport: "unix" });
|
|
const conn = await listener.accept();
|
|
listener.close();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const reqEvent = await httpConn.nextRequest();
|
|
assert(reqEvent);
|
|
const { request, respondWith } = reqEvent;
|
|
const url = new URL(request.url);
|
|
assertEquals(url.protocol, "http+unix:");
|
|
assertEquals(decodeURIComponent(url.host), filePath);
|
|
assertEquals(url.pathname, "/path/name");
|
|
await respondWith(new Response("", { headers: {} }));
|
|
})();
|
|
|
|
// fetch() does not supports unix domain sockets yet https://github.com/denoland/deno/issues/8821
|
|
const conn = await Deno.connect({ path: filePath, transport: "unix" });
|
|
const encoder = new TextEncoder();
|
|
// The Host header must be present and empty if it is not a Internet host name (RFC2616, Section 14.23)
|
|
const body = `GET /path/name HTTP/1.1\r\nHost:\r\n\r\n`;
|
|
const writeResult = await conn.write(encoder.encode(body));
|
|
assertEquals(body.length, writeResult);
|
|
|
|
const resp = new Uint8Array(200);
|
|
const readResult = await conn.read(resp);
|
|
assertEquals(readResult, 138);
|
|
|
|
conn.close();
|
|
|
|
await promise;
|
|
httpConn!.close();
|
|
},
|
|
);
|
|
|
|
/* Automatic Body Compression */
|
|
|
|
const decoder = new TextDecoder();
|
|
|
|
Deno.test({
|
|
name: "http server compresses body - check headers",
|
|
permissions: { net: true, run: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
const listener = Deno.listen({ hostname, port });
|
|
|
|
const data = { hello: "deno", now: "with", compressed: "body" };
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function server() {
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.headers.get("Accept-Encoding"), "gzip, deflate, br");
|
|
const response = new Response(JSON.stringify(data), {
|
|
headers: { "content-type": "application/json" },
|
|
});
|
|
await respondWith(response);
|
|
listener.close();
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const args = [
|
|
"-i",
|
|
"--request",
|
|
"GET",
|
|
"--url",
|
|
url,
|
|
"--header",
|
|
"Accept-Encoding: gzip, deflate, br",
|
|
];
|
|
const { success, stdout } = await new Deno.Command("curl", {
|
|
args,
|
|
stderr: "null",
|
|
stdout: "piped",
|
|
}).output();
|
|
assert(success);
|
|
const output = decoder.decode(stdout);
|
|
assert(output.includes("vary: Accept-Encoding\r\n"));
|
|
assert(output.includes("content-encoding: gzip\r\n"));
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
httpConn!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: "http server compresses body - check body",
|
|
permissions: { net: true, run: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
const listener = Deno.listen({ hostname, port });
|
|
|
|
const data = { hello: "deno", now: "with", compressed: "body" };
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function server() {
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.headers.get("Accept-Encoding"), "gzip, deflate, br");
|
|
const response = new Response(JSON.stringify(data), {
|
|
headers: { "content-type": "application/json" },
|
|
});
|
|
await respondWith(response);
|
|
listener.close();
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const args = [
|
|
"--request",
|
|
"GET",
|
|
"--url",
|
|
url,
|
|
"--header",
|
|
"Accept-Encoding: gzip, deflate, br",
|
|
];
|
|
const proc = new Deno.Command("curl", {
|
|
args,
|
|
stderr: "null",
|
|
stdout: "piped",
|
|
}).spawn();
|
|
const status = await proc.status;
|
|
assert(status.success);
|
|
const stdout = proc.stdout
|
|
.pipeThrough(new DecompressionStream("gzip"))
|
|
.pipeThrough(new TextDecoderStream());
|
|
let body = "";
|
|
for await (const chunk of stdout) {
|
|
body += chunk;
|
|
}
|
|
assertEquals(JSON.parse(body), data);
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
httpConn!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: "http server doesn't compress small body",
|
|
permissions: { net: true, run: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function server() {
|
|
const listener = Deno.listen({ hostname, port });
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.headers.get("Accept-Encoding"), "gzip, deflate, br");
|
|
const response = new Response(
|
|
JSON.stringify({ hello: "deno" }),
|
|
{
|
|
headers: { "content-type": "application/json" },
|
|
},
|
|
);
|
|
await respondWith(response);
|
|
listener.close();
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const args = [
|
|
"-i",
|
|
"--request",
|
|
"GET",
|
|
"--url",
|
|
url,
|
|
"--header",
|
|
"Accept-Encoding: gzip, deflate, br",
|
|
];
|
|
const { success, stdout } = await new Deno.Command("curl", {
|
|
args,
|
|
stderr: "null",
|
|
stdout: "piped",
|
|
}).output();
|
|
assert(success);
|
|
const output = decoder.decode(stdout).toLocaleLowerCase();
|
|
assert(output.includes("vary: accept-encoding\r\n"));
|
|
assert(!output.includes("content-encoding: "));
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
httpConn!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: "http server respects accept-encoding weights",
|
|
permissions: { net: true, run: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function server() {
|
|
const listener = Deno.listen({ hostname, port });
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(
|
|
request.headers.get("Accept-Encoding"),
|
|
"gzip;q=0.8, br;q=1.0, *;q=0.1",
|
|
);
|
|
const response = new Response(
|
|
JSON.stringify({ hello: "deno", now: "with", compressed: "body" }),
|
|
{
|
|
headers: { "content-type": "application/json" },
|
|
},
|
|
);
|
|
await respondWith(response);
|
|
listener.close();
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const args = [
|
|
"-i",
|
|
"--request",
|
|
"GET",
|
|
"--url",
|
|
url,
|
|
"--header",
|
|
"Accept-Encoding: gzip;q=0.8, br;q=1.0, *;q=0.1",
|
|
];
|
|
const { success, stdout } = await new Deno.Command("curl", {
|
|
args,
|
|
stderr: "null",
|
|
stdout: "piped",
|
|
}).output();
|
|
assert(success);
|
|
const output = decoder.decode(stdout);
|
|
assert(output.includes("vary: Accept-Encoding\r\n"));
|
|
assert(output.includes("content-encoding: br\r\n"));
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
httpConn!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: "http server augments vary header",
|
|
permissions: { net: true, run: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function server() {
|
|
const listener = Deno.listen({ hostname, port });
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.headers.get("Accept-Encoding"), "gzip, deflate, br");
|
|
const response = new Response(
|
|
JSON.stringify({ hello: "deno", now: "with", compressed: "body" }),
|
|
{
|
|
headers: { "content-type": "application/json", vary: "Accept" },
|
|
},
|
|
);
|
|
await respondWith(response);
|
|
listener.close();
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const args = [
|
|
"-i",
|
|
"--request",
|
|
"GET",
|
|
"--url",
|
|
url,
|
|
"--header",
|
|
"Accept-Encoding: gzip, deflate, br",
|
|
];
|
|
const { success, stdout } = await new Deno.Command("curl", {
|
|
args,
|
|
stderr: "null",
|
|
stdout: "piped",
|
|
}).output();
|
|
assert(success);
|
|
const output = decoder.decode(stdout);
|
|
assert(output.includes("vary: Accept-Encoding, Accept\r\n"));
|
|
assert(output.includes("content-encoding: gzip\r\n"));
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
httpConn!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: "http server weakens etag header",
|
|
permissions: { net: true, run: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function server() {
|
|
const listener = Deno.listen({ hostname, port });
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.headers.get("Accept-Encoding"), "gzip, deflate, br");
|
|
const response = new Response(
|
|
JSON.stringify({ hello: "deno", now: "with", compressed: "body" }),
|
|
{
|
|
headers: {
|
|
"content-type": "application/json",
|
|
etag: "33a64df551425fcc55e4d42a148795d9f25f89d4",
|
|
},
|
|
},
|
|
);
|
|
await respondWith(response);
|
|
listener.close();
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const args = [
|
|
"curl",
|
|
"-i",
|
|
"--request",
|
|
"GET",
|
|
"--url",
|
|
url,
|
|
"--header",
|
|
"Accept-Encoding: gzip, deflate, br",
|
|
];
|
|
const { success, stdout } = await new Deno.Command("curl", {
|
|
args,
|
|
stderr: "null",
|
|
stdout: "piped",
|
|
}).output();
|
|
assert(success);
|
|
const output = decoder.decode(stdout);
|
|
assert(output.includes("vary: Accept-Encoding\r\n"));
|
|
assert(
|
|
output.includes("etag: W/33a64df551425fcc55e4d42a148795d9f25f89d4\r\n"),
|
|
);
|
|
assert(output.includes("content-encoding: gzip\r\n"));
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
httpConn!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: "http server passes through weak etag header",
|
|
permissions: { net: true, run: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function server() {
|
|
const listener = Deno.listen({ hostname, port });
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.headers.get("Accept-Encoding"), "gzip, deflate, br");
|
|
const response = new Response(
|
|
JSON.stringify({ hello: "deno", now: "with", compressed: "body" }),
|
|
{
|
|
headers: {
|
|
"content-type": "application/json",
|
|
etag: "W/33a64df551425fcc55e4d42a148795d9f25f89d4",
|
|
},
|
|
},
|
|
);
|
|
await respondWith(response);
|
|
listener.close();
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const args = [
|
|
"-i",
|
|
"--request",
|
|
"GET",
|
|
"--url",
|
|
url,
|
|
"--header",
|
|
"Accept-Encoding: gzip, deflate, br",
|
|
];
|
|
const { success, stdout } = await new Deno.Command("curl", {
|
|
args,
|
|
stderr: "null",
|
|
stdout: "piped",
|
|
}).output();
|
|
assert(success);
|
|
const output = decoder.decode(stdout);
|
|
assert(output.includes("vary: Accept-Encoding\r\n"));
|
|
assert(
|
|
output.includes("etag: W/33a64df551425fcc55e4d42a148795d9f25f89d4\r\n"),
|
|
);
|
|
assert(output.includes("content-encoding: gzip\r\n"));
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
httpConn!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: "http server doesn't compress body when no-transform is set",
|
|
permissions: { net: true, run: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function server() {
|
|
const listener = Deno.listen({ hostname, port });
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.headers.get("Accept-Encoding"), "gzip, deflate, br");
|
|
const response = new Response(
|
|
JSON.stringify({ hello: "deno", now: "with", compressed: "body" }),
|
|
{
|
|
headers: {
|
|
"content-type": "application/json",
|
|
"cache-control": "no-transform",
|
|
},
|
|
},
|
|
);
|
|
await respondWith(response);
|
|
listener.close();
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const args = [
|
|
"-i",
|
|
"--request",
|
|
"GET",
|
|
"--url",
|
|
url,
|
|
"--header",
|
|
"Accept-Encoding: gzip, deflate, br",
|
|
];
|
|
const { success, stdout } = await new Deno.Command("curl", {
|
|
args,
|
|
stderr: "null",
|
|
stdout: "piped",
|
|
}).output();
|
|
assert(success);
|
|
const output = decoder.decode(stdout);
|
|
assert(output.includes("vary: Accept-Encoding\r\n"));
|
|
assert(!output.includes("content-encoding: "));
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
httpConn!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: "http server doesn't compress body when content-range is set",
|
|
permissions: { net: true, run: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function server() {
|
|
const listener = Deno.listen({ hostname, port });
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.headers.get("Accept-Encoding"), "gzip, deflate, br");
|
|
const response = new Response(
|
|
JSON.stringify({ hello: "deno", now: "with", compressed: "body" }),
|
|
{
|
|
headers: {
|
|
"content-type": "application/json",
|
|
"content-range": "bytes 200-100/67589",
|
|
},
|
|
},
|
|
);
|
|
await respondWith(response);
|
|
listener.close();
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const args = [
|
|
"-i",
|
|
"--request",
|
|
"GET",
|
|
"--url",
|
|
url,
|
|
"--header",
|
|
"Accept-Encoding: gzip, deflate, br",
|
|
];
|
|
const { success, stdout } = await new Deno.Command("curl", {
|
|
args,
|
|
stderr: "null",
|
|
stdout: "piped",
|
|
}).output();
|
|
assert(success);
|
|
const output = decoder.decode(stdout);
|
|
assert(output.includes("vary: Accept-Encoding\r\n"));
|
|
assert(!output.includes("content-encoding: "));
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
httpConn!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: "http server compresses streamed bodies - check headers",
|
|
permissions: { net: true, run: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
const encoder = new TextEncoder();
|
|
const listener = Deno.listen({ hostname, port });
|
|
|
|
const data = { hello: "deno", now: "with", compressed: "body" };
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function server() {
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.headers.get("Accept-Encoding"), "gzip, deflate, br");
|
|
const bodyInit = new ReadableStream({
|
|
start(controller) {
|
|
controller.enqueue(encoder.encode(JSON.stringify(data)));
|
|
controller.close();
|
|
},
|
|
});
|
|
const response = new Response(
|
|
bodyInit,
|
|
{ headers: { "content-type": "application/json" } },
|
|
);
|
|
await respondWith(response);
|
|
listener.close();
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const args = [
|
|
"curl",
|
|
"-i",
|
|
"--request",
|
|
"GET",
|
|
"--url",
|
|
url,
|
|
"--header",
|
|
"Accept-Encoding: gzip, deflate, br",
|
|
];
|
|
const { success, stdout } = await new Deno.Command("curl", {
|
|
args,
|
|
stderr: "null",
|
|
stdout: "piped",
|
|
}).output();
|
|
assert(success);
|
|
const output = decoder.decode(stdout);
|
|
assert(output.includes("vary: Accept-Encoding\r\n"));
|
|
assert(output.includes("content-encoding: gzip\r\n"));
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
httpConn!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: "http server compresses streamed bodies - check body",
|
|
permissions: { net: true, run: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
const encoder = new TextEncoder();
|
|
const listener = Deno.listen({ hostname, port });
|
|
|
|
const data = { hello: "deno", now: "with", compressed: "body" };
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function server() {
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.headers.get("Accept-Encoding"), "gzip, deflate, br");
|
|
const bodyInit = new ReadableStream({
|
|
start(controller) {
|
|
controller.enqueue(encoder.encode(JSON.stringify(data)));
|
|
controller.close();
|
|
},
|
|
});
|
|
const response = new Response(
|
|
bodyInit,
|
|
{ headers: { "content-type": "application/json" } },
|
|
);
|
|
await respondWith(response);
|
|
listener.close();
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const args = [
|
|
"--request",
|
|
"GET",
|
|
"--url",
|
|
url,
|
|
"--header",
|
|
"Accept-Encoding: gzip, deflate, br",
|
|
];
|
|
const proc = new Deno.Command("curl", {
|
|
args,
|
|
stderr: "null",
|
|
stdout: "piped",
|
|
}).spawn();
|
|
const status = await proc.status;
|
|
assert(status.success);
|
|
const stdout = proc.stdout
|
|
.pipeThrough(new DecompressionStream("gzip"))
|
|
.pipeThrough(new TextDecoderStream());
|
|
let body = "";
|
|
for await (const chunk of stdout) {
|
|
body += chunk;
|
|
}
|
|
assertEquals(JSON.parse(body), data);
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
httpConn!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: "http server updates content-length header if compression is applied",
|
|
permissions: { net: true, run: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
let contentLength: string;
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function server() {
|
|
const listener = Deno.listen({ hostname, port });
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.headers.get("Accept-Encoding"), "gzip, deflate, br");
|
|
const body = JSON.stringify({
|
|
hello: "deno",
|
|
now: "with",
|
|
compressed: "body",
|
|
});
|
|
contentLength = String(body.length);
|
|
const response = new Response(
|
|
body,
|
|
{
|
|
headers: {
|
|
"content-type": "application/json",
|
|
"content-length": contentLength,
|
|
},
|
|
},
|
|
);
|
|
await respondWith(response);
|
|
listener.close();
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const args = [
|
|
"-i",
|
|
"--request",
|
|
"GET",
|
|
"--url",
|
|
url,
|
|
"--header",
|
|
"Accept-Encoding: gzip, deflate, br",
|
|
];
|
|
const { success, stdout } = await new Deno.Command("curl", {
|
|
args,
|
|
stderr: "null",
|
|
stdout: "piped",
|
|
}).output();
|
|
assert(success);
|
|
const output = decoder.decode(stdout);
|
|
assert(output.includes("vary: Accept-Encoding\r\n"));
|
|
assert(output.includes("content-encoding: gzip\r\n"));
|
|
// Ensure the content-length header is updated (but don't check the exact length).
|
|
assert(!output.includes(`content-length: ${contentLength}\r\n`));
|
|
assert(output.includes("content-length: "));
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
httpConn!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: "http server compresses when accept-encoding is deflate, gzip",
|
|
permissions: { net: true, run: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
let contentLength: string;
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function server() {
|
|
const listener = Deno.listen({ hostname, port });
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.headers.get("Accept-Encoding"), "deflate, gzip");
|
|
const body = "x".repeat(10000);
|
|
contentLength = String(body.length);
|
|
const response = new Response(
|
|
body,
|
|
{
|
|
headers: {
|
|
"content-length": contentLength,
|
|
},
|
|
},
|
|
);
|
|
await respondWith(response);
|
|
listener.close();
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const cmd = [
|
|
"curl",
|
|
"-i",
|
|
"--request",
|
|
"GET",
|
|
"--url",
|
|
url,
|
|
// "--compressed", // Windows curl does not support --compressed
|
|
"--header",
|
|
"Accept-Encoding: deflate, gzip",
|
|
];
|
|
// deno-lint-ignore no-deprecated-deno-api
|
|
const proc = Deno.run({ cmd, stdout: "piped", stderr: "null" });
|
|
const status = await proc.status();
|
|
assert(status.success);
|
|
const output = decoder.decode(await proc.output());
|
|
assert(output.includes("vary: Accept-Encoding\r\n"));
|
|
assert(output.includes("content-encoding: gzip\r\n"));
|
|
// Ensure the content-length header is updated.
|
|
assert(!output.includes(`content-length: ${contentLength}\r\n`));
|
|
assert(output.includes("content-length: "));
|
|
proc.close();
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
httpConn!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: "http server custom content-encoding is left untouched",
|
|
permissions: { net: true, run: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
let contentLength: string;
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function server() {
|
|
const listener = Deno.listen({ hostname, port });
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.headers.get("Accept-Encoding"), "deflate, gzip");
|
|
const body = new Uint8Array([3, 1, 4, 1]);
|
|
contentLength = String(body.length);
|
|
const response = new Response(
|
|
body,
|
|
{
|
|
headers: {
|
|
"content-length": contentLength,
|
|
"content-encoding": "arbitrary",
|
|
},
|
|
},
|
|
);
|
|
await respondWith(response);
|
|
listener.close();
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const cmd = [
|
|
"curl",
|
|
"-i",
|
|
"--request",
|
|
"GET",
|
|
"--url",
|
|
url,
|
|
// "--compressed", // Windows curl does not support --compressed
|
|
"--header",
|
|
"Accept-Encoding: deflate, gzip",
|
|
];
|
|
// deno-lint-ignore no-deprecated-deno-api
|
|
const proc = Deno.run({ cmd, stdout: "piped", stderr: "null" });
|
|
const status = await proc.status();
|
|
assert(status.success);
|
|
const output = decoder.decode(await proc.output());
|
|
assert(output.includes("vary: Accept-Encoding\r\n"));
|
|
assert(output.includes("content-encoding: arbitrary\r\n"));
|
|
proc.close();
|
|
}
|
|
|
|
await Promise.all([server(), client()]);
|
|
httpConn!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerReadLargeBodyWithContentLength() {
|
|
const TLS_PACKET_SIZE = 16 * 1024 + 256;
|
|
// We want the body to be read in multiple packets
|
|
const body = "aa\n" + "deno.land large body\n".repeat(TLS_PACKET_SIZE) +
|
|
"zz";
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
const promise = (async () => {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const conn = await listener.accept();
|
|
listener.close();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const reqEvent = await httpConn.nextRequest();
|
|
assert(reqEvent);
|
|
const { request, respondWith } = reqEvent;
|
|
assertEquals(await request.text(), body);
|
|
await respondWith(new Response(body));
|
|
})();
|
|
|
|
const resp = await fetch(`http://127.0.0.1:${listenPort}/`, {
|
|
method: "POST",
|
|
headers: { "connection": "close" },
|
|
body,
|
|
});
|
|
const text = await resp.text();
|
|
assertEquals(text, body);
|
|
await promise;
|
|
|
|
httpConn!.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerReadLargeBodyWithTransferChunked() {
|
|
const TLS_PACKET_SIZE = 16 * 1024 + 256;
|
|
|
|
// We want the body to be read in multiple packets
|
|
const chunks = [
|
|
"aa\n",
|
|
"deno.land large body\n".repeat(TLS_PACKET_SIZE),
|
|
"zz",
|
|
];
|
|
|
|
const body = chunks.join("");
|
|
|
|
const stream = new TransformStream();
|
|
const writer = stream.writable.getWriter();
|
|
for (const chunk of chunks) {
|
|
writer.write(new TextEncoder().encode(chunk));
|
|
}
|
|
writer.close();
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
const promise = (async () => {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const conn = await listener.accept();
|
|
listener.close();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const reqEvent = await httpConn.nextRequest();
|
|
assert(reqEvent);
|
|
const { request, respondWith } = reqEvent;
|
|
assertEquals(await request.text(), body);
|
|
await respondWith(new Response(body));
|
|
})();
|
|
|
|
const resp = await fetch(`http://127.0.0.1:${listenPort}/`, {
|
|
method: "POST",
|
|
headers: { "connection": "close" },
|
|
body: stream.readable,
|
|
});
|
|
const text = await resp.text();
|
|
assertEquals(text, body);
|
|
await promise;
|
|
|
|
httpConn!.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
permissions: { net: true },
|
|
},
|
|
async function httpServerWithoutExclusiveAccessToTcp() {
|
|
const port = listenPort;
|
|
const listener = Deno.listen({ port });
|
|
|
|
const [clientConn, serverConn] = await Promise.all([
|
|
Deno.connect({ port }),
|
|
listener.accept(),
|
|
]);
|
|
|
|
const buf = new Uint8Array(128);
|
|
const readPromise = serverConn.read(buf);
|
|
assertThrows(() => Deno.serveHttp(serverConn), Deno.errors.BadResource);
|
|
|
|
clientConn.close();
|
|
listener.close();
|
|
await readPromise;
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
permissions: { net: true, read: true },
|
|
},
|
|
async function httpServerWithoutExclusiveAccessToTls() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
const listener = Deno.listenTls({
|
|
hostname,
|
|
port,
|
|
cert: await Deno.readTextFile("tests/testdata/tls/localhost.crt"),
|
|
key: await Deno.readTextFile("tests/testdata/tls/localhost.key"),
|
|
});
|
|
|
|
const caCerts = [
|
|
await Deno.readTextFile("tests/testdata/tls/RootCA.pem"),
|
|
];
|
|
const [clientConn, serverConn] = await Promise.all([
|
|
Deno.connectTls({ hostname, port, caCerts }),
|
|
listener.accept(),
|
|
]);
|
|
await Promise.all([clientConn.handshake(), serverConn.handshake()]);
|
|
|
|
const buf = new Uint8Array(128);
|
|
const readPromise = serverConn.read(buf);
|
|
assertThrows(() => Deno.serveHttp(serverConn), Deno.errors.BadResource);
|
|
|
|
clientConn.close();
|
|
listener.close();
|
|
await readPromise;
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
ignore: Deno.build.os === "windows",
|
|
permissions: { read: true, write: true },
|
|
},
|
|
async function httpServerWithoutExclusiveAccessToUnixSocket() {
|
|
const filePath = tmpUnixSocketPath();
|
|
const listener = Deno.listen({ path: filePath, transport: "unix" });
|
|
|
|
const [clientConn, serverConn] = await Promise.all([
|
|
Deno.connect({ path: filePath, transport: "unix" }),
|
|
listener.accept(),
|
|
]);
|
|
|
|
const buf = new Uint8Array(128);
|
|
const readPromise = serverConn.read(buf);
|
|
assertThrows(() => Deno.serveHttp(serverConn), Deno.errors.BadResource);
|
|
|
|
clientConn.close();
|
|
listener.close();
|
|
await readPromise;
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function httpServerRequestResponseClone() {
|
|
const body = "deno".repeat(64 * 1024);
|
|
let httpConn: Deno.HttpConn;
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const promise = (async () => {
|
|
const conn = await listener.accept();
|
|
listener.close();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const reqEvent = await httpConn.nextRequest();
|
|
assert(reqEvent);
|
|
const { request, respondWith } = reqEvent;
|
|
const clone = request.clone();
|
|
const reader = clone.body!.getReader();
|
|
|
|
// get first chunk from branch2
|
|
const clonedChunks = [];
|
|
const { value, done } = await reader.read();
|
|
assert(!done);
|
|
clonedChunks.push(value);
|
|
|
|
// consume request after first chunk single read
|
|
// readAll should read correctly the rest of the body.
|
|
// firstChunk should be in the stream internal buffer
|
|
const body1 = await request.text();
|
|
|
|
while (true) {
|
|
const { value, done } = await reader.read();
|
|
if (done) break;
|
|
clonedChunks.push(value);
|
|
}
|
|
let offset = 0;
|
|
const body2 = new Uint8Array(body.length);
|
|
for (const chunk of clonedChunks) {
|
|
body2.set(chunk, offset);
|
|
offset += chunk.byteLength;
|
|
}
|
|
|
|
assertEquals(body1, body);
|
|
assertEquals(body1, new TextDecoder().decode(body2));
|
|
await respondWith(new Response(body));
|
|
})();
|
|
|
|
const response = await fetch(`http://localhost:${listenPort}`, {
|
|
body,
|
|
method: "POST",
|
|
});
|
|
const clone = response.clone();
|
|
assertEquals(await response.text(), await clone.text());
|
|
|
|
await promise;
|
|
httpConn!.close();
|
|
},
|
|
);
|
|
|
|
Deno.test({
|
|
name: "http server compresses and flushes each chunk of a streamed resource",
|
|
permissions: { net: true, run: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
const port2 = listenPort2;
|
|
|
|
const encoder = new TextEncoder();
|
|
const listener = Deno.listen({ hostname, port });
|
|
const listener2 = Deno.listen({ hostname, port: port2 });
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function server() {
|
|
const tcpConn = await listener.accept();
|
|
httpConn = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { request, respondWith } = e;
|
|
assertEquals(request.headers.get("Accept-Encoding"), "gzip, deflate, br");
|
|
const resp = await fetch(`http://${hostname}:${port2}/`);
|
|
await respondWith(resp);
|
|
listener.close();
|
|
}
|
|
|
|
const ts = new TransformStream();
|
|
const writer = ts.writable.getWriter();
|
|
writer.write(encoder.encode("hello"));
|
|
|
|
let httpConn2: Deno.HttpConn;
|
|
async function server2() {
|
|
const tcpConn = await listener2.accept();
|
|
httpConn2 = Deno.serveHttp(tcpConn);
|
|
const e = await httpConn2.nextRequest();
|
|
assert(e);
|
|
await e.respondWith(
|
|
new Response(ts.readable, {
|
|
headers: { "Content-Type": "text/plain" },
|
|
}),
|
|
);
|
|
listener2.close();
|
|
}
|
|
|
|
async function client() {
|
|
const url = `http://${hostname}:${port}/`;
|
|
const args = [
|
|
"--request",
|
|
"GET",
|
|
"--url",
|
|
url,
|
|
"--header",
|
|
"Accept-Encoding: gzip, deflate, br",
|
|
"--no-buffer",
|
|
];
|
|
const proc = new Deno.Command("curl", {
|
|
args,
|
|
stderr: "null",
|
|
stdout: "piped",
|
|
}).spawn();
|
|
const stdout = proc.stdout
|
|
.pipeThrough(new DecompressionStream("gzip"))
|
|
.pipeThrough(new TextDecoderStream());
|
|
let body = "";
|
|
for await (const chunk of stdout) {
|
|
body += chunk;
|
|
if (body === "hello") {
|
|
writer.write(encoder.encode(" world"));
|
|
writer.close();
|
|
}
|
|
}
|
|
assertEquals(body, "hello world");
|
|
const status = await proc.status;
|
|
assert(status.success);
|
|
}
|
|
|
|
await Promise.all([server(), server2(), client()]);
|
|
httpConn!.close();
|
|
httpConn2!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test("case insensitive comma value finder", async (t) => {
|
|
const cases = /** @type {[string, boolean][]} */ ([
|
|
["websocket", true],
|
|
["wEbSOcKET", true],
|
|
[",wEbSOcKET", true],
|
|
[",wEbSOcKET,", true],
|
|
[", wEbSOcKET ,", true],
|
|
["test, wEbSOcKET ,", true],
|
|
["test ,\twEbSOcKET\t\t ,", true],
|
|
["test , wEbSOcKET", true],
|
|
["test, asdf,web,wEbSOcKET", true],
|
|
["test, asdf,web,wEbSOcKETs", false],
|
|
["test, asdf,awebsocket,wEbSOcKETs", false],
|
|
]);
|
|
|
|
const findValue = buildCaseInsensitiveCommaValueFinder("websocket");
|
|
for (const [input, expected] of cases) {
|
|
await t.step(input.toString(), () => {
|
|
const actual = findValue(input);
|
|
assertEquals(actual, expected);
|
|
});
|
|
}
|
|
});
|
|
|
|
async function httpServerWithErrorBody(
|
|
listener: Deno.Listener,
|
|
compression: boolean,
|
|
): Promise<Deno.HttpConn> {
|
|
const conn = await listener.accept();
|
|
listener.close();
|
|
const httpConn = Deno.serveHttp(conn);
|
|
const e = await httpConn.nextRequest();
|
|
assert(e);
|
|
const { respondWith } = e;
|
|
const originalErr = new Error("boom");
|
|
const rs = new ReadableStream({
|
|
async start(controller) {
|
|
controller.enqueue(new Uint8Array([65]));
|
|
await delay(1000);
|
|
controller.error(originalErr);
|
|
},
|
|
});
|
|
const init = compression ? { headers: { "content-type": "text/plain" } } : {};
|
|
const response = new Response(rs, init);
|
|
const err = await assertRejects(() => respondWith(response));
|
|
assert(err === originalErr);
|
|
return httpConn;
|
|
}
|
|
|
|
for (const compression of [true, false]) {
|
|
Deno.test({
|
|
name: `http server errors stream if response body errors (http/1.1${
|
|
compression ? " + compression" : ""
|
|
})`,
|
|
permissions: { net: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
const listener = Deno.listen({ hostname, port });
|
|
const server = httpServerWithErrorBody(listener, compression);
|
|
|
|
const conn = await Deno.connect({ hostname, port });
|
|
const msg = new TextEncoder().encode(
|
|
`GET / HTTP/1.1\r\nHost: ${hostname}:${port}\r\n\r\n`,
|
|
);
|
|
const nwritten = await conn.write(msg);
|
|
assertEquals(nwritten, msg.byteLength);
|
|
|
|
const buf = new Uint8Array(1024);
|
|
const nread = await conn.read(buf);
|
|
assert(nread);
|
|
const data = new TextDecoder().decode(buf.subarray(0, nread));
|
|
assert(data.endsWith("1\r\nA\r\n"));
|
|
const nread2 = await conn.read(buf); // connection should be closed now because the stream errored
|
|
assertEquals(nread2, null);
|
|
conn.close();
|
|
|
|
const httpConn = await server;
|
|
httpConn.close();
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: `http server errors stream if response body errors (http/1.1 + fetch${
|
|
compression ? " + compression" : ""
|
|
})`,
|
|
permissions: { net: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
const listener = Deno.listen({ hostname, port });
|
|
const server = httpServerWithErrorBody(listener, compression);
|
|
|
|
const resp = await fetch(`http://${hostname}:${port}/`);
|
|
assert(resp.body);
|
|
const reader = resp.body.getReader();
|
|
const result = await reader.read();
|
|
assert(!result.done);
|
|
assertEquals(result.value, new Uint8Array([65]));
|
|
const err = await assertRejects(() => reader.read());
|
|
assert(err instanceof TypeError);
|
|
assert(err.message.includes("unexpected EOF"));
|
|
|
|
const httpConn = await server;
|
|
httpConn.close();
|
|
},
|
|
});
|
|
|
|
Deno.test({
|
|
name: `http server errors stream if response body errors (http/2 + fetch${
|
|
compression ? " + compression" : ""
|
|
}))`,
|
|
permissions: { net: true, read: true },
|
|
async fn() {
|
|
const hostname = "localhost";
|
|
const port = listenPort;
|
|
|
|
const listener = Deno.listenTls({
|
|
hostname,
|
|
port,
|
|
cert: await Deno.readTextFile("tests/testdata/tls/localhost.crt"),
|
|
key: await Deno.readTextFile("tests/testdata/tls/localhost.key"),
|
|
alpnProtocols: ["h2"],
|
|
});
|
|
const server = httpServerWithErrorBody(listener, compression);
|
|
|
|
const caCert = Deno.readTextFileSync("tests/testdata/tls/RootCA.pem");
|
|
const client = Deno.createHttpClient({ caCerts: [caCert] });
|
|
const resp = await fetch(`https://${hostname}:${port}/`, { client });
|
|
client.close();
|
|
assert(resp.body);
|
|
const reader = resp.body.getReader();
|
|
const result = await reader.read();
|
|
assert(!result.done);
|
|
assertEquals(result.value, new Uint8Array([65]));
|
|
const err = await assertRejects(() => reader.read());
|
|
assert(err instanceof TypeError);
|
|
assert(err.message.includes("unexpected internal error encountered"));
|
|
|
|
const httpConn = await server;
|
|
httpConn.close();
|
|
},
|
|
});
|
|
}
|
|
|
|
Deno.test({
|
|
name: "request signal is aborted when response errors",
|
|
permissions: { net: true },
|
|
async fn() {
|
|
let httpConn: Deno.HttpConn;
|
|
const promise = (async () => {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const conn = await listener.accept();
|
|
listener.close();
|
|
httpConn = Deno.serveHttp(conn);
|
|
const ev = await httpConn.nextRequest();
|
|
const { request, respondWith } = ev!;
|
|
|
|
await delay(300);
|
|
await assertRejects(() => respondWith(new Response("Hello World")));
|
|
assert(request.signal.aborted);
|
|
})();
|
|
|
|
const abortController = new AbortController();
|
|
|
|
fetch(`http://127.0.0.1:${listenPort}/`, {
|
|
signal: abortController.signal,
|
|
}).catch(() => {
|
|
// ignore
|
|
});
|
|
|
|
await delay(100);
|
|
abortController.abort();
|
|
await promise;
|
|
httpConn!.close();
|
|
},
|
|
});
|
|
|
|
Deno.test(
|
|
async function httpConnExplicitResourceManagement() {
|
|
let promise;
|
|
|
|
{
|
|
const listen = Deno.listen({ port: listenPort });
|
|
promise = fetch(`http://localhost:${listenPort}/`).catch(() => null);
|
|
const serverConn = await listen.accept();
|
|
listen.close();
|
|
|
|
using _httpConn = Deno.serveHttp(serverConn);
|
|
}
|
|
|
|
const response = await promise;
|
|
assertEquals(response, null);
|
|
},
|
|
);
|
|
|
|
Deno.test("proxy with fetch", async () => {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const deferred = Promise.withResolvers<void>();
|
|
|
|
const server = Deno.serve({ port: listenPort + 1 }, (_req) => {
|
|
return new Response("Hello world");
|
|
});
|
|
|
|
let httpConn: Deno.HttpConn;
|
|
async function handleHttp(conn: Deno.Conn) {
|
|
httpConn = Deno.serveHttp(conn);
|
|
for await (const e of httpConn) {
|
|
await e.respondWith(serve(e.request));
|
|
break;
|
|
}
|
|
}
|
|
|
|
async function serve(req: Request) {
|
|
return await fetch(`http://localhost:${listenPort + 1}/`, req);
|
|
}
|
|
|
|
const originServer = (async () => {
|
|
for await (const conn of listener) {
|
|
handleHttp(conn);
|
|
break;
|
|
}
|
|
})();
|
|
|
|
const proxiedRequest = (async () => {
|
|
const conn = await Deno.connect({ port: listenPort });
|
|
const payload = new TextEncoder().encode(
|
|
"POST /api/sessions HTTP/1.1\x0d\x0aConnection: keep-alive\x0d\x0aContent-Length: 2\x0d\x0a\x0d\x0a{}",
|
|
);
|
|
const n = await conn.write(payload);
|
|
assertEquals(n, 76);
|
|
const buf = new Uint8Array(1000);
|
|
const nread = await conn.read(buf);
|
|
assertEquals(nread, 150);
|
|
const respText = new TextDecoder().decode(buf);
|
|
assert(respText.includes("HTTP/1.1 200 OK"));
|
|
assert(respText.includes("content-type: text/plain;charset=UTF-8"));
|
|
assert(respText.includes("vary: Accept-Encoding"));
|
|
assert(respText.includes("content-length: 11"));
|
|
assert(respText.includes("Hello world"));
|
|
conn.close();
|
|
deferred.resolve();
|
|
})();
|
|
await proxiedRequest;
|
|
await originServer;
|
|
await deferred.promise;
|
|
await server.shutdown();
|
|
await server.finished;
|
|
httpConn!.close();
|
|
});
|
|
|
|
function chunkedBodyReader(h: Headers, r: BufReader): Deno.Reader {
|
|
// Based on https://tools.ietf.org/html/rfc2616#section-19.4.6
|
|
const tp = new TextProtoReader(r);
|
|
let finished = false;
|
|
const chunks: Array<{
|
|
offset: number;
|
|
data: Uint8Array;
|
|
}> = [];
|
|
async function read(buf: Uint8Array): Promise<number | null> {
|
|
if (finished) return null;
|
|
const [chunk] = chunks;
|
|
if (chunk) {
|
|
const chunkRemaining = chunk.data.byteLength - chunk.offset;
|
|
const readLength = Math.min(chunkRemaining, buf.byteLength);
|
|
for (let i = 0; i < readLength; i++) {
|
|
buf[i] = chunk.data[chunk.offset + i];
|
|
}
|
|
chunk.offset += readLength;
|
|
if (chunk.offset === chunk.data.byteLength) {
|
|
chunks.shift();
|
|
// Consume \r\n;
|
|
if ((await tp.readLine()) === null) {
|
|
throw new Deno.errors.UnexpectedEof();
|
|
}
|
|
}
|
|
return readLength;
|
|
}
|
|
const line = await tp.readLine();
|
|
if (line === null) throw new Deno.errors.UnexpectedEof();
|
|
// TODO(bartlomieju): handle chunk extension
|
|
const [chunkSizeString] = line.split(";");
|
|
const chunkSize = parseInt(chunkSizeString, 16);
|
|
if (Number.isNaN(chunkSize) || chunkSize < 0) {
|
|
throw new Deno.errors.InvalidData("Invalid chunk size");
|
|
}
|
|
if (chunkSize > 0) {
|
|
if (chunkSize > buf.byteLength) {
|
|
let eof = await r.readFull(buf);
|
|
if (eof === null) {
|
|
throw new Deno.errors.UnexpectedEof();
|
|
}
|
|
const restChunk = new Uint8Array(chunkSize - buf.byteLength);
|
|
eof = await r.readFull(restChunk);
|
|
if (eof === null) {
|
|
throw new Deno.errors.UnexpectedEof();
|
|
} else {
|
|
chunks.push({
|
|
offset: 0,
|
|
data: restChunk,
|
|
});
|
|
}
|
|
return buf.byteLength;
|
|
} else {
|
|
const bufToFill = buf.subarray(0, chunkSize);
|
|
const eof = await r.readFull(bufToFill);
|
|
if (eof === null) {
|
|
throw new Deno.errors.UnexpectedEof();
|
|
}
|
|
// Consume \r\n
|
|
if ((await tp.readLine()) === null) {
|
|
throw new Deno.errors.UnexpectedEof();
|
|
}
|
|
return chunkSize;
|
|
}
|
|
} else {
|
|
assert(chunkSize === 0);
|
|
// Consume \r\n
|
|
if ((await r.readLine()) === null) {
|
|
throw new Deno.errors.UnexpectedEof();
|
|
}
|
|
await readTrailers(h, r);
|
|
finished = true;
|
|
return null;
|
|
}
|
|
}
|
|
return { read };
|
|
}
|
|
|
|
async function readTrailers(
|
|
headers: Headers,
|
|
r: BufReader,
|
|
) {
|
|
const trailers = parseTrailer(headers.get("trailer"));
|
|
if (trailers == null) return;
|
|
const trailerNames = [...trailers.keys()];
|
|
const tp = new TextProtoReader(r);
|
|
const result = await tp.readMimeHeader();
|
|
if (result == null) {
|
|
throw new Deno.errors.InvalidData("Missing trailer header.");
|
|
}
|
|
const undeclared = [...result.keys()].filter(
|
|
(k) => !trailerNames.includes(k),
|
|
);
|
|
if (undeclared.length > 0) {
|
|
throw new Deno.errors.InvalidData(
|
|
`Undeclared trailers: ${Deno.inspect(undeclared)}.`,
|
|
);
|
|
}
|
|
for (const [k, v] of result) {
|
|
headers.append(k, v);
|
|
}
|
|
const missingTrailers = trailerNames.filter((k) => !result.has(k));
|
|
if (missingTrailers.length > 0) {
|
|
throw new Deno.errors.InvalidData(
|
|
`Missing trailers: ${Deno.inspect(missingTrailers)}.`,
|
|
);
|
|
}
|
|
headers.delete("trailer");
|
|
}
|
|
|
|
function parseTrailer(field: string | null): Headers | undefined {
|
|
if (field == null) {
|
|
return undefined;
|
|
}
|
|
const trailerNames = field.split(",").map((v) => v.trim().toLowerCase());
|
|
if (trailerNames.length === 0) {
|
|
throw new Deno.errors.InvalidData("Empty trailer header.");
|
|
}
|
|
const prohibited = trailerNames.filter((k) => isProhibitedForTrailer(k));
|
|
if (prohibited.length > 0) {
|
|
throw new Deno.errors.InvalidData(
|
|
`Prohibited trailer names: ${Deno.inspect(prohibited)}.`,
|
|
);
|
|
}
|
|
return new Headers(trailerNames.map((key) => [key, ""]));
|
|
}
|
|
|
|
function isProhibitedForTrailer(key: string): boolean {
|
|
const s = new Set(["transfer-encoding", "content-length", "trailer"]);
|
|
return s.has(key.toLowerCase());
|
|
}
|