diff --git a/cli/ops/net.rs b/cli/ops/net.rs index 11bf410d1f..507eff5048 100644 --- a/cli/ops/net.rs +++ b/cli/ops/net.rs @@ -49,8 +49,9 @@ pub fn op_accept( #[derive(Deserialize)] struct DialArgs { - network: String, - address: String, + transport: String, + hostname: String, + port: u16, } pub fn op_dial( @@ -59,9 +60,11 @@ pub fn op_dial( _zero_copy: Option, ) -> Result { let args: DialArgs = serde_json::from_value(args)?; - let network = args.network; - assert_eq!(network, "tcp"); // TODO Support others. - let address = args.address; + assert_eq!(args.transport, "tcp"); // TODO Support others. + + // TODO(ry) Using format! is suboptimal here. Better would be if + // state.check_net and resolve_addr() took hostname and port directly. + let address = format!("{}:{}", args.hostname, args.port); state.check_net(&address)?; @@ -117,8 +120,9 @@ pub fn op_shutdown( #[derive(Deserialize)] struct ListenArgs { - network: String, - address: String, + transport: String, + hostname: String, + port: u16, } pub fn op_listen( @@ -127,10 +131,11 @@ pub fn op_listen( _zero_copy: Option, ) -> Result { let args: ListenArgs = serde_json::from_value(args)?; + assert_eq!(args.transport, "tcp"); - let network = args.network; - assert_eq!(network, "tcp"); - let address = args.address; + // TODO(ry) Using format! is suboptimal here. Better would be if + // state.check_net and resolve_addr() took hostname and port directly. + let address = format!("{}:{}", args.hostname, args.port); state.check_net(&address)?; diff --git a/cli/tests/echo_server.ts b/cli/tests/echo_server.ts index 73995eab5c..82ee1fdabb 100644 --- a/cli/tests/echo_server.ts +++ b/cli/tests/echo_server.ts @@ -1,6 +1,7 @@ const { args, listen, copy } = Deno; const addr = args[1] || "127.0.0.1:4544"; -const listener = listen("tcp", addr); +const [hostname, port] = addr.split(":"); +const listener = listen({ hostname, port: Number(port) }); console.log("listening on", addr); listener.accept().then( async (conn): Promise => { diff --git a/js/deps/https/deno.land/std b/js/deps/https/deno.land/std index 6663e698d0..43aafbf332 160000 --- a/js/deps/https/deno.land/std +++ b/js/deps/https/deno.land/std @@ -1 +1 @@ -Subproject commit 6663e698d08147ae0a736d1df52ffd857729d3da +Subproject commit 43aafbf33285753e7b42230f0eb7969b300f71cf diff --git a/js/fetch_test.ts b/js/fetch_test.ts index 4fcc39f010..56c6936818 100644 --- a/js/fetch_test.ts +++ b/js/fetch_test.ts @@ -264,7 +264,7 @@ testPerm({ net: true }, async function fetchUserAgent(): Promise { /* 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 ed335216cf..fc4e6508f8 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 { /** 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`. - * - * 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. - * - * See `dial()` for a description of the network and address parameters. - */ - 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`. - * - * 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 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". * * 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") + * 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 dial(network: Network, address: string): Promise; - /** **RESERVED** */ - export function connect(_network: Network, _address: string): Promise; + export function listen(options: ListenOptions): Listener; + + export interface DialOptions { + port: number; + hostname?: string; + transport?: Transport; + } + + /** Dial connects to the address on the named transport. + * + * @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({ 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(options: DialOptions): Promise; // @url js/metrics.d.ts diff --git a/js/net.ts b/js/net.ts index b0651b3261..28c8cf8e07 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 { /** Waits for and resolves to the next connection to the `Listener`. */ accept(): Promise; @@ -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. - * - * The network must be `tcp`, `tcp4`, `tcp6`, `unix` or `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. - * - * See `dial()` for a description of the network and address parameters. - */ -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 interface ListenOptions { + port: number; + hostname?: string; + transport?: Transport; } +const listenDefaults = { hostname: "0.0.0.0", transport: "tcp" }; -/** Dial connects to the address on the named network. +/** Listen announces on the local transport address. * - * 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`. - * - * 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 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". * * 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") + * 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 async function dial(network: Network, address: string): Promise { - const res = await sendAsync(dispatch.OP_DIAL, { network, address }); +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); +} + +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. + * + * @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({ 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(options: DialOptions): Promise { + 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 { return notImplemented(); diff --git a/js/net_test.ts b/js/net_test.ts index 23387001fb..33f4f7d079 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 { - 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 { }); testPerm({ net: true }, async function netConcurrentAccept(): Promise { - 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 { }); testPerm({ net: true }, async function netDialListen(): Promise { - const listener = Deno.listen("tcp", ":4500"); + const listener = Deno.listen({ port: 4500 }); listener.accept().then( async (conn): Promise => { assert(conn.remoteAddr != null); @@ -55,7 +57,7 @@ testPerm({ net: true }, async function netDialListen(): Promise { 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 { /* TODO(ry) Re-enable this test. testPerm({ net: true }, async function netListenAsyncIterator(): Promise { - const listener = Deno.listen("tcp", ":4500"); + const listener = Deno.listen(":4500"); const runAsyncIterator = async (): Promise => { 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 { } }; 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 { /* 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 9d68f49f6b..753ef3e172 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 { - 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(); diff --git a/tools/benchmark.py b/tools/benchmark.py index aaf7084220..138135a981 100755 --- a/tools/benchmark.py +++ b/tools/benchmark.py @@ -211,8 +211,8 @@ def run_http(build_dir, new_data): def bundle_benchmark(deno_exe): bundles = { - "file_server": "https://deno.land/std/http/file_server.ts", - "gist": "https://deno.land/std/examples/gist.ts", + "file_server": "./js/deps/https/deno.land/std/http/file_server.ts", + "gist": "./js/deps/https/deno.land/std/examples/gist.ts", } sizes = {} diff --git a/tools/complex_permissions_test.ts b/tools/complex_permissions_test.ts index dd65a0e330..a2e0f7824d 100644 --- a/tools/complex_permissions_test.ts +++ b/tools/complex_permissions_test.ts @@ -16,13 +16,15 @@ const test: (args: string[]) => void = { }, netListen(hosts: string[]): void { hosts.forEach(host => { - const listener = Deno.listen("tcp", host); + const [hostname, port] = host.split(":"); + const listener = Deno.listen({ hostname, port: Number(port) }); listener.close(); }); }, async netDial(hosts: string[]): Promise { for (const host of hosts) { - const listener = await Deno.dial("tcp", host); + const [hostname, port] = host.split(":"); + const listener = await Deno.dial({ hostname, port: Number(port) }); listener.close(); } } diff --git a/tools/deno_tcp.ts b/tools/deno_tcp.ts index d744a09c1c..2b259cd389 100644 --- a/tools/deno_tcp.ts +++ b/tools/deno_tcp.ts @@ -3,7 +3,8 @@ // https://github.com/denoland/deno/issues/726 is completed. // Note: this is a keep-alive server. const addr = Deno.args[1] || "127.0.0.1:4500"; -const listener = Deno.listen("tcp", addr); +const [hostname, port] = addr.split(":"); +const listener = Deno.listen({ hostname, port: Number(port) }); const response = new TextEncoder().encode( "HTTP/1.1 200 OK\r\nContent-Length: 12\r\n\r\nHello World\n" ); diff --git a/tools/deno_tcp_proxy.ts b/tools/deno_tcp_proxy.ts index 02f5ab944f..23d2190710 100644 --- a/tools/deno_tcp_proxy.ts +++ b/tools/deno_tcp_proxy.ts @@ -2,10 +2,16 @@ const addr = Deno.args[1] || "127.0.0.1:4500"; const originAddr = Deno.args[2] || "127.0.0.1:4501"; -const listener = Deno.listen("tcp", addr); +const [hostname, port] = addr.split(":"); +const [originHostname, originPort] = originAddr.split(":"); + +const listener = Deno.listen({ hostname, port: Number(port) }); async function handle(conn: Deno.Conn): Promise { - const origin = await Deno.dial("tcp", originAddr); + const origin = await Deno.dial({ + hostname: originHostname, + port: Number(originPort) + }); try { await Promise.all([Deno.copy(conn, origin), Deno.copy(origin, conn)]); } catch (err) { diff --git a/tools/http_benchmark.py b/tools/http_benchmark.py index 5fac44e78b..39bedae8c5 100755 --- a/tools/http_benchmark.py +++ b/tools/http_benchmark.py @@ -49,13 +49,7 @@ def deno_http(deno_exe): "js/deps/https/deno.land/std/http/http_bench.ts", addr ] print "http_benchmark testing DENO using net/http." - return run( - deno_cmd, - addr, - merge_env={ - # Load from //js/deps/https/deno.land/net/ submodule. - "DENO_DIR": os.path.join(util.root_path, "js") - }) + return run(deno_cmd, addr) def deno_tcp_proxy(deno_exe, hyper_hello_exe): @@ -69,7 +63,6 @@ def deno_tcp_proxy(deno_exe, hyper_hello_exe): return run( deno_cmd, addr, - merge_env={"DENO_DIR": os.path.join(util.root_path, "js")}, origin_cmd=http_proxy_origin(hyper_hello_exe, origin_addr)) @@ -84,7 +77,6 @@ def deno_http_proxy(deno_exe, hyper_hello_exe): return run( deno_cmd, addr, - merge_env={"DENO_DIR": os.path.join(util.root_path, "js")}, origin_cmd=http_proxy_origin(hyper_hello_exe, origin_addr)) diff --git a/tools/permission_prompt_test.ts b/tools/permission_prompt_test.ts index 617f8b0fcb..da0c986ed9 100644 --- a/tools/permission_prompt_test.ts +++ b/tools/permission_prompt_test.ts @@ -1,5 +1,5 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -const { args, listen, env, exit, makeTempDirSync, readFileSync, run } = Deno; +const { args, env, exit, makeTempDirSync, readFileSync, run } = Deno; const firstCheckFailedMessage = "First check failed"; @@ -31,11 +31,11 @@ const test = { }, needsNet(): void { try { - listen("tcp", "127.0.0.1:4540"); + Deno.listen({ hostname: "127.0.0.1", port: 4540 }); } catch (e) { console.log(firstCheckFailedMessage); } - listen("tcp", "127.0.0.1:4541"); + Deno.listen({ hostname: "127.0.0.1", port: 4541 }); }, needsRun(): void { try {