@litert/televoke 0.4.6 → 1.0.0-0

package/src/lib/transporters/legacy-http/LegacyHttp.Server.ts

@@ -0,0 +1,262 @@
+/**
+* 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 Listener from '../http-listener';
+import type * as Http from 'node:http';
+import type * as dT from '../Transporter.decl';
+import * as Shared from '../../shared';
+import { EventEmitter } from 'node:events';
+import { LegacyHttpTransporter } from './LegacyHttp.Transporter';
+import * as v1 from '../../shared/Encodings/v1';
+
+const encoder = new v1.TvEncoderV1();
+
+const INVALID_REQUEST_RESPONSE = Buffer.from(encoder.encodeApiErrorResponse(
+    'null',
+    Shared.Encodings.v1.EResponseCode.MALFORMED_ARGUMENTS,
+    'INVALID REQUEST',
+    0
+));
+
+function refuseBadRequest(resp: Http.ServerResponse): void {
+
+    try {
+
+        resp.writeHead(400, {
+            'content-length': INVALID_REQUEST_RESPONSE.byteLength,
+        });
+        const socket = resp.socket!;
+        resp.end(INVALID_REQUEST_RESPONSE);
+        socket.destroy();
+    }
+    catch {
+
+        // do nothing.
+    }
+}
+
+export interface IHttpGatewayOptions {
+
+    hostname?: string;
+
+    port?: number;
+
+    backlog?: number;
+}
+
+class LegacyHttpGateway extends EventEmitter implements dT.IGateway {
+
+    public constructor(
+        private readonly _listener: Listener.IHttpListener,
+        private readonly _server: dT.IServer,
+    ) {
+
+        super();
+
+        if (this._server.router.encoding !== 'json') {
+
+            throw new TypeError('Legacy HTTP gateway only supports JSON encoding');
+        }
+
+        this._listener
+            .on('error', (e) => this.emit('error', e))
+            .setLegacyApiProcessor(this._onRequest);
+    }
+
+    public get running(): boolean {
+
+        return this._listener.running;
+    }
+
+    private readonly _onRequest = (req: Http.IncomingMessage, resp: Http.ServerResponse): void => {
+
+        if (req.method !== 'POST' || !req.headers['content-length']) {
+
+            refuseBadRequest(resp);
+            this.emit('error', new Shared.errors.invalid_packet({
+                reason: 'invalid_request',
+                data: {
+                    'method': req.method,
+                    'headers': req.headers,
+                    'url': req.url,
+                },
+            }));
+            return;
+        }
+
+        const length = parseInt(req.headers['content-length']);
+
+        if (!Number.isSafeInteger(length) || length > v1.MAX_PACKET_SIZE) { // Maximum request packet is 64MB
+
+            refuseBadRequest(resp);
+            this.emit('error', new Shared.errors.invalid_packet({
+                reason: 'invalid_packet_length',
+                data: {
+                    'length': length,
+                    'max': v1.MAX_PACKET_SIZE,
+                },
+            }));
+            return;
+        }
+
+        const buf: Buffer = Buffer.allocUnsafe(length);
+
+        let offset: number = 0;
+
+        const recvAt = Date.now();
+
+        resp.on('error', (e) => this.emit('error', e));
+
+        req.on('error', (e) => this.emit('error', e))
+            .on('data', (chunk: Buffer) => {
+
+                const index = offset;
+
+                offset += chunk.byteLength;
+
+                if (offset > length) {
+
+                    refuseBadRequest(resp);
+                    this.emit('error', new Shared.errors.invalid_packet({
+                        reason: 'length_exceeded',
+                        recv: offset,
+                        expected: length,
+                    }));
+                    return;
+                }
+
+                chunk.copy(buf, index);
+            })
+            .on('end', () => {
+
+                let input: any;
+
+                if (offset !== length || buf[0] !== 123 || buf[offset - 1] !== 125) {
+
+                    refuseBadRequest(resp);
+                    return;
+                }
+
+                try {
+
+                    input = JSON.parse(buf as any);
+                }
+                catch (e) {
+
+                    refuseBadRequest(resp);
+                    this.emit('error', new Shared.errors.invalid_packet({
+                        reason: 'invalid_json',
+                        data: buf,
+                    }, e));
+                    return;
+                }
+
+                if (typeof input?.api !== 'string') {
+
+                    refuseBadRequest(resp);
+                    this.emit('error', new Shared.errors.invalid_packet({
+                        reason: 'malformed_json',
+                        data: input,
+                    }));
+                    return;
+                }
+
+                this._server.processLegacyApi((result) => {
+
+                    if (!resp.writable) {
+
+                        return;
+                    }
+
+                    if (result instanceof Shared.TelevokeError) {
+
+                        if (result instanceof Shared.errors.app_error) {
+
+                            const data = encoder.encodeApiErrorResponse(
+                                input.rid,
+                                v1.EResponseCode.FAILURE,
+                                result.message,
+                                recvAt
+                            );
+
+                            resp.setHeader('content-length', Buffer.byteLength(data));
+                            resp.end(data);
+                        }
+                        else if (result instanceof Shared.errors.api_not_found) {
+
+                            const data = encoder.encodeApiErrorResponse(
+                                input.rid,
+                                v1.EResponseCode.API_NOT_FOUND,
+                                'null',
+                                recvAt
+                            );
+
+                            resp.setHeader('content-length', Buffer.byteLength(data));
+                            resp.end(data);
+                        }
+                        else {
+
+                            const data = encoder.encodeApiErrorResponse(
+                                input.rid,
+                                v1.EResponseCode.SYSTEM_ERROR,
+                                'null',
+                                recvAt
+                            );
+
+                            resp.setHeader('content-length', Buffer.byteLength(data));
+                            resp.end(data);
+                        }
+
+                        return;
+                    }
+
+                    const data = encoder.encodeApiOkResponse(input.rid, result ?? null, recvAt);
+
+                    resp.setHeader('content-length', Buffer.byteLength(data));
+                    resp.end(data);
+
+                }, input.api, input.args, new LegacyHttpTransporter(req));
+            });
+    };
+
+    public async start(): Promise<void> {
+
+        if (this.running) {
+
+            return;
+        }
+
+        await this._listener.start();
+    }
+
+    public async stop(): Promise<void> {
+
+        if (!this.running) {
+
+            return Promise.resolve();
+        }
+
+        await this._listener.stop();
+    }
+}
+
+export function createLegacyHttpGateway(
+    listener: Listener.IHttpListener,
+    server: dT.IServer
+): dT.IGateway {
+
+    return new LegacyHttpGateway(listener, server);
+}

package/src/lib/transporters/legacy-http/LegacyHttp.Transporter.ts

@@ -0,0 +1,66 @@
+/**
+* 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 Http from 'node:http';
+import type * as Shared from '../../shared';
+
+const PROPERTY_NAMES = ['remoteAddress', 'remotePort', 'localAddress', 'localPort', 'url', 'headers'];
+
+export class LegacyHttpTransporter implements Shared.ITransporter {
+
+    public readonly protocol = 'http';
+
+    public constructor(
+        private readonly _req: Http.IncomingMessage,
+    ) {
+
+    }
+
+    public readonly writable = false;
+
+    public getPropertyNames(): string[] {
+
+        return PROPERTY_NAMES;
+    }
+
+    public getAllProperties(): Record<string, unknown> {
+
+        return {
+            'remoteAddress': this._req.socket.remoteAddress,
+            'remotePort': this._req.socket.remotePort,
+            'localAddress': this._req.socket.localAddress,
+            'localPort': this._req.socket.localPort,
+            'url': this._req.url,
+            'headers': this._req.headers,
+        };
+    }
+
+    public getProperty(name: string): unknown {
+
+        switch (name) {
+            case 'localPort':
+            case 'localAddress':
+            case 'remotePort':
+            case 'remoteAddress':
+                return this._req.socket[name];
+            case 'url':
+            case 'headers':
+                return this._req[name];
+            default:
+                return undefined;
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+/**
+* 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 './LegacyHttp.Server';
+export * from './LegacyHttp.Transporter';

package/src/lib/transporters/lwdfx/LwDFX.Tcp.Client.ts

@@ -0,0 +1,34 @@
+/**
+* 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 LwDFX from '@litert/lwdfx';
+import type * as dT from '../Transporter.decl';
+import { LwDFXTransporter } from './LwDFX.Transporter';
+
+class LwDfxTcpConnector implements dT.IConnector {
+
+    public constructor(private readonly _opts: LwDFX.Tcp.ITcpClientOptions) {}
+
+    public async connect(): Promise<dT.ITransporter> {
+
+        return new LwDFXTransporter('lwdfx/tcp', await LwDFX.Tcp.connect(this._opts));
+    }
+}
+
+export function createTcpConnector(opts: LwDFX.Tcp.ITcpClientOptions): dT.IConnector {
+
+    return new LwDfxTcpConnector(opts);
+}

package/src/lib/transporters/lwdfx/LwDFX.Tcp.Server.ts

@@ -0,0 +1,94 @@
+/**
+* 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 LwDFX from '@litert/lwdfx';
+import type * as dT from '../Transporter.decl';
+import { EventEmitter } from 'node:events';
+import { LwDFXTransporter } from './LwDFX.Transporter';
+import type * as dL from './LwDFX.decl';
+
+export type ILwDfxTcpGatewayOptions = LwDFX.Tcp.ITcpGatewayOptions;
+
+class LwDfxTcpGateway extends EventEmitter implements dT.IGateway {
+
+    private _gateway: LwDFX.Tcp.ITcpGateway | null = null;
+
+    private readonly _lwdfxServer: LwDFX.IServer;
+
+    public constructor(
+        serverOpts: dL.ILwDfxServerOptions,
+        private readonly _gatewayOpts: ILwDfxTcpGatewayOptions,
+        private readonly _server: dT.IServer,
+    ) {
+
+        super();
+
+        this._lwdfxServer = LwDFX.createServer({
+            ...serverOpts,
+            alpWhitelist: ['televoke2']
+        });
+
+        this._lwdfxServer.on('connection', (conn) => {
+
+            this._server.registerChannel(new LwDFXTransporter('lwdfx/tcp', conn));
+        });
+    }
+
+    public get running(): boolean {
+
+        return !!this._gateway;
+    }
+
+    public async start(): Promise<void> {
+
+        if (this._gateway) {
+
+            return;
+        }
+
+        this._gateway = LwDFX.Tcp.createGateway(this._lwdfxServer, this._gatewayOpts);
+
+        try {
+
+            await this._gateway.start();
+        }
+        catch (e) {
+
+            this._gateway = null;
+            throw e;
+        }
+    }
+
+    public async stop(): Promise<void> {
+
+        if (!this._gateway) {
+
+            return;
+        }
+
+        await this._gateway.stop();
+        this._gateway = null;
+    }
+}
+
+export function createTcpGateway(
+    server: dT.IServer,
+    gatewayOpts: ILwDfxTcpGatewayOptions = {},
+    serverOpts: dL.ILwDfxServerOptions = {},
+): dT.IGateway {
+
+    return new LwDfxTcpGateway(serverOpts, gatewayOpts, server);
+}

package/src/lib/transporters/lwdfx/LwDFX.Tls.Client.ts

@@ -0,0 +1,34 @@
+/**
+* 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 LwDFX from '@litert/lwdfx';
+import type * as dT from '../Transporter.decl';
+import { LwDFXTransporter } from './LwDFX.Transporter';
+
+class LwDfxTlsConnector implements dT.IConnector {
+
+    public constructor(private readonly _opts: LwDFX.Tls.ITlsClientOptions) {}
+
+    public async connect(): Promise<dT.ITransporter> {
+
+        return new LwDFXTransporter('lwdfx/tls', await LwDFX.Tls.connect(this._opts));
+    }
+}
+
+export function createTlsConnector(opts: LwDFX.Tls.ITlsClientOptions): dT.IConnector {
+
+    return new LwDfxTlsConnector(opts);
+}

package/src/lib/transporters/lwdfx/LwDFX.Tls.Server.ts

@@ -0,0 +1,94 @@
+/**
+* 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 LwDFX from '@litert/lwdfx';
+import type * as dT from '../Transporter.decl';
+import type * as dL from './LwDFX.decl';
+import { EventEmitter } from 'node:events';
+import { LwDFXTransporter } from './LwDFX.Transporter';
+
+export type ILwDfxTlsGatewayOptions = LwDFX.Tls.ITlsGatewayOptions;
+
+class LwDfxTlsGateway extends EventEmitter implements dT.IGateway {
+
+    private _gateway: LwDFX.Tls.ITlsGateway | null = null;
+
+    private readonly _lwdfxServer: LwDFX.IServer;
+
+    public constructor(
+        serverOpts: dL.ILwDfxServerOptions,
+        private readonly _gatewayOpts: ILwDfxTlsGatewayOptions,
+        private readonly _server: dT.IServer,
+    ) {
+
+        super();
+
+        this._lwdfxServer = LwDFX.createServer({
+            ...serverOpts,
+            alpWhitelist: ['televoke2']
+        });
+
+        this._lwdfxServer.on('connection', (conn) => {
+
+            this._server.registerChannel(new LwDFXTransporter('lwdfx/tls', conn));
+        });
+    }
+
+    public get running(): boolean {
+
+        return !!this._gateway;
+    }
+
+    public async start(): Promise<void> {
+
+        if (this._gateway) {
+
+            return;
+        }
+
+        this._gateway = LwDFX.Tls.createGateway(this._lwdfxServer, this._gatewayOpts);
+
+        try {
+
+            await this._gateway.start();
+        }
+        catch (e) {
+
+            this._gateway = null;
+            throw e;
+        }
+    }
+
+    public async stop(): Promise<void> {
+
+        if (!this._gateway) {
+
+            return;
+        }
+
+        await this._gateway.stop();
+        this._gateway = null;
+    }
+}
+
+export function createTlsGateway(
+    server: dT.IServer,
+    gatewayOpts: ILwDfxTlsGatewayOptions,
+    serverOpts: dL.ILwDfxServerOptions = {},
+): dT.IGateway {
+
+    return new LwDfxTlsGateway(serverOpts, gatewayOpts, server);
+}

package/src/lib/transporters/lwdfx/LwDFX.Transporter.ts

@@ -0,0 +1,100 @@
+/**
+* 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 LwDFX from '@litert/lwdfx';
+import * as Shared from '../../shared';
+import type * as dT from '../Transporter.decl';
+import { EventEmitter } from 'node:events';
+
+const PROPERTY_NAMES = ['remoteAddress', 'remotePort', 'localAddress', 'localPort'];
+
+export class LwDFXTransporter extends EventEmitter implements dT.ITransporter, Shared.ITransporter {
+
+    public constructor(
+        public readonly protocol: string,
+        protected readonly _conn: LwDFX.IConnection
+    ) {
+        super();
+
+        this._conn
+            .on('end', () => this.emit('end'))
+            .on('finish', () => this.emit('finish'))
+            .on('frame', (data) => this.emit('frame', data))
+            .on('error', (e) => this.emit('error', e))
+            .on('close', () => this.emit('close'));
+    }
+
+    public destroy(): void {
+
+        this._conn.destroy();
+    }
+
+    public getPropertyNames(): string[] {
+
+        return PROPERTY_NAMES;
+    }
+
+    public getAllProperties(): Record<string, unknown> {
+
+        return {
+            'remoteAddress': this._conn.remoteAddress,
+            'remotePort': this._conn.remotePort,
+            'localAddress': this._conn.localAddress,
+            'localPort': this._conn.localPort,
+        };
+    }
+
+    public getProperty(name: string): unknown {
+
+        switch (name) {
+            case 'localPort':
+            case 'localAddress':
+            case 'remotePort':
+            case 'remoteAddress':
+                return this._conn[name];
+            default:
+                return undefined;
+        }
+    }
+
+    public get writable(): boolean {
+
+        return this._conn.connected;
+    }
+
+    public write(frame: string | Buffer | Array<string | Buffer>): void {
+
+        if (!this._conn.writable) {
+
+            throw new Shared.errors.network_error({ reason: 'conn_lost' });
+        }
+
+        this._conn.write(frame);
+    }
+
+    public end(frame?: Buffer | string): void {
+
+        if (this._conn.writable) {
+
+            if (frame) {
+
+                this._conn.write(frame);
+            }
+
+            this._conn.end();
+        }
+    }
+}