@litert/televoke 0.4.7 → 1.0.0-1

package/src/lib/client/LegacyHttpClient.impl.ts

@@ -0,0 +1,278 @@
+/**
+* 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 'http';
+import * as $Https from 'https';
+import * as C from './Client.decl';
+import * as Shared from '../shared';
+import * as v1 from '../shared/Encodings/v1';
+import { EventEmitter } from 'node:events';
+
+const HTTP_HEADER_CONTENT_LENGTH = 'content-length';
+const HTTP_HEADER_TV_VER = 'x-tv-ver';
+
+const DEFAULT_TIMEOUT = 30_000;
+
+const disabledStreamManager = Shared.createDisabledStreamManagerFactory()(null as any);
+
+class TvLegacyHttpClient extends EventEmitter implements C.IClient<any> {
+
+    public onError!: any;
+
+    public constructor(
+        private readonly _request: (opts: any, cb: (resp: $Http.IncomingMessage) => void) => $Http.ClientRequest,
+        private readonly _opts: $Https.RequestOptions,
+        private readonly _agent: $Http.Agent,
+        private readonly _apiNameWrapper?: (name: string) => string
+    ) {
+
+        super();
+    }
+
+    public get timeout(): number {
+
+        return this._opts.timeout ?? DEFAULT_TIMEOUT;
+    }
+
+    public get streams(): Shared.IStreamManager {
+
+        return disabledStreamManager;
+    }
+
+    public readonly writable: boolean = true;
+
+    public readonly ended: boolean = false;
+
+    public readonly finished: boolean = false;
+
+    public readonly transporter = null;
+
+    public sendBinaryChunk(): Promise<void> {
+
+        return Promise.reject(new Shared.errors.cmd_not_impl());
+    }
+
+    public sendMessage(): Promise<void> {
+
+        return Promise.reject(new Shared.errors.cmd_not_impl());
+    }
+
+    public ping(): Promise<Buffer> {
+
+        return Promise.reject(new Shared.errors.cmd_not_impl());
+    }
+
+    public invoke(api: any, ...args: any[]): Promise<any> {
+
+        const CST = Date.now();
+
+        const content = JSON.stringify({
+            ttl: this._opts.timeout ?? DEFAULT_TIMEOUT,
+            rid: 0,
+            cst: CST,
+            args,
+            api: this._apiNameWrapper ? this._apiNameWrapper(api) : api
+        });
+
+        return new Promise((resolve, reject) => {
+
+            const length = Buffer.byteLength(content);
+
+            if (length > v1.MAX_PACKET_SIZE) {
+
+                reject(new Shared.errors.invalid_packet({ reason: 'packet_too_large' }));
+                return;
+            }
+
+            const req = this._request({
+                ...this._opts,
+                agent: this._agent,
+                method: 'POST',
+                headers: {
+                    ...this._opts.headers,
+                    [HTTP_HEADER_CONTENT_LENGTH]: Buffer.byteLength(content),
+                    [HTTP_HEADER_TV_VER]: 1
+                },
+            }, (resp) => {
+
+                if (!resp.headers[HTTP_HEADER_CONTENT_LENGTH]) {
+
+                    reject(new Shared.errors.invalid_response());
+                    return;
+                }
+
+                const length = parseInt(resp.headers[HTTP_HEADER_CONTENT_LENGTH]);
+
+                if (!Number.isSafeInteger(length) || length > v1.MAX_PACKET_SIZE) { // Maximum request packet is 64MB
+
+                    reject(new Shared.errors.invalid_packet({ reason: 'packet_too_large' }));
+                    return;
+                }
+
+                const buf = Buffer.allocUnsafe(length);
+
+                let offset: number = 0;
+
+                resp.on('data', (chunk: Buffer) => {
+
+                    const index = offset;
+
+                    offset += chunk.byteLength;
+
+                    if (offset > length) {
+
+                        resp.removeAllListeners('end');
+                        resp.removeAllListeners('data');
+                        resp.destroy();
+
+                        reject(new Shared.errors.invalid_packet({ reason: 'packet_length_mismatched' }));
+                        return;
+                    }
+
+                    chunk.copy(buf, index);
+
+                }).on('end', () => {
+
+                    let data: v1.IResponsePayloadV1;
+
+                    try {
+
+                        data = JSON.parse(buf as any);
+                    }
+                    catch (e) {
+
+                        reject(new Shared.errors.invalid_response({
+                            reason: 'invalid_json',
+                            raw: buf
+                        }, e));
+                        return;
+                    }
+
+                    switch (data.code) {
+                        case v1.EResponseCode.OK:
+                            resolve(data.body);
+                            break;
+                        case v1.EResponseCode.FAILURE:
+                            reject(new Shared.TvErrorResponse(data.body));
+                            break;
+                        case v1.EResponseCode.API_NOT_FOUND:
+                            reject(new Shared.errors.api_not_found({ api }));
+                            break;
+                        case v1.EResponseCode.MALFORMED_ARGUMENTS:
+                        case v1.EResponseCode.SYSTEM_ERROR:
+                        default:
+                            reject(new Shared.errors.unknown({
+                                api, ...data
+                            }));
+                            break;
+                    }
+                });
+            });
+
+            req.once('timeout', () => {
+                reject(new Shared.errors.timeout({
+                    metadata: { api, time: Date.now(), details: null }
+                }));
+            });
+
+            req.once('error', reject);
+
+            req.end(content);
+        });
+    }
+
+    public connect(): Promise<void> {
+
+        return Promise.resolve();
+    }
+
+    public close(): Promise<void> {
+
+        this._agent.destroy();
+
+        return Promise.resolve();
+    }
+}
+
+export interface IHttpClientNetworkOptions extends $Https.RequestOptions {
+
+    /**
+     * Whether to use HTTPS.
+     *
+     * @default false
+     */
+    https?: boolean;
+
+    /**
+     * The hostname of HTTP server.
+     *
+     * @default 'localhost'
+     */
+    hostname: string;
+
+    /**
+     * The port of HTTP server.
+     *
+     * @default 80 or 443
+     */
+    port?: number;
+
+    /**
+     * The path to the RPC entry.
+     *
+     * @default '/'
+     */
+    path?: string;
+
+    apiNameWrapper?: (name: string) => string;
+}
+
+export interface IHttpClientUnixSocketOptions extends $Https.RequestOptions {
+
+    /**
+     * Whether to use HTTPS.
+     *
+     * > Always `false` for Unix domain socket.
+     */
+    https?: false;
+
+    /**
+     * The path of Unix domain socket to connect to.
+     */
+    socketPath: string;
+
+    apiNameWrapper?: (name: string) => string;
+}
+
+export type IHttpClientOptions = IHttpClientNetworkOptions | IHttpClientUnixSocketOptions;
+
+export function createLegacyHttpClient<TAPIs extends Shared.IObject>(opts: IHttpClientOptions): C.IClient<TAPIs> {
+
+    return new TvLegacyHttpClient(
+        opts.https ? $Https.request : $Http.request,
+        opts,
+        opts.https ? new $Https.Agent({
+            maxSockets: 0,
+            keepAlive: true,
+            keepAliveMsecs: DEFAULT_TIMEOUT
+        }) : new $Http.Agent({
+            maxSockets: 0,
+            keepAlive: true,
+            keepAliveMsecs: DEFAULT_TIMEOUT
+        }),
+        opts.apiNameWrapper
+    );
+}

