Merge branch 'main' into ext_node_http_upgrade

Author: bartlomieju

cli/tests/integration/node_unit_tests.rs

@@ -19,6 +19,7 @@ util::unit_test_factory!(
     _fs_close_test = _fs / _fs_close_test,
     _fs_copy_test = _fs / _fs_copy_test,
     _fs_dir_test = _fs / _fs_dir_test,
+    _fs_dirent_test = _fs / _fs_dirent_test,
     _fs_exists_test = _fs / _fs_exists_test,
     _fs_fdatasync_test = _fs / _fs_fdatasync_test,
     _fs_fstat_test = _fs / _fs_fstat_test,

cli/tests/unit_node/_fs/_fs_dirent_test.ts

@@ -0,0 +1,86 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import {
+  assert,
+  assertEquals,
+  assertThrows,
+} from "../../../../test_util/std/testing/asserts.ts";
+import { Dirent as Dirent_ } from "node:fs";
+
+// deno-lint-ignore no-explicit-any
+const Dirent = Dirent_ as any;
+
+class DirEntryMock implements Deno.DirEntry {
+  name = "";
+  isFile = false;
+  isDirectory = false;
+  isSymlink = false;
+}
+
+Deno.test({
+  name: "Directories are correctly identified",
+  fn() {
+    const entry: DirEntryMock = new DirEntryMock();
+    entry.isDirectory = true;
+    entry.isFile = false;
+    entry.isSymlink = false;
+    assert(new Dirent(entry).isDirectory());
+    assert(!new Dirent(entry).isFile());
+    assert(!new Dirent(entry).isSymbolicLink());
+  },
+});
+
+Deno.test({
+  name: "Files are correctly identified",
+  fn() {
+    const entry: DirEntryMock = new DirEntryMock();
+    entry.isDirectory = false;
+    entry.isFile = true;
+    entry.isSymlink = false;
+    assert(!new Dirent(entry).isDirectory());
+    assert(new Dirent(entry).isFile());
+    assert(!new Dirent(entry).isSymbolicLink());
+  },
+});
+
+Deno.test({
+  name: "Symlinks are correctly identified",
+  fn() {
+    const entry: DirEntryMock = new DirEntryMock();
+    entry.isDirectory = false;
+    entry.isFile = false;
+    entry.isSymlink = true;
+    assert(!new Dirent(entry).isDirectory());
+    assert(!new Dirent(entry).isFile());
+    assert(new Dirent(entry).isSymbolicLink());
+  },
+});
+
+Deno.test({
+  name: "File name is correct",
+  fn() {
+    const entry: DirEntryMock = new DirEntryMock();
+    entry.name = "my_file";
+    assertEquals(new Dirent(entry).name, "my_file");
+  },
+});
+
+Deno.test({
+  name: "Socket and FIFO pipes aren't yet available",
+  fn() {
+    const entry: DirEntryMock = new DirEntryMock();
+    assertThrows(
+      () => {
+        new Dirent(entry).isFIFO();
+      },
+      Error,
+      "does not yet support",
+    );
+    assertThrows(
+      () => {
+        new Dirent(entry).isSocket();
+      },
+      Error,
+      "does not yet support",
+    );
+  },
+});

cli/tests/unit_node/http_test.ts

@@ -6,6 +6,7 @@ import https from "node:https";
 import {
   assert,
   assertEquals,
+  fail,
 } from "../../../test_util/std/testing/asserts.ts";
 import { assertSpyCalls, spy } from "../../../test_util/std/testing/mock.ts";
 import { deferred } from "../../../test_util/std/async/deferred.ts";
@@ -618,6 +619,37 @@ Deno.test("[node/http] ClientRequest search params", async () => {
   assertEquals(body, "foo=bar");
 });
 
+Deno.test("[node/http] HTTPS server", async () => {
+  const promise = deferred<void>();
+  const promise2 = deferred<void>();
+  const client = Deno.createHttpClient({
+    caCerts: [Deno.readTextFileSync("cli/tests/testdata/tls/RootCA.pem")],
+  });
+  const server = https.createServer({
+    cert: Deno.readTextFileSync("cli/tests/testdata/tls/localhost.crt"),
+    key: Deno.readTextFileSync("cli/tests/testdata/tls/localhost.key"),
+  }, (_req, res) => {
+    res.end("success!");
+  });
+  server.listen(() => {
+    // deno-lint-ignore no-explicit-any
+    fetch(`https://localhost:${(server.address() as any).port}`, {
+      client,
+    }).then(async (res) => {
+      assertEquals(res.status, 200);
+      assertEquals(await res.text(), "success!");
+      server.close();
+      promise2.resolve();
+    });
+  })
+    .on("error", () => fail());
+  server.on("close", () => {
+    promise.resolve();
+  });
+  await Promise.all([promise, promise2]);
+  client.close();
+});
+
 Deno.test(
   "[node/http] client upgrade",
   { permissions: { net: true } },

ext/fetch/lib.rs

@@ -23,6 +23,7 @@ use deno_core::op;
 use deno_core::BufView;
 use deno_core::WriteOutcome;
 
+use deno_core::task::spawn;
 use deno_core::url::Url;
 use deno_core::AsyncRefCell;
 use deno_core::AsyncResult;
@@ -58,6 +59,8 @@ use reqwest::RequestBuilder;
 use reqwest::Response;
 use serde::Deserialize;
 use serde::Serialize;
+use tokio::io::AsyncReadExt;
+use tokio::io::AsyncWriteExt;
 use tokio::sync::mpsc;
 
 // Re-export reqwest and data_url
@@ -512,8 +515,6 @@ pub fn op_fetch_response_into_byte_stream(
   Ok(rid)
 }
 
-use deno_core::task::spawn;
-
 #[op]
 pub async fn op_fetch_response_upgrade(
   state: Rc<RefCell<OpState>>,
@@ -566,9 +567,6 @@ pub async fn op_fetch_response_upgrade(
   )
 }
 
-use tokio::io::AsyncReadExt;
-use tokio::io::AsyncWriteExt;
-
 struct UpgradeStream {
   read: AsyncRefCell<tokio::io::ReadHalf<tokio::io::DuplexStream>>,
   write: AsyncRefCell<tokio::io::WriteHalf<tokio::io::DuplexStream>>,

ext/http/http_next.rs

@@ -376,12 +376,17 @@ pub fn op_http_read_request_body(
 }
 
 #[op(fast)]
-pub fn op_http_set_response_header(slab_id: SlabId, name: &str, value: &str) {
+pub fn op_http_set_response_header(
+  slab_id: SlabId,
+  name: ByteString,
+  value: ByteString,
+) {
   let mut http = slab_get(slab_id);
   let resp_headers = http.response().headers_mut();
   // These are valid latin-1 strings
-  let name = HeaderName::from_bytes(name.as_bytes()).unwrap();
-  let value = HeaderValue::from_bytes(value.as_bytes()).unwrap();
+  let name = HeaderName::from_bytes(&name).unwrap();
+  // SAFETY: These are valid latin-1 strings
+  let value = unsafe { HeaderValue::from_maybe_shared_unchecked(value) };
   resp_headers.append(name, value);
 }
 
@@ -410,7 +415,9 @@ fn op_http_set_response_headers(
     let v8_name: ByteString = from_v8(scope, name).unwrap();
     let v8_value: ByteString = from_v8(scope, value).unwrap();
     let header_name = HeaderName::from_bytes(&v8_name).unwrap();
-    let header_value = HeaderValue::from_bytes(&v8_value).unwrap();
+    let header_value =
+      // SAFETY: These are valid latin-1 strings
+      unsafe { HeaderValue::from_maybe_shared_unchecked(v8_value) };
     resp_headers.append(header_name, header_value);
   }
 }
@@ -425,7 +432,8 @@ pub fn op_http_set_response_trailers(
   for (name, value) in trailers {
     // These are valid latin-1 strings
     let name = HeaderName::from_bytes(&name).unwrap();
-    let value = HeaderValue::from_bytes(&value).unwrap();
+    // SAFETY: These are valid latin-1 strings
+    let value = unsafe { HeaderValue::from_maybe_shared_unchecked(value) };
     trailer_map.append(name, value);
   }
   *http.trailers().borrow_mut() = Some(trailer_map);

ext/node/polyfills/http.ts

@@ -18,6 +18,7 @@ import { nextTick } from "ext:deno_node/_next_tick.ts";
 import {
   validateBoolean,
   validateInteger,
+  validateObject,
   validatePort,
 } from "ext:deno_node/internal/validators.mjs";
 import {
@@ -1507,16 +1508,16 @@ export class IncomingMessageForServer extends NodeReadable {
   }
 }
 
-type ServerHandler = (
+export type ServerHandler = (
   req: IncomingMessageForServer,
   res: ServerResponse,
 ) => void;
 
-export function Server(handler?: ServerHandler): ServerImpl {
-  return new ServerImpl(handler);
+export function Server(opts, requestListener?: ServerHandler): ServerImpl {
+  return new ServerImpl(opts, requestListener);
 }
 
-class ServerImpl extends EventEmitter {
+export class ServerImpl extends EventEmitter {
   #httpConnections: Set<Deno.HttpConn> = new Set();
   #listener?: Deno.Listener;
 
@@ -1528,12 +1529,24 @@ class ServerImpl extends EventEmitter {
   #servePromise: Deferred<void>;
   listening = false;
 
-  constructor(handler?: ServerHandler) {
+  constructor(opts, requestListener?: ServerHandler) {
     super();
+
+    if (typeof opts === "function") {
+      requestListener = opts;
+      opts = kEmptyObject;
+    } else if (opts == null) {
+      opts = kEmptyObject;
+    } else {
+      validateObject(opts, "options");
+    }
+
+    this._opts = opts;
+
     this.#servePromise = deferred();
     this.#servePromise.then(() => this.emit("close"));
-    if (handler !== undefined) {
-      this.on("request", handler);
+    if (requestListener !== undefined) {
+      this.on("request", requestListener);
     }
   }
 
@@ -1562,12 +1575,12 @@ class ServerImpl extends EventEmitter {
       port,
     } as Deno.NetAddr;
     this.listening = true;
-    nextTick(() => this.#serve());
+    nextTick(() => this._serve());
 
     return this;
   }
 
-  #serve() {
+  _serve() {
     const ac = new AbortController();
     const handler = (request: Request, info: Deno.ServeHandlerInfo) => {
       const req = new IncomingMessageForServer(request, info.remoteAddr);
@@ -1600,6 +1613,7 @@ class ServerImpl extends EventEmitter {
           this.#addr!.port = port;
           this.emit("listening");
         },
+        ...this._additionalServeOptions?.(),
       },
     );
     if (this.#unref) {
@@ -1662,8 +1676,8 @@ class ServerImpl extends EventEmitter {
 
 Server.prototype = ServerImpl.prototype;
 
-export function createServer(handler?: ServerHandler) {
-  return Server(handler);
+export function createServer(opts, requestListener?: ServerHandler) {
+  return Server(opts, requestListener);
 }
 
 /** Makes an HTTP request. */

ext/node/polyfills/https.ts

@@ -10,14 +10,49 @@ import {
 } from "ext:deno_node/http.ts";
 import { Agent as HttpAgent } from "ext:deno_node/_http_agent.mjs";
 import { createHttpClient } from "ext:deno_fetch/22_http_client.js";
+import {
+  type ServerHandler,
+  ServerImpl as HttpServer,
+} from "ext:deno_node/http.ts";
+import { validateObject } from "ext:deno_node/internal/validators.mjs";
+import { kEmptyObject } from "ext:deno_node/internal/util.mjs";
+import { Buffer } from "ext:deno_node/buffer.ts";
+
+export class Server extends HttpServer {
+  constructor(opts, requestListener?: ServerHandler) {
+    if (typeof opts === "function") {
+      requestListener = opts;
+      opts = kEmptyObject;
+    } else if (opts == null) {
+      opts = kEmptyObject;
+    } else {
+      validateObject(opts, "options");
+    }
+
+    if (opts.cert && Array.isArray(opts.cert)) {
+      notImplemented("https.Server.opts.cert array type");
+    }
 
-export class Server {
-  constructor() {
-    notImplemented("https.Server.prototype.constructor");
+    if (opts.key && Array.isArray(opts.key)) {
+      notImplemented("https.Server.opts.key array type");
+    }
+
+    super(opts, requestListener);
+  }
+
+  _additionalServeOptions() {
+    return {
+      cert: this._opts.cert instanceof Buffer
+        ? this._opts.cert.toString()
+        : this._opts.cert,
+      key: this._opts.key instanceof Buffer
+        ? this._opts.key.toString()
+        : this._opts.key,
+    };
   }
 }
-export function createServer() {
-  notImplemented("https.createServer");
+export function createServer(opts, requestListener?: ServerHandler) {
+  return new Server(opts, requestListener);
 }
 
 interface HttpsRequestOptions extends RequestOptions {