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",
@@ -93,6 +94,7 @@ ts_sources = [
   "js/flatbuffers.ts",
   "js/global_eval.ts",
   "js/globals.ts",
+  "js/http.ts",
   "js/io.ts",
   "js/libdeno.ts",
   "js/main.ts",

js/deno.ts

@@ -30,6 +30,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/dom_types.ts

@@ -274,7 +274,7 @@ export interface Blob {
   slice(start?: number, end?: number, contentType?: string): Blob;
 }
 
-interface Body {
+export interface Body {
   /** A simple getter used to expose a `ReadableStream` of the body contents. */
   readonly body: ReadableStream | null;
   /** Stores a `Boolean` that declares whether the body has been used in a
@@ -352,7 +352,7 @@ export interface HeadersConstructor {
   prototype: Headers;
 }
 
-type RequestCache =
+export type RequestCache =
   | "default"
   | "no-store"
   | "reload"
@@ -381,7 +381,7 @@ type RequestDestination =
   | "xslt";
 type RequestMode = "navigate" | "same-origin" | "no-cors" | "cors";
 type RequestRedirect = "follow" | "error" | "manual";
-type ResponseType =
+export type ResponseType =
   | "basic"
   | "cors"
   | "default"

js/headers.ts

@@ -10,7 +10,7 @@ function isHeaders(value: any): value is domTypes.Headers {
 const headerMap = Symbol("header map");
 
 // ref: https://fetch.spec.whatwg.org/#dom-headers
-class HeadersBase {
+export class HeadersBase {
   private [headerMap]: Map<string, string>;
 
   private _normalizeParams(name: string, value?: string): string[] {

js/http.ts

@@ -0,0 +1,143 @@
+// 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);
+  }
+
+  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/net.ts

@@ -6,7 +6,7 @@ import * as dispatch from "./dispatch";
 import * as flatbuffers from "./flatbuffers";
 import { read, write, close } from "./files";
 
-export type Network = "tcp";
+export type Network = "tcp" | "http";
 // TODO support other types:
 // export type Network = "tcp" | "tcp4" | "tcp6" | "unix" | "unixpacket";
 
@@ -15,6 +15,9 @@ export type Addr = string;
 
 /** A Listener is a generic network listener for stream-oriented protocols. */
 export interface Listener {
+  /** Resource id for this listener. AKA file descriptor. */
+  readonly rid: number;
+
   /** Waits for and resolves to the next connection to the `Listener`. */
   accept(): Promise<Conn>;
 

js/os.ts

@@ -86,6 +86,7 @@ function createEnv(inner: msg.EnvironRes): { [index: string]: string } {
 
   for (let i = 0; i < inner.mapLength(); i++) {
     const item = inner.map(i)!;
+
     env[item.key()!] = item.value()!;
   }
 

js/unit_tests.ts

@@ -12,6 +12,7 @@ import "./dir_test";
 import "./fetch_test.ts";
 import "./files_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"))
 }