package/src/lib/client/index.ts

@@ -0,0 +1,19 @@
+/**
+* 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 './Client.decl';
+export * from './JsonApiClient.impl';
+export * from './LegacyHttpClient.impl';

package/src/lib/index.ts

@@ -1,22 +1,20 @@
 /**
- * Copyright 2021 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.
- */
+* 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 './Common';
-export * from './Encoder/Encoder';
-export * from './Encoder/Decoder';
-export * from './Server';
-export * from './Errors';
-export * from './Client';
+export * from './shared';
+export * as Servers from './server';
+export * as Clients from './client';
+export * as Gateways from './transporters';

package/src/lib/server/LegacyServerChannel.impl.ts

@@ -0,0 +1,71 @@
+/**
+* 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 Shared from '../shared';
+import { EventEmitter } from 'node:events';
+import * as v2 from '../shared/Encodings/v2';
+
+export type ILegacyApiResponseCallback = (body: v2.IDataChunkField | Shared.TelevokeError) => void;
+
+const streamManager = Shared.createDisabledStreamManagerFactory()(null as any);
+
+export class TvLegacyServerChannelV1 extends EventEmitter implements Shared.IChannelBase<Shared.IDefaultEvents> {
+
+    public get context(): Record<string, unknown> { return {}; }
+
+    public get ended(): boolean { return false; }
+
+    public get finished(): boolean { return false; }
+
+    public get writable(): boolean { return false; }
+
+    public get id(): number { return 0; }
+
+    public get timeout(): number { return 30_000; }
+
+    public get streams(): Shared.IStreamManager { return streamManager; }
+
+    public constructor(
+        public readonly transporter: Shared.ITransporter
+    ) {
+        super();
+    }
+
+    public openBinaryStream(): Shared.IBinaryReadStream {
+
+        throw new Shared.errors.cmd_not_impl();
+    }
+
+    public ping(): Promise<Buffer> {
+
+        return Promise.reject(new Shared.errors.cmd_not_impl());
+    }
+
+    public sendBinaryChunk(): Promise<void> {
+
+        return Promise.reject(new Shared.errors.cmd_not_impl());
+    }
+
+    public sendMessage(): Promise<void> {
+
+        return Promise.reject(new Shared.errors.cmd_not_impl());
+    }
+
+    public close(): void {
+
+        return;
+    }
+}

package/src/lib/server/Server.decl.ts

@@ -0,0 +1,109 @@
+/**
+* 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 Shared from '../shared';
+
+export interface IChannelEvents extends Shared.IDefaultEvents {
+
+    close(): void;
+}
+
+export interface IChannel extends Shared.IChannelBase<IChannelEvents> {
+
+    /**
+     * The channel id.
+     */
+    readonly id: number;
+}
+
+export interface IRequestContext {
+
+    /**
+     * The channel which the request comes from.
+     */
+    readonly channel: IChannel;
+}
+
+export type IRouteApiCallback = (response: string | Buffer | Array<string | Buffer> | Shared.TelevokeError) => void;
+
+export type IRouteLegacyApiCallback = (response: unknown | Shared.TvErrorResponse | Shared.TelevokeError) => void;
+
+export interface IRouter {
+
+    /**
+     * The encoding of the API request/response.
+     */
+    readonly encoding: string;
+
+    /**
+     * Process an API call.
+     *
+     * @param cb        The callback function of processing result.
+     * @param name      The API name.
+     * @param args      The API arguments.
+     * @param context   The request context.
+     */
+    processApi(
+        cb: IRouteApiCallback,
+        name: string,
+        args: Buffer[],
+        context: IRequestContext
+    ): void;
+
+    /**
+     * Process an API call from legacy client.
+     *
+     * @param cb        The callback function of processing result.
+     * @param name      The API name.
+     * @param args      The API arguments.
+     * @param context   The request context.
+     */
+    processLegacyApi(
+        cb: IRouteLegacyApiCallback,
+        name: string,
+        args: unknown,
+        context: IRequestContext
+    ): void;
+}
+
+export interface IServerEvents extends Shared.IDefaultEvents {
+
+    channel(channel: IChannel): void;
+}
+
+export interface IServer extends Shared.IEventListener<IServerEvents> {
+
+    readonly router: IRouter;
+
+    /**
+     * The timeout for waiting replies of each command sent to the remote endpoint, in milliseconds.
+     *
+     * @default 60000
+     */
+    timeout: number;
+
+    /**
+     * Get the channel object by Id.
+     *
+     * @param channelId     The channel Id.
+     */
+    getChannel(channelId: string): IChannel | null;
+
+    /**
+     * Get the Id list of all alive channels.
+     */
+    getChannelIdList(): string[];
+}

