summaryrefslogtreecommitdiff
path: root/js
diff options
context:
space:
mode:
Diffstat (limited to 'js')
m---------js/deps/https/deno.land/std0
-rw-r--r--js/fetch_test.ts2
-rw-r--r--js/lib.deno_runtime.d.ts83
-rw-r--r--js/net.ts100
-rw-r--r--js/net_test.ts34
-rw-r--r--js/resources_test.ts6
6 files changed, 120 insertions, 105 deletions
diff --git a/js/deps/https/deno.land/std b/js/deps/https/deno.land/std
-Subproject 6663e698d08147ae0a736d1df52ffd857729d3d
+Subproject 43aafbf33285753e7b42230f0eb7969b300f71c
diff --git a/js/fetch_test.ts b/js/fetch_test.ts
index 4fcc39f01..56c693681 100644
--- a/js/fetch_test.ts
+++ b/js/fetch_test.ts
@@ -264,7 +264,7 @@ testPerm({ net: true }, async function fetchUserAgent(): Promise<void> {
/*
function bufferServer(addr: string): Deno.Buffer {
- const listener = Deno.listen("tcp", addr);
+ const listener = Deno.listen(addr);
const buf = new Deno.Buffer();
listener.accept().then(async conn => {
const p1 = buf.readFrom(conn);
diff --git a/js/lib.deno_runtime.d.ts b/js/lib.deno_runtime.d.ts
index ed335216c..fc4e6508f 100644
--- a/js/lib.deno_runtime.d.ts
+++ b/js/lib.deno_runtime.d.ts
@@ -914,11 +914,12 @@ declare namespace Deno {
// @url js/net.d.ts
- type Network = "tcp";
+ type Transport = "tcp";
interface Addr {
- network: Network;
+ transport: Transport;
address: string;
}
+
/** A Listener is a generic network listener for stream-oriented protocols. */
export interface Listener extends AsyncIterator<Conn> {
/** Waits for and resolves to the next connection to the `Listener`. */
@@ -947,52 +948,56 @@ declare namespace Deno {
*/
closeWrite(): void;
}
- /** Listen announces on the local network address.
+
+ export interface ListenOptions {
+ port: number;
+ hostname?: string;
+ transport?: Transport;
+ }
+
+ /** Listen announces on the local transport address.
*
- * The network must be `tcp`, `tcp4`, `tcp6`, `unix` or `unixpacket`.
+ * @param options
+ * @param options.port The port to connect to. (Required.)
+ * @param options.hostname A literal IP address or host name that can be
+ * resolved to an IP address. If not specified, defaults to 0.0.0.0
+ * @param options.transport Defaults to "tcp". Later we plan to add "tcp4",
+ * "tcp6", "udp", "udp4", "udp6", "ip", "ip4", "ip6", "unix", "unixgram" and
+ * "unixpacket".
*
- * For TCP networks, if the host in the address parameter is empty or a literal
- * unspecified IP address, `listen()` listens on all available unicast and
- * anycast IP addresses of the local system. To only use IPv4, use network
- * `tcp4`. The address can use a host name, but this is not recommended,
- * because it will create a listener for at most one of the host's IP
- * addresses. If the port in the address parameter is empty or `0`, as in
- * `127.0.0.1:` or `[::1]:0`, a port number is automatically chosen. The
- * `addr()` method of `Listener` can be used to discover the chosen port.
+ * Examples:
*
- * See `dial()` for a description of the network and address parameters.
+ * listen({ port: 80 })
+ * listen({ hostname: "192.0.2.1", port: 80 })
+ * listen({ hostname: "[2001:db8::1]", port: 80 });
+ * listen({ hostname: "golang.org", port: 80, transport: "tcp" })
*/
- export function listen(network: Network, address: string): Listener;
- /** Dial connects to the address on the named network.
- *
- * Supported networks are only `tcp` currently.
- *
- * TODO: `tcp4` (IPv4-only), `tcp6` (IPv6-only), `udp`, `udp4` (IPv4-only),
- * `udp6` (IPv6-only), `ip`, `ip4` (IPv4-only), `ip6` (IPv6-only), `unix`,
- * `unixgram` and `unixpacket`.
+ export function listen(options: ListenOptions): Listener;
+
+ export interface DialOptions {
+ port: number;
+ hostname?: string;
+ transport?: Transport;
+ }
+
+ /** Dial connects to the address on the named transport.
*
- * For TCP and UDP networks, the address has the form `host:port`. The host must
- * be a literal IP address, or a host name that can be resolved to IP addresses.
- * The port must be a literal port number or a service name. If the host is a
- * literal IPv6 address it must be enclosed in square brackets, as in
- * `[2001:db8::1]:80` or `[fe80::1%zone]:80`. The zone specifies the scope of
- * the literal IPv6 address as defined in RFC 4007. The functions JoinHostPort
- * and SplitHostPort manipulate a pair of host and port in this form. When using
- * TCP, and the host resolves to multiple IP addresses, Dial will try each IP
- * address in order until one succeeds.
+ * @param options
+ * @param options.port The port to connect to. (Required.)
+ * @param options.hostname A literal IP address or host name that can be
+ * resolved to an IP address. If not specified, defaults to 127.0.0.1
+ * @param options.transport Defaults to "tcp". Later we plan to add "tcp4",
+ * "tcp6", "udp", "udp4", "udp6", "ip", "ip4", "ip6", "unix", "unixgram" and
+ * "unixpacket".
*
* Examples:
*
- * dial("tcp", "golang.org:http")
- * dial("tcp", "192.0.2.1:http")
- * dial("tcp", "198.51.100.1:80")
- * dial("udp", "[2001:db8::1]:domain")
- * dial("udp", "[fe80::1%lo0]:53")
- * dial("tcp", ":80")
+ * dial({ port: 80 })
+ * dial({ hostname: "192.0.2.1", port: 80 })
+ * dial({ hostname: "[2001:db8::1]", port: 80 });
+ * dial({ hostname: "golang.org", port: 80, transport: "tcp" })
*/
- export function dial(network: Network, address: string): Promise<Conn>;
- /** **RESERVED** */
- export function connect(_network: Network, _address: string): Promise<Conn>;
+ export function dial(options: DialOptions): Promise<Conn>;
// @url js/metrics.d.ts
diff --git a/js/net.ts b/js/net.ts
index b0651b326..28c8cf8e0 100644
--- a/js/net.ts
+++ b/js/net.ts
@@ -5,16 +5,18 @@ import { read, write, close } from "./files.ts";
import * as dispatch from "./dispatch.ts";
import { sendSync, sendAsync } from "./dispatch_json.ts";
-export type Network = "tcp";
+export type Transport = "tcp";
// TODO support other types:
-// export type Network = "tcp" | "tcp4" | "tcp6" | "unix" | "unixpacket";
+// export type Transport = "tcp" | "tcp4" | "tcp6" | "unix" | "unixpacket";
+// TODO(ry) Replace 'address' with 'hostname' and 'port', similar to DialOptions
+// and ListenOptions.
export interface Addr {
- network: Network;
+ transport: Transport;
address: string;
}
-/** A Listener is a generic network listener for stream-oriented protocols. */
+/** A Listener is a generic transport listener for stream-oriented protocols. */
export interface Listener extends AsyncIterator<Conn> {
/** Waits for and resolves to the next connection to the `Listener`. */
accept(): Promise<Conn>;
@@ -79,7 +81,7 @@ class ConnImpl implements Conn {
class ListenerImpl implements Listener {
constructor(
readonly rid: number,
- private network: Network,
+ private transport: Transport,
private localAddr: string
) {}
@@ -94,7 +96,7 @@ class ListenerImpl implements Listener {
addr(): Addr {
return {
- network: this.network,
+ transport: this.transport,
address: this.localAddr
};
}
@@ -128,62 +130,70 @@ export interface Conn extends Reader, Writer, Closer {
closeWrite(): void;
}
-/** Listen announces on the local network address.
+export interface ListenOptions {
+ port: number;
+ hostname?: string;
+ transport?: Transport;
+}
+const listenDefaults = { hostname: "0.0.0.0", transport: "tcp" };
+
+/** Listen announces on the local transport address.
*
- * The network must be `tcp`, `tcp4`, `tcp6`, `unix` or `unixpacket`.
+ * @param options
+ * @param options.port The port to connect to. (Required.)
+ * @param options.hostname A literal IP address or host name that can be
+ * resolved to an IP address. If not specified, defaults to 0.0.0.0
+ * @param options.transport Defaults to "tcp". Later we plan to add "tcp4",
+ * "tcp6", "udp", "udp4", "udp6", "ip", "ip4", "ip6", "unix", "unixgram" and
+ * "unixpacket".
*
- * For TCP networks, if the host in the address parameter is empty or a literal
- * unspecified IP address, `listen()` listens on all available unicast and
- * anycast IP addresses of the local system. To only use IPv4, use network
- * `tcp4`. The address can use a host name, but this is not recommended,
- * because it will create a listener for at most one of the host's IP
- * addresses. If the port in the address parameter is empty or `0`, as in
- * `127.0.0.1:` or `[::1]:0`, a port number is automatically chosen. The
- * `addr()` method of `Listener` can be used to discover the chosen port.
+ * Examples:
*
- * See `dial()` for a description of the network and address parameters.
+ * listen({ port: 80 })
+ * listen({ hostname: "192.0.2.1", port: 80 })
+ * listen({ hostname: "[2001:db8::1]", port: 80 });
+ * listen({ hostname: "golang.org", port: 80, transport: "tcp" })
*/
-export function listen(network: Network, address: string): Listener {
- const res = sendSync(dispatch.OP_LISTEN, { network, address });
- return new ListenerImpl(res.rid, network, res.localAddr);
+export function listen(options: ListenOptions): Listener {
+ options = Object.assign(listenDefaults, options);
+ const res = sendSync(dispatch.OP_LISTEN, options);
+ return new ListenerImpl(res.rid, options.transport, res.localAddr);
}
-/** Dial connects to the address on the named network.
- *
- * Supported networks are only `tcp` currently.
- *
- * TODO: `tcp4` (IPv4-only), `tcp6` (IPv6-only), `udp`, `udp4` (IPv4-only),
- * `udp6` (IPv6-only), `ip`, `ip4` (IPv4-only), `ip6` (IPv6-only), `unix`,
- * `unixgram` and `unixpacket`.
+export interface DialOptions {
+ port: number;
+ hostname?: string;
+ transport?: Transport;
+}
+const dialDefaults = { hostname: "127.0.0.1", transport: "tcp" };
+
+/** Dial connects to the address on the named transport.
*
- * For TCP and UDP networks, the address has the form `host:port`. The host must
- * be a literal IP address, or a host name that can be resolved to IP addresses.
- * The port must be a literal port number or a service name. If the host is a
- * literal IPv6 address it must be enclosed in square brackets, as in
- * `[2001:db8::1]:80` or `[fe80::1%zone]:80`. The zone specifies the scope of
- * the literal IPv6 address as defined in RFC 4007. The functions JoinHostPort
- * and SplitHostPort manipulate a pair of host and port in this form. When using
- * TCP, and the host resolves to multiple IP addresses, Dial will try each IP
- * address in order until one succeeds.
+ * @param options
+ * @param options.port The port to connect to. (Required.)
+ * @param options.hostname A literal IP address or host name that can be
+ * resolved to an IP address. If not specified, defaults to 127.0.0.1
+ * @param options.transport Defaults to "tcp". Later we plan to add "tcp4",
+ * "tcp6", "udp", "udp4", "udp6", "ip", "ip4", "ip6", "unix", "unixgram" and
+ * "unixpacket".
*
* Examples:
*
- * dial("tcp", "golang.org:http")
- * dial("tcp", "192.0.2.1:http")
- * dial("tcp", "198.51.100.1:80")
- * dial("udp", "[2001:db8::1]:domain")
- * dial("udp", "[fe80::1%lo0]:53")
- * dial("tcp", ":80")
+ * dial({ port: 80 })
+ * dial({ hostname: "192.0.2.1", port: 80 })
+ * dial({ hostname: "[2001:db8::1]", port: 80 });
+ * dial({ hostname: "golang.org", port: 80, transport: "tcp" })
*/
-export async function dial(network: Network, address: string): Promise<Conn> {
- const res = await sendAsync(dispatch.OP_DIAL, { network, address });
+export async function dial(options: DialOptions): Promise<Conn> {
+ options = Object.assign(dialDefaults, options);
+ const res = await sendAsync(dispatch.OP_DIAL, options);
// TODO(bartlomieju): add remoteAddr and localAddr on Rust side
return new ConnImpl(res.rid, res.remoteAddr!, res.localAddr!);
}
/** **RESERVED** */
export async function connect(
- _network: Network,
+ _transport: Transport,
_address: string
): Promise<Conn> {
return notImplemented();
diff --git a/js/net_test.ts b/js/net_test.ts
index 23387001f..33f4f7d07 100644
--- a/js/net_test.ts
+++ b/js/net_test.ts
@@ -2,15 +2,17 @@
import { testPerm, assert, assertEquals } from "./test_util.ts";
testPerm({ net: true }, function netListenClose(): void {
- const listener = Deno.listen("tcp", "127.0.0.1:4500");
+ const listener = Deno.listen({ hostname: "127.0.0.1", port: 4500 });
const addr = listener.addr();
- assertEquals(addr.network, "tcp");
+ assertEquals(addr.transport, "tcp");
+ // TODO(ry) Replace 'address' with 'hostname' and 'port', similar to
+ // DialOptions and ListenOptions.
assertEquals(addr.address, "127.0.0.1:4500");
listener.close();
});
testPerm({ net: true }, async function netCloseWhileAccept(): Promise<void> {
- const listener = Deno.listen("tcp", ":4501");
+ const listener = Deno.listen({ port: 4501 });
const p = listener.accept();
listener.close();
let err;
@@ -25,7 +27,7 @@ testPerm({ net: true }, async function netCloseWhileAccept(): Promise<void> {
});
testPerm({ net: true }, async function netConcurrentAccept(): Promise<void> {
- const listener = Deno.listen("tcp", ":4502");
+ const listener = Deno.listen({ port: 4502 });
let acceptErrCount = 0;
const checkErr = (e): void => {
assertEquals(e.kind, Deno.ErrorKind.Other);
@@ -46,7 +48,7 @@ testPerm({ net: true }, async function netConcurrentAccept(): Promise<void> {
});
testPerm({ net: true }, async function netDialListen(): Promise<void> {
- const listener = Deno.listen("tcp", ":4500");
+ const listener = Deno.listen({ port: 4500 });
listener.accept().then(
async (conn): Promise<void> => {
assert(conn.remoteAddr != null);
@@ -55,7 +57,7 @@ testPerm({ net: true }, async function netDialListen(): Promise<void> {
conn.close();
}
);
- const conn = await Deno.dial("tcp", "127.0.0.1:4500");
+ const conn = await Deno.dial({ hostname: "127.0.0.1", port: 4500 });
assertEquals(conn.remoteAddr, "127.0.0.1:4500");
assert(conn.localAddr != null);
const buf = new Uint8Array(1024);
@@ -77,7 +79,7 @@ testPerm({ net: true }, async function netDialListen(): Promise<void> {
/* TODO(ry) Re-enable this test.
testPerm({ net: true }, async function netListenAsyncIterator(): Promise<void> {
- const listener = Deno.listen("tcp", ":4500");
+ const listener = Deno.listen(":4500");
const runAsyncIterator = async (): Promise<void> => {
for await (let conn of listener) {
await conn.write(new Uint8Array([1, 2, 3]));
@@ -85,7 +87,7 @@ testPerm({ net: true }, async function netListenAsyncIterator(): Promise<void> {
}
};
runAsyncIterator();
- const conn = await Deno.dial("tcp", "127.0.0.1:4500");
+ const conn = await Deno.dial("127.0.0.1:4500");
const buf = new Uint8Array(1024);
const readResult = await conn.read(buf);
assertEquals(3, readResult);
@@ -107,7 +109,7 @@ testPerm({ net: true }, async function netListenAsyncIterator(): Promise<void> {
/* TODO Fix broken test.
testPerm({ net: true }, async function netCloseReadSuccess() {
const addr = "127.0.0.1:4500";
- const listener = Deno.listen("tcp", addr);
+ const listener = Deno.listen(addr);
const closeDeferred = deferred();
const closeReadDeferred = deferred();
listener.accept().then(async conn => {
@@ -122,7 +124,7 @@ testPerm({ net: true }, async function netCloseReadSuccess() {
conn.close();
closeDeferred.resolve();
});
- const conn = await Deno.dial("tcp", addr);
+ const conn = await Deno.dial(addr);
conn.closeRead(); // closing read
closeReadDeferred.resolve();
const buf = new Uint8Array(1024);
@@ -139,14 +141,14 @@ testPerm({ net: true }, async function netCloseReadSuccess() {
/* TODO Fix broken test.
testPerm({ net: true }, async function netDoubleCloseRead() {
const addr = "127.0.0.1:4500";
- const listener = Deno.listen("tcp", addr);
+ const listener = Deno.listen(addr);
const closeDeferred = deferred();
listener.accept().then(async conn => {
await conn.write(new Uint8Array([1, 2, 3]));
await closeDeferred.promise;
conn.close();
});
- const conn = await Deno.dial("tcp", addr);
+ const conn = await Deno.dial(addr);
conn.closeRead(); // closing read
let err;
try {
@@ -167,14 +169,14 @@ testPerm({ net: true }, async function netDoubleCloseRead() {
/* TODO Fix broken test.
testPerm({ net: true }, async function netCloseWriteSuccess() {
const addr = "127.0.0.1:4500";
- const listener = Deno.listen("tcp", addr);
+ const listener = Deno.listen(addr);
const closeDeferred = deferred();
listener.accept().then(async conn => {
await conn.write(new Uint8Array([1, 2, 3]));
await closeDeferred.promise;
conn.close();
});
- const conn = await Deno.dial("tcp", addr);
+ const conn = await Deno.dial(addr);
conn.closeWrite(); // closing write
const buf = new Uint8Array(1024);
// Check read not impacted
@@ -202,13 +204,13 @@ testPerm({ net: true }, async function netCloseWriteSuccess() {
/* TODO Fix broken test.
testPerm({ net: true }, async function netDoubleCloseWrite() {
const addr = "127.0.0.1:4500";
- const listener = Deno.listen("tcp", addr);
+ const listener = Deno.listen(addr);
const closeDeferred = deferred();
listener.accept().then(async conn => {
await closeDeferred.promise;
conn.close();
});
- const conn = await Deno.dial("tcp", addr);
+ const conn = await Deno.dial(addr);
conn.closeWrite(); // closing write
let err;
try {
diff --git a/js/resources_test.ts b/js/resources_test.ts
index 9d68f49f6..753ef3e17 100644
--- a/js/resources_test.ts
+++ b/js/resources_test.ts
@@ -10,10 +10,8 @@ test(function resourcesStdio(): void {
});
testPerm({ net: true }, async function resourcesNet(): Promise<void> {
- const addr = "127.0.0.1:4501";
- const listener = Deno.listen("tcp", addr);
-
- const dialerConn = await Deno.dial("tcp", addr);
+ const listener = Deno.listen({ port: 4501 });
+ const dialerConn = await Deno.dial({ port: 4501 });
const listenerConn = await listener.accept();
const res = Deno.resources();
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-28 05:00:42 +0000