.deno/gen/https/deno.land/8d6b5cd21d4064cfdc92ce7f09807d551dcbce46a7ecc6af2532ffe73b7aba43.js

// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
import { BufReader, BufWriter } from "../io/bufio.ts";
import { assert } from "../_util/assert.ts";
import { deferred, MuxAsyncIterator } from "../async/mod.ts";
import { bodyReader, chunkedBodyReader, emptyReader, readRequest, writeResponse } from "./_io.ts";
export class ServerRequest {
    url;
    method;
    proto;
    protoMinor;
    protoMajor;
    headers;
    conn;
    r;
    w;
    #done = deferred();
    #contentLength = undefined;
    #body = undefined;
    #finalized = false;
    get done() {
        return this.#done.then((e)=>e);
    }
    /**
   * Value of Content-Length header.
   * If null, then content length is invalid or not given (e.g. chunked encoding).
   */ get contentLength() {
        // undefined means not cached.
        // null means invalid or not provided.
        if (this.#contentLength === undefined) {
            const cl = this.headers.get("content-length");
            if (cl) {
                this.#contentLength = parseInt(cl);
                // Convert NaN to null (as NaN harder to test)
                if (Number.isNaN(this.#contentLength)) {
                    this.#contentLength = null;
                }
            } else {
                this.#contentLength = null;
            }
        }
        return this.#contentLength;
    }
    /**
   * Body of the request.  The easiest way to consume the body is:
   *
   *     const buf: Uint8Array = await readAll(req.body);
   */ get body() {
        if (!this.#body) {
            if (this.contentLength != null) {
                this.#body = bodyReader(this.contentLength, this.r);
            } else {
                const transferEncoding = this.headers.get("transfer-encoding");
                if (transferEncoding != null) {
                    const parts = transferEncoding.split(",").map((e)=>e.trim().toLowerCase());
                    assert(parts.includes("chunked"), 'transfer-encoding must include "chunked" if content-length is not set');
                    this.#body = chunkedBodyReader(this.headers, this.r);
                } else {
                    // Neither content-length nor transfer-encoding: chunked
                    this.#body = emptyReader();
                }
            }
        }
        return this.#body;
    }
    async respond(r) {
        let err;
        try {
            // Write our response!
            await writeResponse(this.w, r);
        } catch (e) {
            try {
                // Eagerly close on error.
                this.conn.close();
            } catch  {
            // Pass
            }
            err = e;
        }
        // Signal that this request has been processed and the next pipelined
        // request on the same connection can be accepted.
        this.#done.resolve(err);
        if (err) {
            // Error during responding, rethrow.
            throw err;
        }
    }
    async finalize() {
        if (this.#finalized) return;
        // Consume unread body
        const body = this.body;
        const buf = new Uint8Array(1024);
        while(await body.read(buf) !== null){
        // Pass
        }
        this.#finalized = true;
    }
}
export class Server {
    listener;
    #closing;
    #connections;
    constructor(listener){
        this.listener = listener;
        this.#closing = false;
        this.#connections = [];
    }
    close() {
        this.#closing = true;
        this.listener.close();
        for (const conn of this.#connections){
            try {
                conn.close();
            } catch (e) {
                // Connection might have been already closed
                if (!(e instanceof Deno.errors.BadResource)) {
                    throw e;
                }
            }
        }
    }
    // Yields all HTTP requests on a single TCP connection.
    async *iterateHttpRequests(conn) {
        const reader = new BufReader(conn);
        const writer = new BufWriter(conn);
        while(!this.#closing){
            let request;
            try {
                request = await readRequest(conn, reader);
            } catch (error) {
                if (error instanceof Deno.errors.InvalidData || error instanceof Deno.errors.UnexpectedEof) {
                    // An error was thrown while parsing request headers.
                    // Try to send the "400 Bad Request" before closing the connection.
                    try {
                        await writeResponse(writer, {
                            status: 400,
                            body: new TextEncoder().encode(`${error.message}\r\n\r\n`)
                        });
                    } catch  {
                    // The connection is broken.
                    }
                }
                break;
            }
            if (request === null) {
                break;
            }
            request.w = writer;
            yield request;
            // Wait for the request to be processed before we accept a new request on
            // this connection.
            const responseError = await request.done;
            if (responseError) {
                // Something bad happened during response.
                // (likely other side closed during pipelined req)
                // req.done implies this connection already closed, so we can just return.
                this.untrackConnection(request.conn);
                return;
            }
            try {
                // Consume unread body and trailers if receiver didn't consume those data
                await request.finalize();
            } catch  {
                break;
            }
        }
        this.untrackConnection(conn);
        try {
            conn.close();
        } catch  {
        // might have been already closed
        }
    }
    trackConnection(conn) {
        this.#connections.push(conn);
    }
    untrackConnection(conn) {
        const index = this.#connections.indexOf(conn);
        if (index !== -1) {
            this.#connections.splice(index, 1);
        }
    }
    // Accepts a new TCP connection and yields all HTTP requests that arrive on
    // it. When a connection is accepted, it also creates a new iterator of the
    // same kind and adds it to the request multiplexer so that another TCP
    // connection can be accepted.
    async *acceptConnAndIterateHttpRequests(mux) {
        if (this.#closing) return;
        // Wait for a new connection.
        let conn;
        try {
            conn = await this.listener.accept();
        } catch (error) {
            if (// The listener is closed:
            error instanceof Deno.errors.BadResource || // TLS handshake errors:
            error instanceof Deno.errors.InvalidData || error instanceof Deno.errors.UnexpectedEof || error instanceof Deno.errors.ConnectionReset) {
                return mux.add(this.acceptConnAndIterateHttpRequests(mux));
            }
            throw error;
        }
        this.trackConnection(conn);
        // Try to accept another connection and add it to the multiplexer.
        mux.add(this.acceptConnAndIterateHttpRequests(mux));
        // Yield the requests that arrive on the just-accepted connection.
        yield* this.iterateHttpRequests(conn);
    }
    [Symbol.asyncIterator]() {
        const mux = new MuxAsyncIterator();
        mux.add(this.acceptConnAndIterateHttpRequests(mux));
        return mux.iterate();
    }
}
/**
 * Parse addr from string
 *
 *     const addr = "::1:8000";
 *     parseAddrFromString(addr);
 *
 * @param addr Address string
 */ export function _parseAddrFromStr(addr) {
    let url;
    try {
        const host = addr.startsWith(":") ? `0.0.0.0${addr}` : addr;
        url = new URL(`http://${host}`);
    } catch  {
        throw new TypeError("Invalid address.");
    }
    if (url.username || url.password || url.pathname != "/" || url.search || url.hash) {
        throw new TypeError("Invalid address.");
    }
    return {
        hostname: url.hostname,
        port: url.port === "" ? 80 : Number(url.port)
    };
}
/**
 * Create a HTTP server
 *
 *     import { serve } from "https://deno.land/std/http/server.ts";
 *     const body = "Hello World\n";
 *     const server = serve({ port: 8000 });
 *     for await (const req of server) {
 *       req.respond({ body });
 *     }
 */ export function serve(addr) {
    if (typeof addr === "string") {
        addr = _parseAddrFromStr(addr);
    }
    const listener = Deno.listen(addr);
    return new Server(listener);
}
/**
 * Start an HTTP server with given options and request handler
 *
 *     const body = "Hello World\n";
 *     const options = { port: 8000 };
 *     listenAndServe(options, (req) => {
 *       req.respond({ body });
 *     });
 *
 * @param options Server configuration
 * @param handler Request handler
 */ export async function listenAndServe(addr, handler) {
    const server = serve(addr);
    for await (const request of server){
        handler(request);
    }
}
/**
 * Create an HTTPS server with given options
 *
 *     const body = "Hello HTTPS";
 *     const options = {
 *       hostname: "localhost",
 *       port: 443,
 *       certFile: "./path/to/localhost.crt",
 *       keyFile: "./path/to/localhost.key",
 *     };
 *     for await (const req of serveTLS(options)) {
 *       req.respond({ body });
 *     }
 *
 * @param options Server configuration
 * @return Async iterable server instance for incoming requests
 */ export function serveTLS(options) {
    const tlsOptions = {
        ...options,
        transport: "tcp"
    };
    const listener = Deno.listenTls(tlsOptions);
    return new Server(listener);
}
/**
 * Start an HTTPS server with given options and request handler
 *
 *     const body = "Hello HTTPS";
 *     const options = {
 *       hostname: "localhost",
 *       port: 443,
 *       certFile: "./path/to/localhost.crt",
 *       keyFile: "./path/to/localhost.key",
 *     };
 *     listenAndServeTLS(options, (req) => {
 *       req.respond({ body });
 *     });
 *
 * @param options Server configuration
 * @param handler Request handler
 */ export async function listenAndServeTLS(options, handler) {
    const server = serveTLS(options);
    for await (const request of server){
        handler(request);
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.92.0/http/server.ts"],"sourcesContent":["// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.\nimport { BufReader, BufWriter } from \"../io/bufio.ts\";\nimport { assert } from \"../_util/assert.ts\";\nimport { Deferred, deferred, MuxAsyncIterator } from \"../async/mod.ts\";\nimport {\n  bodyReader,\n  chunkedBodyReader,\n  emptyReader,\n  readRequest,\n  writeResponse,\n} from \"./_io.ts\";\nexport class ServerRequest {\n  url!: string;\n  method!: string;\n  proto!: string;\n  protoMinor!: number;\n  protoMajor!: number;\n  headers!: Headers;\n  conn!: Deno.Conn;\n  r!: BufReader;\n  w!: BufWriter;\n\n  #done: Deferred<Error | undefined> = deferred();\n  #contentLength?: number | null = undefined;\n  #body?: Deno.Reader = undefined;\n  #finalized = false;\n\n  get done(): Promise<Error | undefined> {\n    return this.#done.then((e) => e);\n  }\n\n  /**\n   * Value of Content-Length header.\n   * If null, then content length is invalid or not given (e.g. chunked encoding).\n   */\n  get contentLength(): number | null {\n    // undefined means not cached.\n    // null means invalid or not provided.\n    if (this.#contentLength === undefined) {\n      const cl = this.headers.get(\"content-length\");\n      if (cl) {\n        this.#contentLength = parseInt(cl);\n        // Convert NaN to null (as NaN harder to test)\n        if (Number.isNaN(this.#contentLength)) {\n          this.#contentLength = null;\n        }\n      } else {\n        this.#contentLength = null;\n      }\n    }\n    return this.#contentLength;\n  }\n\n  /**\n   * Body of the request.  The easiest way to consume the body is:\n   *\n   *     const buf: Uint8Array = await readAll(req.body);\n   */\n  get body(): Deno.Reader {\n    if (!this.#body) {\n      if (this.contentLength != null) {\n        this.#body = bodyReader(this.contentLength, this.r);\n      } else {\n        const transferEncoding = this.headers.get(\"transfer-encoding\");\n        if (transferEncoding != null) {\n          const parts = transferEncoding\n            .split(\",\")\n            .map((e): string => e.trim().toLowerCase());\n          assert(\n            parts.includes(\"chunked\"),\n            'transfer-encoding must include \"chunked\" if content-length is not set',\n          );\n          this.#body = chunkedBodyReader(this.headers, this.r);\n        } else {\n          // Neither content-length nor transfer-encoding: chunked\n          this.#body = emptyReader();\n        }\n      }\n    }\n    return this.#body;\n  }\n\n  async respond(r: Response): Promise<void> {\n    let err: Error | undefined;\n    try {\n      // Write our response!\n      await writeResponse(this.w, r);\n    } catch (e) {\n      try {\n        // Eagerly close on error.\n        this.conn.close();\n      } catch {\n        // Pass\n      }\n      err = e;\n    }\n    // Signal that this request has been processed and the next pipelined\n    // request on the same connection can be accepted.\n    this.#done.resolve(err);\n    if (err) {\n      // Error during responding, rethrow.\n      throw err;\n    }\n  }\n\n  async finalize(): Promise<void> {\n    if (this.#finalized) return;\n    // Consume unread body\n    const body = this.body;\n    const buf = new Uint8Array(1024);\n    while ((await body.read(buf)) !== null) {\n      // Pass\n    }\n    this.#finalized = true;\n  }\n}\n\nexport class Server implements AsyncIterable<ServerRequest> {\n  #closing = false;\n  #connections: Deno.Conn[] = [];\n\n  constructor(public listener: Deno.Listener) {}\n\n  close(): void {\n    this.#closing = true;\n    this.listener.close();\n    for (const conn of this.#connections) {\n      try {\n        conn.close();\n      } catch (e) {\n        // Connection might have been already closed\n        if (!(e instanceof Deno.errors.BadResource)) {\n          throw e;\n        }\n      }\n    }\n  }\n\n  // Yields all HTTP requests on a single TCP connection.\n  private async *iterateHttpRequests(\n    conn: Deno.Conn,\n  ): AsyncIterableIterator<ServerRequest> {\n    const reader = new BufReader(conn);\n    const writer = new BufWriter(conn);\n\n    while (!this.#closing) {\n      let request: ServerRequest | null;\n      try {\n        request = await readRequest(conn, reader);\n      } catch (error) {\n        if (\n          error instanceof Deno.errors.InvalidData ||\n          error instanceof Deno.errors.UnexpectedEof\n        ) {\n          // An error was thrown while parsing request headers.\n          // Try to send the \"400 Bad Request\" before closing the connection.\n          try {\n            await writeResponse(writer, {\n              status: 400,\n              body: new TextEncoder().encode(`${error.message}\\r\\n\\r\\n`),\n            });\n          } catch {\n            // The connection is broken.\n          }\n        }\n        break;\n      }\n      if (request === null) {\n        break;\n      }\n\n      request.w = writer;\n      yield request;\n\n      // Wait for the request to be processed before we accept a new request on\n      // this connection.\n      const responseError = await request.done;\n      if (responseError) {\n        // Something bad happened during response.\n        // (likely other side closed during pipelined req)\n        // req.done implies this connection already closed, so we can just return.\n        this.untrackConnection(request.conn);\n        return;\n      }\n\n      try {\n        // Consume unread body and trailers if receiver didn't consume those data\n        await request.finalize();\n      } catch {\n        // Invalid data was received or the connection was closed.\n        break;\n      }\n    }\n\n    this.untrackConnection(conn);\n    try {\n      conn.close();\n    } catch {\n      // might have been already closed\n    }\n  }\n\n  private trackConnection(conn: Deno.Conn): void {\n    this.#connections.push(conn);\n  }\n\n  private untrackConnection(conn: Deno.Conn): void {\n    const index = this.#connections.indexOf(conn);\n    if (index !== -1) {\n      this.#connections.splice(index, 1);\n    }\n  }\n\n  // Accepts a new TCP connection and yields all HTTP requests that arrive on\n  // it. When a connection is accepted, it also creates a new iterator of the\n  // same kind and adds it to the request multiplexer so that another TCP\n  // connection can be accepted.\n  private async *acceptConnAndIterateHttpRequests(\n    mux: MuxAsyncIterator<ServerRequest>,\n  ): AsyncIterableIterator<ServerRequest> {\n    if (this.#closing) return;\n    // Wait for a new connection.\n    let conn: Deno.Conn;\n    try {\n      conn = await this.listener.accept();\n    } catch (error) {\n      if (\n        // The listener is closed:\n        error instanceof Deno.errors.BadResource ||\n        // TLS handshake errors:\n        error instanceof Deno.errors.InvalidData ||\n        error instanceof Deno.errors.UnexpectedEof ||\n        error instanceof Deno.errors.ConnectionReset\n      ) {\n        return mux.add(this.acceptConnAndIterateHttpRequests(mux));\n      }\n      throw error;\n    }\n    this.trackConnection(conn);\n    // Try to accept another connection and add it to the multiplexer.\n    mux.add(this.acceptConnAndIterateHttpRequests(mux));\n    // Yield the requests that arrive on the just-accepted connection.\n    yield* this.iterateHttpRequests(conn);\n  }\n\n  [Symbol.asyncIterator](): AsyncIterableIterator<ServerRequest> {\n    const mux: MuxAsyncIterator<ServerRequest> = new MuxAsyncIterator();\n    mux.add(this.acceptConnAndIterateHttpRequests(mux));\n    return mux.iterate();\n  }\n}\n\n/** Options for creating an HTTP server. */\nexport type HTTPOptions = Omit<Deno.ListenOptions, \"transport\">;\n\n/**\n * Parse addr from string\n *\n *     const addr = \"::1:8000\";\n *     parseAddrFromString(addr);\n *\n * @param addr Address string\n */\nexport function _parseAddrFromStr(addr: string): HTTPOptions {\n  let url: URL;\n  try {\n    const host = addr.startsWith(\":\") ? `0.0.0.0${addr}` : addr;\n    url = new URL(`http://${host}`);\n  } catch {\n    throw new TypeError(\"Invalid address.\");\n  }\n  if (\n    url.username ||\n    url.password ||\n    url.pathname != \"/\" ||\n    url.search ||\n    url.hash\n  ) {\n    throw new TypeError(\"Invalid address.\");\n  }\n\n  return {\n    hostname: url.hostname,\n    port: url.port === \"\" ? 80 : Number(url.port),\n  };\n}\n\n/**\n * Create a HTTP server\n *\n *     import { serve } from \"https://deno.land/std/http/server.ts\";\n *     const body = \"Hello World\\n\";\n *     const server = serve({ port: 8000 });\n *     for await (const req of server) {\n *       req.respond({ body });\n *     }\n */\nexport function serve(addr: string | HTTPOptions): Server {\n  if (typeof addr === \"string\") {\n    addr = _parseAddrFromStr(addr);\n  }\n\n  const listener = Deno.listen(addr);\n  return new Server(listener);\n}\n\n/**\n * Start an HTTP server with given options and request handler\n *\n *     const body = \"Hello World\\n\";\n *     const options = { port: 8000 };\n *     listenAndServe(options, (req) => {\n *       req.respond({ body });\n *     });\n *\n * @param options Server configuration\n * @param handler Request handler\n */\nexport async function listenAndServe(\n  addr: string | HTTPOptions,\n  handler: (req: ServerRequest) => void,\n): Promise<void> {\n  const server = serve(addr);\n\n  for await (const request of server) {\n    handler(request);\n  }\n}\n\n/** Options for creating an HTTPS server. */\nexport type HTTPSOptions = Omit<Deno.ListenTlsOptions, \"transport\">;\n\n/**\n * Create an HTTPS server with given options\n *\n *     const body = \"Hello HTTPS\";\n *     const options = {\n *       hostname: \"localhost\",\n *       port: 443,\n *       certFile: \"./path/to/localhost.crt\",\n *       keyFile: \"./path/to/localhost.key\",\n *     };\n *     for await (const req of serveTLS(options)) {\n *       req.respond({ body });\n *     }\n *\n * @param options Server configuration\n * @return Async iterable server instance for incoming requests\n */\nexport function serveTLS(options: HTTPSOptions): Server {\n  const tlsOptions: Deno.ListenTlsOptions = {\n    ...options,\n    transport: \"tcp\",\n  };\n  const listener = Deno.listenTls(tlsOptions);\n  return new Server(listener);\n}\n\n/**\n * Start an HTTPS server with given options and request handler\n *\n *     const body = \"Hello HTTPS\";\n *     const options = {\n *       hostname: \"localhost\",\n *       port: 443,\n *       certFile: \"./path/to/localhost.crt\",\n *       keyFile: \"./path/to/localhost.key\",\n *     };\n *     listenAndServeTLS(options, (req) => {\n *       req.respond({ body });\n *     });\n *\n * @param options Server configuration\n * @param handler Request handler\n */\nexport async function listenAndServeTLS(\n  options: HTTPSOptions,\n  handler: (req: ServerRequest) => void,\n): Promise<void> {\n  const server = serveTLS(options);\n\n  for await (const request of server) {\n    handler(request);\n  }\n}\n\n/**\n * Interface of HTTP server response.\n * If body is a Reader, response would be chunked.\n * If body is a string, it would be UTF-8 encoded by default.\n */\nexport interface Response {\n  status?: number;\n  headers?: Headers;\n  body?: Uint8Array | Deno.Reader | string;\n  trailers?: () => Promise<Headers> | Headers;\n}\n"],"names":[],"mappings":"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"}