package/src/lib/server/Server.impl.ts

@@ -0,0 +1,90 @@
+/**
+* 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 dS from './Server.decl';
+import * as Shared from '../shared';
+import type * as dT from '../transporters/Transporter.decl';
+import { EventEmitter } from 'node:events';
+import { IChannelEvents } from '../shared/Channel.impl';
+import { TvServerChannelV2 } from './ServerChannel';
+import { TvLegacyServerChannelV1 } from './LegacyServerChannel.impl';
+
+let nextChId = Date.now();
+
+export class TvServer extends EventEmitter implements dS.IServer, dT.IServer {
+
+    private readonly _channels: Record<string, dS.IChannel> = {};
+
+    public timeout = 60_000;
+
+    public constructor(
+        public router: dS.IRouter,
+        private readonly _streamManagerFactory: Shared.IStreamManagerFactory = Shared.createSharedStreamManagerFactory()
+    ) {
+        super();
+    }
+
+    public setRouter(router: dS.IRouter): void {
+
+        this.router = router;
+    }
+
+    public registerChannel(transporter: dT.ITransporter): void {
+
+        const id = nextChId++;
+
+        this._channels[id] = new TvServerChannelV2(
+            id,
+            transporter as any,
+            this.timeout,
+            this._streamManagerFactory
+        );
+
+        (this._channels[id] as Shared.IChannelBase<IChannelEvents>)
+            .on('api_call', (cb, name, body) => {
+                this.router.processApi(cb, name, body, {
+                    channel: this._channels[id],
+                });
+            })
+            .on('error', (err) => this.emit('error', err))
+            .on('close', () => { delete this._channels[id]; });
+    }
+
+    public processLegacyApi(
+        callback: dT.ILegacyApiResponseCallback,
+        name: string,
+        args: unknown,
+        transporter: Shared.ITransporter
+    ): void {
+
+        this.router.processLegacyApi(
+            callback,
+            name,
+            args,
+            { 'channel': new TvLegacyServerChannelV1(transporter) }
+        );
+    }
+
+    public getChannel(id: string): dS.IChannel | null {
+
+        return this._channels[id] ?? null;
+    }
+
+    public getChannelIdList(): string[] {
+
+        return Object.keys(this._channels);
+    }
+}

package/src/lib/server/ServerChannel.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.
+*/
+
+import type * as dS from './Server.decl';
+import { AbstractTvChannelV2 } from '../shared/Channel.impl';
+
+export class TvServerChannelV2 extends AbstractTvChannelV2 implements dS.IChannel {}