@litert/televoke 0.4.7 → 1.0.0-0

package/src/lib/transporters/http-listener/Http.Decl.ts

@@ -0,0 +1,141 @@
+/**
+* Copyright 2023 Angus.Fenying <fenying@litert.org>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*   https://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import type * as Shared from '../../shared';
+import type * as Https from 'node:https';
+import type * as Http from 'node:http';
+
+export type ILegacyHttpApiProcessor = (req: Http.IncomingMessage, resp: Http.ServerResponse) => void;
+
+export type IUpgradeProcessor = (req: Http.IncomingMessage, socket: NodeJS.Socket, head: Buffer) => void;
+
+export interface IHttpListener extends Shared.IEventListener<Shared.IDefaultEvents> {
+
+    /**
+     * The port the listener is listening on.
+     */
+    readonly port: number;
+
+    /**
+     * Whether the listener is running.
+     */
+    readonly running: boolean;
+
+    /**
+     * Start the listener.
+     */
+    start(): Promise<void>;
+
+    /**
+     * Stop the listener.
+     */
+    stop(): Promise<void>;
+
+    /**
+     * Set the upgrade processor.
+     *
+     * @param processor The new processor to set, or `null` to remove the processor and use the default processor.
+     */
+    setUpgradeProcessor(processor: IUpgradeProcessor | null): void;
+
+    /**
+     * Set the legacy API processor.
+     *
+     * @param processor The new processor to set, or `null` to remove the processor and use the default processor.
+     */
+    setLegacyApiProcessor(processor: ILegacyHttpApiProcessor | null): void;
+}
+
+const DEFAULT_REFUSE_PAYLOAD = Buffer.from('BAD REQUEST');
+const DEFAULT_REFUSE_STATUS_CODE = 400;
+
+/**
+ * The default processor of legacy HTTP API, it will reject all requests with 400 Bad Request.
+ */
+export const DEFAULT_LEGACY_HTTP_API_PROCESSOR: ILegacyHttpApiProcessor = function(_req, resp): void {
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    resp.writeHead(DEFAULT_REFUSE_STATUS_CODE, {
+        'Content-Type': 'text/plain',
+        'Content-Length': DEFAULT_REFUSE_PAYLOAD.byteLength,
+    });
+    resp.end(DEFAULT_REFUSE_PAYLOAD);
+};
+
+/**
+ * The default upgrade processor, it will destroy the socket.
+ */
+export const DEFAULT_UPGRADE_PROCESSOR: IUpgradeProcessor = function(req): void {
+
+    const socket = req.socket;
+
+    const header: Http.OutgoingHttpHeaders = {
+        'Content-Type': 'text/plain',
+        'Content-Length': DEFAULT_REFUSE_PAYLOAD.byteLength,
+    };
+
+    socket.write([
+        `HTTP/1.1 ${DEFAULT_REFUSE_STATUS_CODE}`,
+        ...Object.entries(header).map(([k, v]) => `${k}: ${v as string}`),
+        ''
+    ].join('\r\n'));
+
+    socket.write(DEFAULT_REFUSE_PAYLOAD);
+
+    socket.write('\r\n');
+
+    socket.end();
+};
+
+export interface IHttpListenerOptions {
+
+    /**
+     * The hostname to listen on.
+     *
+     * @default 'localhost'
+     */
+    hostname?: string;
+
+    /**
+     * The port to listen on.
+     *
+     * @default 80 for http, or 443 for https
+     */
+    port?: number;
+
+    /**
+     * The maximum length of the queue of pending connections.
+     *
+     * @default 511
+     */
+    backlog?: number;
+}
+
+export interface IHttpUnixSocketOptions {
+
+    /**
+     * The path of Unix domain socket to listen on.
+     */
+    socketPath: string;
+}
+
+export interface IHttpsListenerOptions extends IHttpListenerOptions {
+
+    /**
+     * The options to create the HTTPS server.
+     */
+    tlsOptions: Https.ServerOptions;
+}

package/src/lib/transporters/http-listener/HttpListener.ts

