Adds HTTP server

Does not yet support streaming bodies.

Author: ry

BUILD.gn

@@ -55,6 +55,7 @@ main_extern = [
   "$rust_build:dirs",
   "$rust_build:futures",
   "$rust_build:getopts",
+  "$rust_build:http",
   "$rust_build:hyper",
   "$rust_build:hyper_rustls",
   "$rust_build:lazy_static",
@@ -97,6 +98,7 @@ ts_sources = [
   "js/form_data.ts",
   "js/global_eval.ts",
   "js/globals.ts",
+  "js/http.ts",
   "js/io.ts",
   "js/libdeno.ts",
   "js/main.ts",

Cargo.toml

@@ -15,6 +15,7 @@ flatbuffers = { path = "third_party/flatbuffers/rust/flatbuffers/" }
 futures = "0.1.25"
 getopts = "0.2.18"
 hyper = "0.12.13"
+http = "0.1.13"
 # The current version of hyper-rustls, 0.14.0, depends on tokio-core, which is
 # deprecated.
 hyper-rustls = { git = "https://github.com/ctz/hyper-rustls.git" }

js/deno.ts

@@ -31,6 +31,7 @@ export { readDirSync, readDir } from "./read_dir";
 export { copyFileSync, copyFile } from "./copy_file";
 export { readlinkSync, readlink } from "./read_link";
 export { statSync, lstatSync, stat, lstat } from "./stat";
+export { httpListen, ServerRequest, ServerResponse } from "./http";
 export { symlinkSync, symlink } from "./symlink";
 export { writeFileSync, writeFile } from "./write_file";
 export { ErrorKind, DenoError } from "./errors";

js/http.ts

@@ -0,0 +1,146 @@
+// Copyright 2018 the Deno authors. All rights reserved. MIT license.
+
+import { Closer } from "./io";
+import * as msg from "gen/msg_generated";
+import { assert, log } from "./util";
+import * as dispatch from "./dispatch";
+import * as flatbuffers from "./flatbuffers";
+import { close } from "./files";
+
+// TODO Cannot use Headers due to bug in ts_declaration_builder.
+// import { Headers } from "./headers";
+// import * as headers from "./headers";
+// import * as domTypes from "./dom_types";
+
+type HttpHandler = (req: ServerRequest, res: ServerResponse) => void;
+
+export class HttpServer implements Closer {
+  private _closing = false;
+
+  constructor(readonly rid: number) {
+    assert(rid >= 2); // rid should be after stdout/stderr
+  }
+
+  async serve(handler: HttpHandler): Promise<void> {
+    while (this._closing === false) {
+      const [req, res] = await httpAccept(this.rid);
+      handler(req, res);
+    }
+  }
+
+  close(): void {
+    this._closing = true;
+    close(this.rid);
+  }
+}
+
+function deserializeHeaderFields(m: msg.HttpHeader): Array<[string, string]> {
+  const out: Array<[string, string]> = [];
+  for (let i = 0; i < m.fieldsLength(); i++) {
+    const item = m.fields(i)!;
+    out.push([item.key()!, item.value()!]);
+  }
+  return out;
+}
+
+export class ServerRequest {
+  // TODO Cannot do this due to ts_declaration_builder bug.
+  // headers: domTypes.Headers;
+  readonly headers: Array<[string, string]>;
+
+  constructor(
+    readonly rid: number,
+    readonly method: string,
+    readonly url: string,
+    headersInit: Array<[string, string]>
+  ) {
+    // TODO cannot use Headers due to ts_declaration_builder bug.
+    // this.headers = new Headers(headersInit);
+    this.headers = headersInit;
+  }
+}
+
+export class ServerResponse {
+  headers = new Array<[string, string]>(); // TODO Use Headers
+  status = 200;
+
+  constructor(readonly rid: number, readonly url: string) {}
+
+  writeResponse(body?: ArrayBufferView): void {
+    httpWriteResponse(this, body);
+    close(this.rid); // TODO Streaming response body.
+  }
+}
+
+async function httpAccept(
+  rid: number
+): Promise<[ServerRequest, ServerResponse]> {
+  const builder = flatbuffers.createBuilder();
+
+  msg.HttpAccept.startHttpAccept(builder);
+  msg.HttpAccept.addListenerRid(builder, rid);
+  const inner = msg.HttpAccept.endHttpAccept(builder);
+
+  const baseRes = await dispatch.sendAsync(builder, msg.Any.HttpAccept, inner);
+  assert(baseRes != null);
+  assert(msg.Any.HttpAcceptRes === baseRes!.innerType());
+  const acceptResMsg = new msg.HttpAcceptRes();
+  assert(baseRes!.inner(acceptResMsg) != null);
+
+  const transactionRid = acceptResMsg.transactionRid();
+  const header = acceptResMsg.header()!;
+  const fields = deserializeHeaderFields(header);
+  const url = header.url()!;
+  const method = header.method()!;
+  log("http accept:", method, url, fields);
+
+  const req = new ServerRequest(transactionRid, method, url, fields);
+  const res = new ServerResponse(transactionRid, url);
+  return [req, res];
+}
+
+export function httpListen(address: string): HttpServer {
+  const builder = flatbuffers.createBuilder();
+  const address_ = builder.createString(address);
+
+  msg.HttpListen.startHttpListen(builder);
+  msg.HttpListen.addAddress(builder, address_);
+  const inner = msg.HttpListen.endHttpListen(builder);
+
+  const baseRes = dispatch.sendSync(builder, msg.Any.HttpListen, inner);
+  assert(baseRes != null);
+  assert(msg.Any.HttpListenRes === baseRes!.innerType());
+  const res = new msg.HttpListenRes();
+  assert(baseRes!.inner(res) != null);
+  return new HttpServer(res.rid());
+}
+
+export function httpWriteResponse(
+  res: ServerResponse,
+  body?: ArrayBufferView
+): void {
+  const builder = flatbuffers.createBuilder();
+  const fields = msg.HttpHeader.createFieldsVector(
+    builder,
+    res.headers.map(([key, val]) => {
+      const key_ = builder.createString(key);
+      const val_ = builder.createString(val);
+      msg.KeyValue.startKeyValue(builder);
+      msg.KeyValue.addKey(builder, key_);
+      msg.KeyValue.addValue(builder, val_);
+      return msg.KeyValue.endKeyValue(builder);
+    })
+  );
+  msg.HttpHeader.startHttpHeader(builder);
+  msg.HttpHeader.addFields(builder, fields);
+  msg.HttpHeader.addStatus(builder, res.status);
+  msg.HttpHeader.addIsRequest(builder, false);
+
+  const header = msg.HttpHeader.endHttpHeader(builder);
+  msg.HttpWriteResponse.startHttpWriteResponse(builder);
+  msg.HttpWriteResponse.addTransactionRid(builder, res.rid);
+  msg.HttpWriteResponse.addHeader(builder, header);
+  const inner = msg.HttpWriteResponse.endHttpWriteResponse(builder);
+  const r = dispatch.sendSync(builder, msg.Any.HttpWriteResponse, inner, body);
+  assert(r == null);
+}

js/http_test.ts

@@ -0,0 +1,37 @@
+// Copyright 2018 the Deno authors. All rights reserved. MIT license.
+import { test, testPerm, assert, assertEqual } from "./test_util.ts";
+import * as deno from "deno";
+
+testPerm({ net: true }, async function httpServerBasic() {
+  const addr = "127.0.0.1:4501";
+  let counter = 0;
+  const server = deno.httpListen(addr);
+  const serverComplete = server.serve(
+    (req: deno.ServerRequest, res: deno.ServerResponse) => {
+      assertEqual(req.url, "/foo");
+      assertEqual(req.method, "GET");
+      assertEqual(req.headers, [["host", "127.0.0.1:4501"]]);
+
+      res.status = 404;
+      res.headers = [["content-type", "text/plain"], ["hello", "world"]];
+      const resBody = new TextEncoder().encode("404 Not Found\n");
+      res.writeResponse(resBody);
+      counter++;
+      server.close();
+    }
+  );
+
+  const fetchRes = await fetch("http://" + addr + "/foo");
+  // TODO
+  // assertEqual(fetchRes.headers, [
+  //   [ "content-type", "text/plain" ],
+  //   [ "hello", "world" ],
+  // ]);
+  // assertEqual(fetchRes.statusText, "Not Found");
+  assertEqual(fetchRes.status, 404);
+  const body = await fetchRes.text();
+  assertEqual(body, "404 Not Found\n");
+
+  await serverComplete;
+  assertEqual(counter, 1);
+});

js/unit_tests.ts

@@ -15,6 +15,7 @@ import "./file_test.ts";
 import "./files_test.ts";
 import "./form_data_test.ts";
 import "./headers_test.ts";
+import "./http_test.ts";
 import "./make_temp_dir_test.ts";
 import "./metrics_test.ts";
 import "./mixins/dom_iterable_test.ts";

src/errors.rs

@@ -149,6 +149,47 @@ impl From<hyper::Error> for DenoError {
   }
 }
 
+use futures::sync::mpsc::SendError;
+impl<T> From<SendError<T>> for DenoError {
+  #[inline]
+  fn from(_err: SendError<T>) -> DenoError {
+    DenoError {
+      repr: Repr::Simple(ErrorKind::Other, String::from("Send Error")),
+    }
+  }
+}
+
+use futures::Canceled;
+impl From<Canceled> for DenoError {
+  #[inline]
+  fn from(_err: Canceled) -> DenoError {
+    DenoError {
+      repr: Repr::Simple(ErrorKind::Other, String::from("Future Canceled")),
+    }
+  }
+}
+
+use http::status::InvalidStatusCode;
+use std::error::Error;
+impl From<InvalidStatusCode> for DenoError {
+  #[inline]
+  fn from(err: InvalidStatusCode) -> DenoError {
+    DenoError {
+      repr: Repr::Simple(ErrorKind::HttpOther, String::from(err.description())),
+    }
+  }
+}
+
+use http::header::InvalidHeaderValue;
+impl From<InvalidHeaderValue> for DenoError {
+  #[inline]
+  fn from(err: InvalidHeaderValue) -> DenoError {
+    DenoError {
+      repr: Repr::Simple(ErrorKind::HttpOther, String::from(err.description())),
+    }
+  }
+}
+
 pub fn bad_resource() -> DenoError {
   new(ErrorKind::BadResource, String::from("bad resource id"))
 }