mirror of
https://github.com/denoland/deno.git
synced 2024-12-20 14:24:48 -05:00
1329 lines
36 KiB
TypeScript
1329 lines
36 KiB
TypeScript
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
|
|
import {
|
|
assert,
|
|
assertEquals,
|
|
assertRejects,
|
|
assertThrows,
|
|
delay,
|
|
execCode,
|
|
execCode2,
|
|
tmpUnixSocketPath,
|
|
} from "./test_util.ts";
|
|
|
|
// Since these tests may run in parallel, ensure this port is unique to this file
|
|
const listenPort = 4503;
|
|
const listenPort2 = 4504;
|
|
|
|
let isCI: boolean;
|
|
try {
|
|
isCI = Deno.env.get("CI") !== undefined;
|
|
} catch {
|
|
isCI = true;
|
|
}
|
|
|
|
Deno.test({ permissions: { net: true } }, function netTcpListenClose() {
|
|
const listener = Deno.listen({ hostname: "127.0.0.1", port: listenPort });
|
|
assert(listener.addr.transport === "tcp");
|
|
assertEquals(listener.addr.hostname, "127.0.0.1");
|
|
assertEquals(listener.addr.port, listenPort);
|
|
listener.close();
|
|
});
|
|
|
|
Deno.test(
|
|
{
|
|
permissions: { net: true },
|
|
},
|
|
function netUdpListenClose() {
|
|
const socket = Deno.listenDatagram({
|
|
hostname: "127.0.0.1",
|
|
port: listenPort,
|
|
transport: "udp",
|
|
});
|
|
assert(socket.addr.transport === "udp");
|
|
assertEquals(socket.addr.hostname, "127.0.0.1");
|
|
assertEquals(socket.addr.port, listenPort);
|
|
socket.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
ignore: Deno.build.os === "windows",
|
|
permissions: { read: true, write: true },
|
|
},
|
|
function netUnixListenClose() {
|
|
const filePath = tmpUnixSocketPath();
|
|
const socket = Deno.listen({
|
|
path: filePath,
|
|
transport: "unix",
|
|
});
|
|
assert(socket.addr.transport === "unix");
|
|
assertEquals(socket.addr.path, filePath);
|
|
socket.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
ignore: Deno.build.os === "windows",
|
|
permissions: { read: true, write: true },
|
|
},
|
|
function netUnixPacketListenClose() {
|
|
const filePath = tmpUnixSocketPath();
|
|
const socket = Deno.listenDatagram({
|
|
path: filePath,
|
|
transport: "unixpacket",
|
|
});
|
|
assert(socket.addr.transport === "unixpacket");
|
|
assertEquals(socket.addr.path, filePath);
|
|
socket.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
ignore: Deno.build.os === "windows",
|
|
permissions: { read: true, write: false },
|
|
},
|
|
function netUnixListenWritePermission() {
|
|
assertThrows(() => {
|
|
const filePath = tmpUnixSocketPath();
|
|
const socket = Deno.listen({
|
|
path: filePath,
|
|
transport: "unix",
|
|
});
|
|
assert(socket.addr.transport === "unix");
|
|
assertEquals(socket.addr.path, filePath);
|
|
socket.close();
|
|
}, Deno.errors.NotCapable);
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
ignore: Deno.build.os === "windows",
|
|
permissions: { read: true, write: false },
|
|
},
|
|
function netUnixPacketListenWritePermission() {
|
|
assertThrows(() => {
|
|
const filePath = tmpUnixSocketPath();
|
|
const socket = Deno.listenDatagram({
|
|
path: filePath,
|
|
transport: "unixpacket",
|
|
});
|
|
assert(socket.addr.transport === "unixpacket");
|
|
assertEquals(socket.addr.path, filePath);
|
|
socket.close();
|
|
}, Deno.errors.NotCapable);
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
permissions: { net: true },
|
|
},
|
|
async function netTcpCloseWhileAccept() {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const p = listener.accept();
|
|
listener.close();
|
|
await assertRejects(
|
|
() => p,
|
|
Deno.errors.BadResource,
|
|
"Listener has been closed",
|
|
);
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
ignore: Deno.build.os === "windows",
|
|
permissions: { read: true, write: true },
|
|
},
|
|
async function netUnixCloseWhileAccept() {
|
|
const filePath = tmpUnixSocketPath();
|
|
const listener = Deno.listen({
|
|
path: filePath,
|
|
transport: "unix",
|
|
});
|
|
const p = listener.accept();
|
|
listener.close();
|
|
await assertRejects(
|
|
() => p,
|
|
Deno.errors.BadResource,
|
|
"Listener has been closed",
|
|
);
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function netTcpConcurrentAccept() {
|
|
const listener = Deno.listen({ port: 4510 });
|
|
let acceptErrCount = 0;
|
|
const checkErr = (e: Error) => {
|
|
if (e.message === "Listener has been closed") {
|
|
assertEquals(acceptErrCount, 1);
|
|
} else if (e.message === "Another accept task is ongoing") {
|
|
acceptErrCount++;
|
|
} else {
|
|
throw e;
|
|
}
|
|
};
|
|
const p = listener.accept().catch(checkErr);
|
|
const p1 = listener.accept().catch(checkErr);
|
|
await Promise.race([p, p1]);
|
|
listener.close();
|
|
await Promise.all([p, p1]);
|
|
assertEquals(acceptErrCount, 1);
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
ignore: Deno.build.os === "windows",
|
|
permissions: { read: true, write: true },
|
|
},
|
|
async function netUnixConcurrentAccept() {
|
|
const filePath = tmpUnixSocketPath();
|
|
const listener = Deno.listen({ transport: "unix", path: filePath });
|
|
let acceptErrCount = 0;
|
|
const checkErr = (e: Error) => {
|
|
if (e.message === "Listener has been closed") {
|
|
assertEquals(acceptErrCount, 1);
|
|
} else if (e instanceof Deno.errors.Busy) { // "Listener already in use"
|
|
acceptErrCount++;
|
|
} else {
|
|
throw e;
|
|
}
|
|
};
|
|
const p = listener.accept().catch(checkErr);
|
|
const p1 = listener.accept().catch(checkErr);
|
|
await Promise.race([p, p1]);
|
|
listener.close();
|
|
await Promise.all([p, p1]);
|
|
assertEquals(acceptErrCount, 1);
|
|
},
|
|
);
|
|
|
|
Deno.test({ permissions: { net: true } }, async function netTcpDialListen() {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
listener.accept().then(
|
|
async (conn) => {
|
|
assert(conn.remoteAddr != null);
|
|
assert(conn.localAddr.transport === "tcp");
|
|
assertEquals(conn.localAddr.hostname, "127.0.0.1");
|
|
assertEquals(conn.localAddr.port, listenPort);
|
|
await conn.write(new Uint8Array([1, 2, 3]));
|
|
conn.close();
|
|
},
|
|
);
|
|
|
|
const conn = await Deno.connect({ hostname: "127.0.0.1", port: listenPort });
|
|
assert(conn.remoteAddr.transport === "tcp");
|
|
assertEquals(conn.remoteAddr.hostname, "127.0.0.1");
|
|
assertEquals(conn.remoteAddr.port, listenPort);
|
|
assert(conn.localAddr != null);
|
|
const buf = new Uint8Array(1024);
|
|
const readResult = await conn.read(buf);
|
|
assertEquals(3, readResult);
|
|
assertEquals(1, buf[0]);
|
|
assertEquals(2, buf[1]);
|
|
assertEquals(3, buf[2]);
|
|
|
|
assert(readResult !== null);
|
|
|
|
const readResult2 = await conn.read(buf);
|
|
assertEquals(readResult2, null);
|
|
|
|
listener.close();
|
|
conn.close();
|
|
});
|
|
|
|
Deno.test({ permissions: { net: true } }, async function netTcpSetNoDelay() {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
listener.accept().then(
|
|
async (conn) => {
|
|
assert(conn.remoteAddr != null);
|
|
assert(conn.localAddr.transport === "tcp");
|
|
assertEquals(conn.localAddr.hostname, "127.0.0.1");
|
|
assertEquals(conn.localAddr.port, listenPort);
|
|
await conn.write(new Uint8Array([1, 2, 3]));
|
|
conn.close();
|
|
},
|
|
);
|
|
|
|
const conn = await Deno.connect({ hostname: "127.0.0.1", port: listenPort });
|
|
conn.setNoDelay(true);
|
|
assert(conn.remoteAddr.transport === "tcp");
|
|
assertEquals(conn.remoteAddr.hostname, "127.0.0.1");
|
|
assertEquals(conn.remoteAddr.port, listenPort);
|
|
assert(conn.localAddr != null);
|
|
const buf = new Uint8Array(1024);
|
|
const readResult = await conn.read(buf);
|
|
assertEquals(3, readResult);
|
|
assertEquals(1, buf[0]);
|
|
assertEquals(2, buf[1]);
|
|
assertEquals(3, buf[2]);
|
|
|
|
assert(readResult !== null);
|
|
|
|
const readResult2 = await conn.read(buf);
|
|
assertEquals(readResult2, null);
|
|
|
|
listener.close();
|
|
conn.close();
|
|
});
|
|
|
|
Deno.test({ permissions: { net: true } }, async function netTcpSetKeepAlive() {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
listener.accept().then(
|
|
async (conn) => {
|
|
assert(conn.remoteAddr != null);
|
|
assert(conn.localAddr.transport === "tcp");
|
|
assertEquals(conn.localAddr.hostname, "127.0.0.1");
|
|
assertEquals(conn.localAddr.port, listenPort);
|
|
await conn.write(new Uint8Array([1, 2, 3]));
|
|
conn.close();
|
|
},
|
|
);
|
|
|
|
const conn = await Deno.connect({ hostname: "127.0.0.1", port: listenPort });
|
|
conn.setKeepAlive(true);
|
|
assert(conn.remoteAddr.transport === "tcp");
|
|
assertEquals(conn.remoteAddr.hostname, "127.0.0.1");
|
|
assertEquals(conn.remoteAddr.port, listenPort);
|
|
assert(conn.localAddr != null);
|
|
const buf = new Uint8Array(1024);
|
|
const readResult = await conn.read(buf);
|
|
assertEquals(3, readResult);
|
|
assertEquals(1, buf[0]);
|
|
assertEquals(2, buf[1]);
|
|
assertEquals(3, buf[2]);
|
|
|
|
assert(readResult !== null);
|
|
|
|
const readResult2 = await conn.read(buf);
|
|
assertEquals(readResult2, null);
|
|
|
|
listener.close();
|
|
conn.close();
|
|
});
|
|
|
|
Deno.test(
|
|
{
|
|
ignore: Deno.build.os === "windows",
|
|
permissions: { read: true, write: true },
|
|
},
|
|
async function netUnixDialListen() {
|
|
const filePath = tmpUnixSocketPath();
|
|
const listener = Deno.listen({ path: filePath, transport: "unix" });
|
|
listener.accept().then(
|
|
async (conn) => {
|
|
assert(conn.remoteAddr != null);
|
|
assert(conn.localAddr.transport === "unix");
|
|
assertEquals(conn.localAddr.path, filePath);
|
|
await conn.write(new Uint8Array([1, 2, 3]));
|
|
conn.close();
|
|
},
|
|
);
|
|
const conn = await Deno.connect({ path: filePath, transport: "unix" });
|
|
assert(conn.remoteAddr.transport === "unix");
|
|
assertEquals(conn.remoteAddr.path, filePath);
|
|
assert(conn.remoteAddr != null);
|
|
const buf = new Uint8Array(1024);
|
|
const readResult = await conn.read(buf);
|
|
assertEquals(3, readResult);
|
|
assertEquals(1, buf[0]);
|
|
assertEquals(2, buf[1]);
|
|
assertEquals(3, buf[2]);
|
|
|
|
assert(readResult !== null);
|
|
|
|
const readResult2 = await conn.read(buf);
|
|
assertEquals(readResult2, null);
|
|
|
|
listener.close();
|
|
conn.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function netUdpSendReceive() {
|
|
const alice = Deno.listenDatagram({ port: listenPort, transport: "udp" });
|
|
assert(alice.addr.transport === "udp");
|
|
assertEquals(alice.addr.port, listenPort);
|
|
assertEquals(alice.addr.hostname, "127.0.0.1");
|
|
|
|
const bob = Deno.listenDatagram({ port: listenPort2, transport: "udp" });
|
|
assert(bob.addr.transport === "udp");
|
|
assertEquals(bob.addr.port, listenPort2);
|
|
assertEquals(bob.addr.hostname, "127.0.0.1");
|
|
|
|
const sent = new Uint8Array([1, 2, 3]);
|
|
const byteLength = await alice.send(sent, bob.addr);
|
|
|
|
assertEquals(byteLength, 3);
|
|
|
|
const [recvd, remote] = await bob.receive();
|
|
assert(remote.transport === "udp");
|
|
assertEquals(remote.port, listenPort);
|
|
assertEquals(recvd.length, 3);
|
|
assertEquals(1, recvd[0]);
|
|
assertEquals(2, recvd[1]);
|
|
assertEquals(3, recvd[2]);
|
|
alice.close();
|
|
bob.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function netUdpSendReceiveTestSizeLimits() {
|
|
// Ensure payload being sent is within UDP limit, which seems to be 65507
|
|
// bytes
|
|
const alice = Deno.listenDatagram({
|
|
port: listenPort,
|
|
transport: "udp",
|
|
hostname: "127.0.0.1",
|
|
});
|
|
// wrap this in a try/catch so other tests can continue if we fail
|
|
// if we don't close here then listening on future tests fails
|
|
try {
|
|
assert(alice.addr.transport === "udp");
|
|
assertEquals(alice.addr.port, listenPort);
|
|
assertEquals(alice.addr.hostname, "127.0.0.1");
|
|
} catch (err) {
|
|
alice.close();
|
|
throw err;
|
|
}
|
|
|
|
const bob = Deno.listenDatagram({
|
|
port: listenPort2,
|
|
transport: "udp",
|
|
hostname: "127.0.0.1",
|
|
});
|
|
try {
|
|
assert(bob.addr.transport === "udp");
|
|
assertEquals(bob.addr.port, listenPort2);
|
|
assertEquals(bob.addr.hostname, "127.0.0.1");
|
|
} catch (err) {
|
|
bob.close();
|
|
throw err;
|
|
}
|
|
|
|
const sizes = [0, 1, 2, 256, 1024, 4096, 16384, 65506, 65507, 65508, 65536];
|
|
const rx = /.+ \(os error \d+\)/;
|
|
|
|
for (const size of sizes) {
|
|
const tosend = new Uint8Array(size);
|
|
let byteLength = 0;
|
|
try {
|
|
byteLength = await alice.send(tosend, bob.addr);
|
|
} catch (err) {
|
|
// Note: we have to do the test this way as different OS's have
|
|
// different UDP size limits enabled, so we will just ensure if
|
|
// an error is thrown it is the one we are expecting.
|
|
assert((err as Error).message.match(rx));
|
|
alice.close();
|
|
bob.close();
|
|
return;
|
|
}
|
|
assertEquals(byteLength, size);
|
|
const [recvd, remote] = await bob.receive();
|
|
assert(remote.transport === "udp");
|
|
assertEquals(remote.port, listenPort);
|
|
assertEquals(recvd.length, size);
|
|
}
|
|
|
|
alice.close();
|
|
bob.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true }, ignore: true },
|
|
async function netUdpSendReceiveBroadcast() {
|
|
// Must bind sender to an address that can send to the broadcast address on MacOS.
|
|
// Macos will give us error 49 when sending the broadcast packet if we omit hostname here.
|
|
const alice = Deno.listenDatagram({
|
|
port: listenPort,
|
|
transport: "udp",
|
|
hostname: "0.0.0.0",
|
|
});
|
|
|
|
const bob = Deno.listenDatagram({
|
|
port: listenPort,
|
|
transport: "udp",
|
|
hostname: "0.0.0.0",
|
|
});
|
|
assert(bob.addr.transport === "udp");
|
|
assertEquals(bob.addr.port, listenPort);
|
|
assertEquals(bob.addr.hostname, "0.0.0.0");
|
|
|
|
const broadcastAddr = { ...bob.addr, hostname: "255.255.255.255" };
|
|
|
|
const sent = new Uint8Array([1, 2, 3]);
|
|
const byteLength = await alice.send(sent, broadcastAddr);
|
|
|
|
assertEquals(byteLength, 3);
|
|
const [recvd, remote] = await bob.receive();
|
|
assert(remote.transport === "udp");
|
|
assertEquals(remote.port, listenPort);
|
|
assertEquals(recvd.length, 3);
|
|
assertEquals(1, recvd[0]);
|
|
assertEquals(2, recvd[1]);
|
|
assertEquals(3, recvd[2]);
|
|
alice.close();
|
|
bob.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true }, ignore: true },
|
|
async function netUdpMulticastV4() {
|
|
const listener = Deno.listenDatagram({
|
|
hostname: "0.0.0.0",
|
|
port: 5353,
|
|
transport: "udp",
|
|
reuseAddress: true,
|
|
});
|
|
|
|
const membership = await listener.joinMulticastV4(
|
|
"224.0.0.251",
|
|
"127.0.0.1",
|
|
);
|
|
|
|
membership.setLoopback(true);
|
|
membership.setLoopback(false);
|
|
membership.setTTL(50);
|
|
membership.leave();
|
|
listener.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true }, ignore: true },
|
|
async function netUdpMulticastV6() {
|
|
const listener = Deno.listenDatagram({
|
|
hostname: "::",
|
|
port: 5353,
|
|
transport: "udp",
|
|
reuseAddress: true,
|
|
});
|
|
|
|
const membership = await listener.joinMulticastV6(
|
|
"ff02::fb",
|
|
1,
|
|
);
|
|
|
|
membership.setLoopback(true);
|
|
membership.setLoopback(false);
|
|
membership.leave();
|
|
listener.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true }, ignore: true },
|
|
async function netUdpSendReceiveMulticastv4() {
|
|
const alice = Deno.listenDatagram({
|
|
hostname: "0.0.0.0",
|
|
port: 5353,
|
|
transport: "udp",
|
|
reuseAddress: true,
|
|
loopback: true,
|
|
});
|
|
|
|
const bob = Deno.listenDatagram({
|
|
hostname: "0.0.0.0",
|
|
port: 5353,
|
|
transport: "udp",
|
|
reuseAddress: true,
|
|
});
|
|
|
|
const aliceMembership = await alice.joinMulticastV4(
|
|
"224.0.0.1",
|
|
"0.0.0.0",
|
|
);
|
|
|
|
const bobMembership = await bob.joinMulticastV4("224.0.0.1", "0.0.0.0");
|
|
|
|
const sent = new Uint8Array([1, 2, 3]);
|
|
|
|
await alice.send(sent, {
|
|
hostname: "224.0.0.1",
|
|
port: 5353,
|
|
transport: "udp",
|
|
});
|
|
|
|
const [recvd, remote] = await bob.receive();
|
|
|
|
assert(remote.transport === "udp");
|
|
assertEquals(remote.port, 5353);
|
|
assertEquals(recvd.length, 3);
|
|
assertEquals(1, recvd[0]);
|
|
assertEquals(2, recvd[1]);
|
|
assertEquals(3, recvd[2]);
|
|
|
|
aliceMembership.leave();
|
|
bobMembership.leave();
|
|
|
|
alice.close();
|
|
bob.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true }, ignore: true },
|
|
async function netUdpMulticastLoopbackOption() {
|
|
// Must bind sender to an address that can send to the broadcast address on MacOS.
|
|
// Macos will give us error 49 when sending the broadcast packet if we omit hostname here.
|
|
const listener = Deno.listenDatagram({
|
|
port: 5353,
|
|
transport: "udp",
|
|
hostname: "0.0.0.0",
|
|
loopback: true,
|
|
reuseAddress: true,
|
|
});
|
|
|
|
const membership = await listener.joinMulticastV4(
|
|
"224.0.0.1",
|
|
"0.0.0.0",
|
|
);
|
|
|
|
// await membership.setLoopback(true);
|
|
|
|
const sent = new Uint8Array([1, 2, 3]);
|
|
const byteLength = await listener.send(sent, {
|
|
hostname: "224.0.0.1",
|
|
port: 5353,
|
|
transport: "udp",
|
|
});
|
|
|
|
assertEquals(byteLength, 3);
|
|
const [recvd, remote] = await listener.receive();
|
|
assert(remote.transport === "udp");
|
|
assertEquals(remote.port, 5353);
|
|
assertEquals(recvd.length, 3);
|
|
assertEquals(1, recvd[0]);
|
|
assertEquals(2, recvd[1]);
|
|
assertEquals(3, recvd[2]);
|
|
membership.leave();
|
|
listener.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function netUdpConcurrentSendReceive() {
|
|
const socket = Deno.listenDatagram({ port: listenPort, transport: "udp" });
|
|
assert(socket.addr.transport === "udp");
|
|
assertEquals(socket.addr.port, listenPort);
|
|
assertEquals(socket.addr.hostname, "127.0.0.1");
|
|
|
|
const recvPromise = socket.receive();
|
|
|
|
const sendBuf = new Uint8Array([1, 2, 3]);
|
|
const sendLen = await socket.send(sendBuf, socket.addr);
|
|
assertEquals(sendLen, 3);
|
|
|
|
const [recvBuf, _recvAddr] = await recvPromise;
|
|
assertEquals(recvBuf.length, 3);
|
|
assertEquals(1, recvBuf[0]);
|
|
assertEquals(2, recvBuf[1]);
|
|
assertEquals(3, recvBuf[2]);
|
|
|
|
socket.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function netUdpBorrowMutError() {
|
|
const socket = Deno.listenDatagram({
|
|
port: listenPort,
|
|
transport: "udp",
|
|
});
|
|
// Panic happened on second send: BorrowMutError
|
|
const a = socket.send(new Uint8Array(), socket.addr);
|
|
const b = socket.send(new Uint8Array(), socket.addr);
|
|
await Promise.all([a, b]);
|
|
socket.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
ignore: Deno.build.os === "windows",
|
|
permissions: { read: true, write: true },
|
|
},
|
|
async function netUnixPacketSendReceive() {
|
|
const aliceFilePath = tmpUnixSocketPath();
|
|
const alice = Deno.listenDatagram({
|
|
path: aliceFilePath,
|
|
transport: "unixpacket",
|
|
});
|
|
assert(alice.addr.transport === "unixpacket");
|
|
assertEquals(alice.addr.path, aliceFilePath);
|
|
|
|
const bobFilePath = tmpUnixSocketPath();
|
|
const bob = Deno.listenDatagram({
|
|
path: bobFilePath,
|
|
transport: "unixpacket",
|
|
});
|
|
assert(bob.addr.transport === "unixpacket");
|
|
assertEquals(bob.addr.path, bobFilePath);
|
|
|
|
const sent = new Uint8Array([1, 2, 3]);
|
|
const byteLength = await alice.send(sent, bob.addr);
|
|
assertEquals(byteLength, 3);
|
|
|
|
const [recvd, remote] = await bob.receive();
|
|
assert(remote.transport === "unixpacket");
|
|
assertEquals(remote.path, aliceFilePath);
|
|
assertEquals(recvd.length, 3);
|
|
assertEquals(1, recvd[0]);
|
|
assertEquals(2, recvd[1]);
|
|
assertEquals(3, recvd[2]);
|
|
alice.close();
|
|
bob.close();
|
|
},
|
|
);
|
|
|
|
// TODO(lucacasonato): support concurrent reads and writes on unixpacket sockets
|
|
Deno.test(
|
|
{ ignore: true, permissions: { read: true, write: true } },
|
|
async function netUnixPacketConcurrentSendReceive() {
|
|
const filePath = tmpUnixSocketPath();
|
|
const socket = Deno.listenDatagram({
|
|
path: filePath,
|
|
transport: "unixpacket",
|
|
});
|
|
assert(socket.addr.transport === "unixpacket");
|
|
assertEquals(socket.addr.path, filePath);
|
|
|
|
const recvPromise = socket.receive();
|
|
|
|
const sendBuf = new Uint8Array([1, 2, 3]);
|
|
const sendLen = await socket.send(sendBuf, socket.addr);
|
|
assertEquals(sendLen, 3);
|
|
|
|
const [recvBuf, _recvAddr] = await recvPromise;
|
|
assertEquals(recvBuf.length, 3);
|
|
assertEquals(1, recvBuf[0]);
|
|
assertEquals(2, recvBuf[1]);
|
|
assertEquals(3, recvBuf[2]);
|
|
|
|
socket.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function netTcpListenIteratorBreakClosesResource() {
|
|
async function iterate(listener: Deno.Listener) {
|
|
let i = 0;
|
|
|
|
for await (const conn of listener) {
|
|
conn.close();
|
|
i++;
|
|
|
|
if (i > 1) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
const addr = { hostname: "127.0.0.1", port: 8888 };
|
|
const listener = Deno.listen(addr);
|
|
const iteratePromise = iterate(listener);
|
|
|
|
await delay(100);
|
|
const conn1 = await Deno.connect(addr);
|
|
conn1.close();
|
|
const conn2 = await Deno.connect(addr);
|
|
conn2.close();
|
|
|
|
await iteratePromise;
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function netTcpListenCloseWhileIterating() {
|
|
const listener = Deno.listen({ port: 8001 });
|
|
const nextWhileClosing = listener[Symbol.asyncIterator]().next();
|
|
listener.close();
|
|
assertEquals(await nextWhileClosing, { value: undefined, done: true });
|
|
|
|
const nextAfterClosing = listener[Symbol.asyncIterator]().next();
|
|
assertEquals(await nextAfterClosing, { value: undefined, done: true });
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function netUdpListenCloseWhileIterating() {
|
|
const socket = Deno.listenDatagram({ port: 8000, transport: "udp" });
|
|
const nextWhileClosing = socket[Symbol.asyncIterator]().next();
|
|
socket.close();
|
|
assertEquals(await nextWhileClosing, { value: undefined, done: true });
|
|
|
|
const nextAfterClosing = socket[Symbol.asyncIterator]().next();
|
|
assertEquals(await nextAfterClosing, { value: undefined, done: true });
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
ignore: Deno.build.os === "windows",
|
|
permissions: { read: true, write: true },
|
|
},
|
|
async function netUnixListenCloseWhileIterating() {
|
|
const filePath = tmpUnixSocketPath();
|
|
const socket = Deno.listen({ path: filePath, transport: "unix" });
|
|
const nextWhileClosing = socket[Symbol.asyncIterator]().next();
|
|
socket.close();
|
|
assertEquals(await nextWhileClosing, { value: undefined, done: true });
|
|
|
|
const nextAfterClosing = socket[Symbol.asyncIterator]().next();
|
|
assertEquals(await nextAfterClosing, { value: undefined, done: true });
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
ignore: Deno.build.os === "windows",
|
|
permissions: { read: true, write: true },
|
|
},
|
|
async function netUnixPacketListenCloseWhileIterating() {
|
|
const filePath = tmpUnixSocketPath();
|
|
const socket = Deno.listenDatagram({
|
|
path: filePath,
|
|
transport: "unixpacket",
|
|
});
|
|
const nextWhileClosing = socket[Symbol.asyncIterator]().next();
|
|
socket.close();
|
|
assertEquals(await nextWhileClosing, { value: undefined, done: true });
|
|
|
|
const nextAfterClosing = socket[Symbol.asyncIterator]().next();
|
|
assertEquals(await nextAfterClosing, { value: undefined, done: true });
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function netListenAsyncIterator() {
|
|
const addr = { hostname: "127.0.0.1", port: listenPort };
|
|
const listener = Deno.listen(addr);
|
|
const runAsyncIterator = async () => {
|
|
for await (const conn of listener) {
|
|
await conn.write(new Uint8Array([1, 2, 3]));
|
|
conn.close();
|
|
}
|
|
};
|
|
runAsyncIterator();
|
|
const conn = await Deno.connect(addr);
|
|
const buf = new Uint8Array(1024);
|
|
const readResult = await conn.read(buf);
|
|
assertEquals(3, readResult);
|
|
assertEquals(1, buf[0]);
|
|
assertEquals(2, buf[1]);
|
|
assertEquals(3, buf[2]);
|
|
|
|
assert(readResult !== null);
|
|
|
|
const readResult2 = await conn.read(buf);
|
|
assertEquals(readResult2, null);
|
|
|
|
listener.close();
|
|
conn.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
permissions: { net: true },
|
|
},
|
|
async function netCloseWriteSuccess() {
|
|
const addr = { hostname: "127.0.0.1", port: listenPort };
|
|
const listener = Deno.listen(addr);
|
|
const { promise: closePromise, resolve } = Promise.withResolvers<void>();
|
|
listener.accept().then(async (conn) => {
|
|
await conn.write(new Uint8Array([1, 2, 3]));
|
|
await closePromise;
|
|
conn.close();
|
|
});
|
|
const conn = await Deno.connect(addr);
|
|
conn.closeWrite(); // closing write
|
|
const buf = new Uint8Array(1024);
|
|
// Check read not impacted
|
|
const readResult = await conn.read(buf);
|
|
assertEquals(3, readResult);
|
|
assertEquals(1, buf[0]);
|
|
assertEquals(2, buf[1]);
|
|
assertEquals(3, buf[2]);
|
|
// Verify that the write end of the socket is closed.
|
|
// TODO(piscisaureus): assert that thrown error is of a specific type.
|
|
await assertRejects(async () => {
|
|
await conn.write(new Uint8Array([1, 2, 3]));
|
|
});
|
|
resolve();
|
|
listener.close();
|
|
conn.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
// https://github.com/denoland/deno/issues/11580
|
|
ignore: Deno.build.os === "darwin" && isCI,
|
|
permissions: { net: true },
|
|
},
|
|
async function netHangsOnClose() {
|
|
let acceptedConn: Deno.Conn;
|
|
|
|
async function iteratorReq(listener: Deno.Listener) {
|
|
const p = new Uint8Array(10);
|
|
const conn = await listener.accept();
|
|
acceptedConn = conn;
|
|
|
|
try {
|
|
while (true) {
|
|
const nread = await conn.read(p);
|
|
if (nread === null) {
|
|
break;
|
|
}
|
|
await conn.write(new Uint8Array([1, 2, 3]));
|
|
}
|
|
} catch (err) {
|
|
assert(err);
|
|
assert(err instanceof Deno.errors.Interrupted);
|
|
}
|
|
}
|
|
|
|
const addr = { hostname: "127.0.0.1", port: listenPort };
|
|
const listener = Deno.listen(addr);
|
|
const listenerPromise = iteratorReq(listener);
|
|
const connectionPromise = (async () => {
|
|
const conn = await Deno.connect(addr);
|
|
await conn.write(new Uint8Array([1, 2, 3, 4]));
|
|
const buf = new Uint8Array(10);
|
|
await conn.read(buf);
|
|
conn!.close();
|
|
acceptedConn!.close();
|
|
listener.close();
|
|
})();
|
|
|
|
await Promise.all([
|
|
listenerPromise,
|
|
connectionPromise,
|
|
]);
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
permissions: { net: true },
|
|
},
|
|
function netExplicitUndefinedHostname() {
|
|
const listener = Deno.listen({ hostname: undefined, port: 8080 });
|
|
assertEquals((listener.addr as Deno.NetAddr).hostname, "0.0.0.0");
|
|
listener.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{
|
|
ignore: Deno.build.os !== "linux",
|
|
permissions: { read: true, write: true },
|
|
},
|
|
function netUnixAbstractPathShouldNotPanic() {
|
|
const listener = Deno.listen({
|
|
path: "\0aaa",
|
|
transport: "unix",
|
|
});
|
|
assert("not panic");
|
|
listener.close();
|
|
},
|
|
);
|
|
|
|
Deno.test({ permissions: { net: true } }, async function whatwgStreams() {
|
|
const server = (async () => {
|
|
const listener = Deno.listen({ hostname: "127.0.0.1", port: listenPort });
|
|
const conn = await listener.accept();
|
|
await conn.readable.pipeTo(conn.writable);
|
|
listener.close();
|
|
})();
|
|
|
|
const conn = await Deno.connect({ hostname: "127.0.0.1", port: listenPort });
|
|
const reader = conn.readable.getReader();
|
|
const writer = conn.writable.getWriter();
|
|
const encoder = new TextEncoder();
|
|
const decoder = new TextDecoder();
|
|
const data = encoder.encode("Hello World");
|
|
|
|
await writer.write(data);
|
|
const { value, done } = await reader.read();
|
|
assert(!done);
|
|
assertEquals(decoder.decode(value), "Hello World");
|
|
await reader.cancel();
|
|
await server;
|
|
});
|
|
|
|
Deno.test(
|
|
{ permissions: { read: true } },
|
|
async function readableStreamTextEncoderPipe() {
|
|
const filename = "tests/testdata/assets/hello.txt";
|
|
const file = await Deno.open(filename);
|
|
const readable = file.readable.pipeThrough(new TextDecoderStream());
|
|
const chunks = [];
|
|
for await (const chunk of readable) {
|
|
chunks.push(chunk);
|
|
}
|
|
assertEquals(chunks.length, 1);
|
|
assertEquals(chunks[0].length, 12);
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { read: true, write: true } },
|
|
async function writableStream() {
|
|
const path = await Deno.makeTempFile();
|
|
const file = await Deno.open(path, { write: true });
|
|
assert(file.writable instanceof WritableStream);
|
|
const readable = new ReadableStream({
|
|
start(controller) {
|
|
controller.enqueue(new TextEncoder().encode("hello "));
|
|
controller.enqueue(new TextEncoder().encode("world!"));
|
|
controller.close();
|
|
},
|
|
});
|
|
await readable.pipeTo(file.writable);
|
|
const res = await Deno.readTextFile(path);
|
|
assertEquals(res, "hello world!");
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { read: true, run: true } },
|
|
async function netListenUnref() {
|
|
const [statusCode, _output] = await execCode(`
|
|
async function main() {
|
|
const listener = Deno.listen({ port: ${listenPort} });
|
|
listener.unref();
|
|
await listener.accept(); // This doesn't block the program from exiting
|
|
}
|
|
main();
|
|
`);
|
|
assertEquals(statusCode, 0);
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { read: true, run: true } },
|
|
async function netListenUnref2() {
|
|
const [statusCode, _output] = await execCode(`
|
|
async function main() {
|
|
const listener = Deno.listen({ port: ${listenPort} });
|
|
await listener.accept();
|
|
listener.unref();
|
|
await listener.accept(); // The program exits here
|
|
throw new Error(); // The program doesn't reach here
|
|
}
|
|
main();
|
|
const conn = await Deno.connect({ port: ${listenPort} });
|
|
conn.close();
|
|
`);
|
|
assertEquals(statusCode, 0);
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { read: true, run: true, net: true } },
|
|
async function netListenUnrefAndRef() {
|
|
const p = execCode2(`
|
|
async function main() {
|
|
const listener = Deno.listen({ port: ${listenPort} });
|
|
listener.unref();
|
|
listener.ref(); // This restores 'ref' state of listener
|
|
console.log("started");
|
|
await listener.accept();
|
|
console.log("accepted")
|
|
}
|
|
main();
|
|
`);
|
|
await p.waitStdoutText("started");
|
|
const conn = await Deno.connect({ port: listenPort });
|
|
conn.close();
|
|
const [statusCode, output] = await p.finished();
|
|
assertEquals(statusCode, 0);
|
|
assertEquals(output.trim(), "started\naccepted");
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function netListenUnrefConcurrentAccept() {
|
|
const timer = setTimeout(() => {}, 1000);
|
|
const listener = Deno.listen({ port: listenPort });
|
|
listener.accept().catch(() => {});
|
|
listener.unref();
|
|
// Unref'd listener still causes Busy error
|
|
// on concurrent accept calls.
|
|
await assertRejects(async () => {
|
|
await listener.accept(); // The program exits here
|
|
}, Deno.errors.Busy);
|
|
listener.close();
|
|
clearTimeout(timer);
|
|
},
|
|
);
|
|
|
|
Deno.test({
|
|
ignore: Deno.build.os === "windows",
|
|
permissions: { read: true, write: true },
|
|
}, function netUnixListenAddrAlreadyInUse() {
|
|
const filePath = tmpUnixSocketPath();
|
|
const listener = Deno.listen({ path: filePath, transport: "unix" });
|
|
assertThrows(
|
|
() => {
|
|
Deno.listen({ path: filePath, transport: "unix" });
|
|
},
|
|
Deno.errors.AddrInUse,
|
|
);
|
|
listener.close();
|
|
});
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true, read: true, run: true } },
|
|
async function netConnUnref() {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const intervalId = setInterval(() => {}); // This keeps event loop alive.
|
|
|
|
const program = execCode(`
|
|
async function main() {
|
|
const conn = await Deno.connect({ port: ${listenPort} });
|
|
conn.unref();
|
|
await conn.read(new Uint8Array(10)); // The program exits here
|
|
throw new Error(); // The program doesn't reach here
|
|
}
|
|
main();
|
|
`);
|
|
const conn = await listener.accept();
|
|
const [statusCode, _output] = await program;
|
|
conn.close();
|
|
listener.close();
|
|
clearInterval(intervalId);
|
|
assertEquals(statusCode, 0);
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true, read: true, run: true } },
|
|
async function netConnUnrefReadable() {
|
|
const listener = Deno.listen({ port: listenPort });
|
|
const intervalId = setInterval(() => {}); // This keeps event loop alive.
|
|
|
|
const program = execCode(`
|
|
async function main() {
|
|
const conn = await Deno.connect({ port: ${listenPort} });
|
|
conn.unref();
|
|
const reader = conn.readable.getReader();
|
|
await reader.read(); // The program exits here
|
|
throw new Error(); // The program doesn't reach here
|
|
}
|
|
main();
|
|
`);
|
|
const conn = await listener.accept();
|
|
const [statusCode, _output] = await program;
|
|
conn.close();
|
|
listener.close();
|
|
clearInterval(intervalId);
|
|
assertEquals(statusCode, 0);
|
|
},
|
|
);
|
|
|
|
Deno.test({ permissions: { net: true } }, async function netTcpReuseAddr() {
|
|
const listener1 = Deno.listen({
|
|
hostname: "127.0.0.1",
|
|
port: listenPort,
|
|
});
|
|
listener1.accept().then(
|
|
(conn) => {
|
|
conn.close();
|
|
},
|
|
);
|
|
|
|
const conn1 = await Deno.connect({ hostname: "127.0.0.1", port: listenPort });
|
|
const buf1 = new Uint8Array(1024);
|
|
await conn1.read(buf1);
|
|
listener1.close();
|
|
conn1.close();
|
|
|
|
const listener2 = Deno.listen({
|
|
hostname: "127.0.0.1",
|
|
port: listenPort,
|
|
});
|
|
|
|
listener2.accept().then(
|
|
(conn) => {
|
|
conn.close();
|
|
},
|
|
);
|
|
|
|
const conn2 = await Deno.connect({ hostname: "127.0.0.1", port: listenPort });
|
|
const buf2 = new Uint8Array(1024);
|
|
await conn2.read(buf2);
|
|
|
|
listener2.close();
|
|
conn2.close();
|
|
});
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function netUdpReuseAddr() {
|
|
const sender = Deno.listenDatagram({
|
|
port: 4002,
|
|
transport: "udp",
|
|
});
|
|
const listener1 = Deno.listenDatagram({
|
|
port: 4000,
|
|
transport: "udp",
|
|
reuseAddress: true,
|
|
});
|
|
const listener2 = Deno.listenDatagram({
|
|
port: 4000,
|
|
transport: "udp",
|
|
reuseAddress: true,
|
|
});
|
|
|
|
const sent = new Uint8Array([1, 2, 3]);
|
|
await sender.send(sent, listener1.addr);
|
|
await Promise.any([listener1.receive(), listener2.receive()]).then(
|
|
([recvd, remote]) => {
|
|
assert(remote.transport === "udp");
|
|
assertEquals(recvd.length, 3);
|
|
assertEquals(1, recvd[0]);
|
|
assertEquals(2, recvd[1]);
|
|
assertEquals(3, recvd[2]);
|
|
},
|
|
);
|
|
sender.close();
|
|
listener1.close();
|
|
listener2.close();
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
function netUdpNoReuseAddr() {
|
|
let listener1;
|
|
try {
|
|
listener1 = Deno.listenDatagram({
|
|
port: 4001,
|
|
transport: "udp",
|
|
reuseAddress: false,
|
|
});
|
|
} catch (err) {
|
|
assert(err);
|
|
assert(err instanceof Deno.errors.AddrInUse); // AddrInUse from previous test
|
|
}
|
|
|
|
assertThrows(() => {
|
|
Deno.listenDatagram({
|
|
port: 4001,
|
|
transport: "udp",
|
|
reuseAddress: false,
|
|
});
|
|
}, Deno.errors.AddrInUse);
|
|
if (typeof listener1 !== "undefined") {
|
|
listener1.close();
|
|
}
|
|
},
|
|
);
|
|
|
|
Deno.test({
|
|
ignore: Deno.build.os !== "linux",
|
|
permissions: { net: true },
|
|
}, async function netTcpListenReusePort() {
|
|
const port = 4003;
|
|
const listener1 = Deno.listen({ port, reusePort: true });
|
|
const listener2 = Deno.listen({ port, reusePort: true });
|
|
let p1;
|
|
let p2;
|
|
let listener1Recv = false;
|
|
let listener2Recv = false;
|
|
while (!listener1Recv || !listener2Recv) {
|
|
if (!p1) {
|
|
p1 = listener1.accept().then((conn) => {
|
|
conn.close();
|
|
listener1Recv = true;
|
|
p1 = undefined;
|
|
listener1.close();
|
|
}).catch(() => {});
|
|
}
|
|
if (!p2) {
|
|
p2 = listener2.accept().then((conn) => {
|
|
conn.close();
|
|
listener2Recv = true;
|
|
p2 = undefined;
|
|
listener2.close();
|
|
}).catch(() => {});
|
|
}
|
|
const conn = await Deno.connect({ port });
|
|
conn.close();
|
|
await Promise.race([p1, p2]);
|
|
}
|
|
});
|
|
|
|
Deno.test({
|
|
ignore: Deno.build.os === "linux",
|
|
permissions: { net: true },
|
|
}, function netTcpListenReusePortDoesNothing() {
|
|
const listener1 = Deno.listen({ port: 4003, reusePort: true });
|
|
assertThrows(() => {
|
|
Deno.listen({ port: 4003, reusePort: true });
|
|
}, Deno.errors.AddrInUse);
|
|
listener1.close();
|
|
});
|
|
|
|
Deno.test({
|
|
permissions: { net: true },
|
|
}, function netTcpListenDoesNotThrowOnStringPort() {
|
|
// @ts-ignore String port is not allowed by typing, but it shouldn't throw
|
|
// for backwards compatibility.
|
|
const listener = Deno.listen({ hostname: "localhost", port: "0" });
|
|
listener.close();
|
|
});
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function listenerExplicitResourceManagement() {
|
|
let done: Promise<Deno.errors.BadResource>;
|
|
|
|
{
|
|
using listener = Deno.listen({ port: listenPort });
|
|
|
|
done = assertRejects(
|
|
() => listener.accept(),
|
|
Deno.errors.BadResource,
|
|
);
|
|
}
|
|
|
|
await done;
|
|
},
|
|
);
|
|
|
|
Deno.test(
|
|
{ permissions: { net: true } },
|
|
async function listenerExplicitResourceManagementManualClose() {
|
|
using listener = Deno.listen({ port: listenPort });
|
|
listener.close();
|
|
await assertRejects( // definitely closed
|
|
() => listener.accept(),
|
|
Deno.errors.BadResource,
|
|
);
|
|
// calling [Symbol.dispose] after manual close is a no-op
|
|
},
|
|
);
|