@@ -0,0 +1,102 @@
+/**
+* Copyright 2023 Angus.Fenying <fenying@litert.org>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*   https://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import type * as $Net from 'node:net';
+import * as Http from 'node:http';
+import * as dH from './Http.Decl';
+import * as v1 from '../../shared/Encodings/v1';
+import { AbstractHttpListener } from './AbstractHttpListener';
+
+class HttpListener extends AbstractHttpListener {
+
+    public constructor(
+        private readonly _opts: dH.IHttpListenerOptions,
+    ) {
+
+        super();
+
+        this.port = _opts.port ?? v1.DEFAULT_INSECURE_PORT;
+    }
+
+    public async start(): Promise<void> {
+
+        if (this._gateway) {
+
+            return;
+        }
+
+        const gateway = Http.createServer(this._apiProcessor);
+
+        const ret = new Promise<void>((resolve, reject) => {
+            gateway.on('error', (e) => {
+                reject(e);
+            }).on('listening', () => {
+
+                gateway.removeAllListeners('error');
+                this._gateway = gateway;
+                if (this.port === 0) {
+
+                    this.port = (gateway.address() as $Net.AddressInfo).port;
+                }
+                gateway.on('error', (e) => this.emit('error', e));
+                gateway.on('upgrade', this._upgradeProcessor);
+                resolve();
+            });
+        });
+
+        gateway.listen(
+            this._opts.port ?? v1.DEFAULT_INSECURE_PORT,
+            this._opts.hostname ?? v1.DEFAULT_HOSTNAME,
+            this._opts.backlog ?? v1.DEFAULT_BACKLOG,
+        );
+
+        return ret;
+    }
+
+    public async stop(): Promise<void> {
+
+        if (!this._gateway) {
+
+            return Promise.resolve();
+        }
+
+        const gateway = this._gateway;
+
+        return new Promise<void>((resolve, reject) => {
+
+            gateway.close((e) => {
+
+                if (e) {
+
+                    reject(e);
+                    return;
+                }
+
+                resolve();
+
+                if (this._gateway === gateway) {
+
+                    this._gateway = null;
+                }
+            });
+        });
+    }
+}
+
+export function createHttpListener(opts: dH.IHttpListenerOptions = {}): dH.IHttpListener {
+
+    return new HttpListener(opts);
+}

package/src/lib/transporters/http-listener/HttpUnixSocketListener.ts

@@ -0,0 +1,97 @@
+/**
+* Copyright 2023 Angus.Fenying <fenying@litert.org>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*   https://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import type * as $Net from 'node:net';
+import * as Http from 'node:http';
+import * as dH from './Http.Decl';
+import { AbstractHttpListener } from './AbstractHttpListener';
+
+class HttpUnixSocketListener extends AbstractHttpListener {
+
+    public constructor(
+        private readonly _opts: dH.IHttpUnixSocketOptions,
+    ) {
+
+        super();
+
+        this.port = 0;
+    }
+
+    public async start(): Promise<void> {
+
+        if (this._gateway) {
+
+            return;
+        }
+
+        const gateway = Http.createServer(this._apiProcessor);
+
+        const ret = new Promise<void>((resolve, reject) => {
+            gateway.on('error', (e) => {
+                reject(e);
+            }).on('listening', () => {
+
+                gateway.removeAllListeners('error');
+                this._gateway = gateway;
+                if (this.port === 0) {
+
+                    this.port = (gateway.address() as $Net.AddressInfo).port;
+                }
+                gateway.on('error', (e) => this.emit('error', e));
+                gateway.on('upgrade', this._upgradeProcessor);
+                resolve();
+            });
+        });
+
+        gateway.listen(this._opts.socketPath);
+
+        return ret;
+    }
+
+    public async stop(): Promise<void> {
+
+        if (!this._gateway) {
+
+            return Promise.resolve();
+        }
+
+        const gateway = this._gateway;
+
+        return new Promise<void>((resolve, reject) => {
+
+            gateway.close((e) => {
+
+                if (e) {
+
+                    reject(e);
+                    return;
+                }
+
+                resolve();
+
+                if (this._gateway === gateway) {
+
+                    this._gateway = null;
+                }
+            });
+        });
+    }
+}
+
+export function createHttpUnixSocketListener(opts: dH.IHttpUnixSocketOptions): dH.IHttpListener {
+
+    return new HttpUnixSocketListener(opts);
+}

package/src/lib/transporters/http-listener/HttpsListener.ts

@@ -0,0 +1,102 @@
+/**
+* Copyright 2023 Angus.Fenying <fenying@litert.org>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*   https://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import * as Https from 'node:https';
+import type * as $Net from 'node:net';
+import * as dH from './Http.Decl';
+import * as v1 from '../../shared/Encodings/v1';
+import { AbstractHttpListener } from './AbstractHttpListener';
+
+class HttpsListener extends AbstractHttpListener {
+
+    public constructor(
+        private readonly _opts: dH.IHttpsListenerOptions,
+    ) {
+
+        super();
+
+        this.port = _opts.port ?? v1.DEFAULT_SECURE_PORT;
+    }
+
+    public async start(): Promise<void> {
+
+        if (this._gateway) {
+
+            return;
+        }
+
+        const gateway = Https.createServer(this._opts.tlsOptions ?? {}, this._apiProcessor);
+
+        const ret = new Promise<void>((resolve, reject) => {
+            gateway.on('error', (e) => {
+                reject(e);
+            }).on('listening', () => {
+
+                gateway.removeAllListeners('error');
+                this._gateway = gateway;
+                if (this._opts.port === 0) {
+
+                    this._opts.port = (gateway.address() as $Net.AddressInfo).port;
+                }
+                gateway.on('error', (e) => this.emit('error', e));
+                gateway.on('upgrade', this._upgradeProcessor);
+                resolve();
+            });
+        });
+
+        gateway.listen(
+            this._opts.port ?? v1.DEFAULT_SECURE_PORT,
+            this._opts.hostname ?? v1.DEFAULT_HOSTNAME,
+            this._opts.backlog ?? v1.DEFAULT_BACKLOG,
+        );
+
+        return ret;
+    }
+
+    public async stop(): Promise<void> {
+
+        if (!this._gateway) {
+
+            return Promise.resolve();
+        }
+
+        const gateway = this._gateway;
+
+        return new Promise<void>((resolve, reject) => {
+
+            gateway.close((e) => {
+
+                if (e) {
+
+                    reject(e);
+                    return;
+                }
+
+                resolve();
+
+                if (this._gateway === gateway) {
+
+                    this._gateway = null;
+                }
+            });
+        });
+    }
+}
+
+export function createHttpsListener(opts: dH.IHttpsListenerOptions): dH.IHttpListener {
+
+    return new HttpsListener(opts);
+}

package/src/lib/transporters/http-listener/index.ts

@@ -0,0 +1,20 @@
+/**
+* Copyright 2023 Angus.Fenying <fenying@litert.org>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*   https://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+export * from './Http.Decl';
+export * from './HttpListener';
+export * from './HttpsListener';
+export * from './HttpUnixSocketListener';

package/src/lib/transporters/index.ts

@@ -0,0 +1,17 @@
+/**
+* Copyright 2023 Angus.Fenying <fenying@litert.org>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*   https://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+export type * from './Transporter.decl';