@litert/televoke 0.4.6 → 1.0.0-0

package/src/lib/server/SimpleJsonApiRouter.ts

@@ -0,0 +1,135 @@
+/**
+* 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 { buffer2json } from '../shared/Utils';
+
+export type ISimpleJsonApiHandler = (ctx: dS.IRequestContext, ...args: any[]) => unknown;
+
+export type ISimpleJsonMessageHandler = (ctx: dS.IRequestContext, msg: unknown) => unknown;
+
+export class SimpleJsonApiRouter implements dS.IRouter {
+
+    public get encoding(): string {
+
+        return 'json';
+    }
+
+    private readonly _apiHandlers: Record<string, ISimpleJsonApiHandler> = {};
+
+    public registerApi(name: string, callback: ISimpleJsonApiHandler): this {
+
+        this._apiHandlers[name] = callback;
+
+        return this;
+    }
+
+    public processApi(cb: dS.IRouteApiCallback, name: string, body: Buffer[], ctx: dS.IRequestContext): void {
+
+        if (!this._apiHandlers[name]) {
+            cb(new Shared.errors.api_not_found({ name }));
+            return;
+        }
+
+        let args: unknown;
+
+        try {
+
+            args = buffer2json(body);
+        }
+        catch (err) {
+
+            cb(new Shared.errors.invalid_packet({ reason: 'invalid_json' }, err));
+        }
+
+        try {
+
+            const result = Array.isArray(args) ?
+                this._apiHandlers[name](ctx, ...args) :
+                this._apiHandlers[name](ctx, args);
+
+            if (result instanceof Promise) {
+
+                result.then(
+                    (data) => { cb(JSON.stringify(data)); },
+                    (e) => { this._processError(cb, e); },
+                );
+            }
+            else {
+
+                cb(JSON.stringify(result ?? null));
+            }
+        }
+        catch (e) {
+
+            this._processError(cb, e);
+        }
+    }
+
+    private _processError(cb: dS.IRouteApiCallback, e: unknown): void {
+
+        if (e instanceof Shared.TelevokeError) {
+
+            cb(e);
+            return;
+        }
+
+        if (e instanceof Shared.TvErrorResponse) {
+
+            cb(new Shared.errors.app_error(JSON.stringify(e.data)));
+            return;
+        }
+
+        cb(new Shared.errors.app_error('null'));
+    }
+
+    public processLegacyApi(
+        cb: dS.IRouteLegacyApiCallback,
+        name: string,
+        args: unknown,
+        ctx: dS.IRequestContext
+    ): void {
+
+        if (!this._apiHandlers[name]) {
+            cb(new Shared.errors.api_not_found({ name }));
+            return;
+        }
+
+        try {
+
+            const result = Array.isArray(args) ?
+                this._apiHandlers[name](ctx, ...args) :
+                this._apiHandlers[name](ctx, args);
+
+            if (result instanceof Promise) {
+
+                result.then(
+                    (data) => { cb(data); },
+                    (e) => { this._processError(cb, e); },
+                );
+            }
+            else {
+
+                cb(result ?? null);
+            }
+        }
+        catch (e) {
+
+            this._processError(cb, e);
+        }
+    }
+}

package/src/lib/server/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 './Server.decl';
+export * from './Server.impl';
+export * from './SimpleJsonApiRouter';

package/src/lib/shared/BinaryStream.ts

@@ -0,0 +1,131 @@
+/**
+* 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.decl';
+import * as E from './Errors';
+import { Readable } from 'node:stream';
+
+export class TvBinaryReadStream extends Readable implements Shared.IBinaryReadStream {
+
+    private _timer: NodeJS.Timeout | null = null;
+
+    public constructor(
+        public readonly id: number,
+        private _timeout: number = 0,
+    ) {
+
+        super();
+
+        if (_timeout > 0) {
+
+            this._resetTimer();
+        }
+    }
+
+    public setTimeout(timeout: number): void {
+
+        if (timeout === this._timeout) {
+
+            return;
+        }
+
+        this._timeout = timeout;
+
+        if (timeout > 0) {
+
+            if (this._timer) {
+
+                clearTimeout(this._timer);
+                this._timer = null;
+            }
+
+            this._resetTimer();
+        }
+    }
+
+    private _resetTimer(): void {
+
+        if (this.readableEnded) {
+
+            if (this._timer) {
+                clearTimeout(this._timer);
+                this._timer = null;
+            }
+            return;
+        }
+
+        if (this._timer) {
+
+            this._timer.refresh();
+            return;
+        }
+
+        this._timer = setTimeout(() => {
+
+            if (this.readableEnded) {
+
+                return;
+            }
+
+            this._timer = null;
+
+            this.destroy(new E.errors.timeout());
+
+        }, this._timeout);
+    }
+
+    public push(buf: Buffer | null): boolean {
+
+        if (this.readableEnded) {
+
+            throw new E.errors.stream_closed();
+        }
+
+        if (this._timeout > 0) {
+
+            this._resetTimer();
+        }
+
+        return super.push(buf);
+    }
+
+    public close(): void {
+
+        if (this._timer) {
+
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+
+        this.push(null);
+    }
+
+    public abort(): void {
+
+        if (this._timer) {
+
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+
+        this.destroy(new E.errors.stream_aborted());
+    }
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public _read(): void {
+        return;
+    }
+}

package/src/lib/shared/BinaryStreamManager.ts

@@ -0,0 +1,142 @@
+/**
+* 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.decl';
+import * as Constants from './Constants';
+import * as E from './Errors';
+import { TvBinaryReadStream } from './BinaryStream';
+
+export class TvBinaryStreamManager implements Shared.IStreamManager {
+
+    private _closed: boolean = false;
+
+    private readonly _streams: Record<string, TvBinaryReadStream> = {};
+
+    public constructor(
+        public defaultTimeout: number,
+        public maxStreams: number,
+    ) { }
+
+    private _generateStreamId(): number {
+
+        do {
+
+            const id = Math.floor(Math.random() * 0xFFFF_FFFF);
+
+            if (id in this._streams) {
+
+                continue;
+            }
+
+            return id;
+
+        } while (true);
+    }
+
+    public close(): void {
+
+        this._closed = true;
+
+        for (const id of Object.keys(this._streams)) {
+
+            this._streams[id].abort();
+            delete this._streams[id];
+        }
+    }
+
+    public get(id: number): Shared.IBinaryReadStream | null {
+
+        return this._streams[id] ?? null;
+    }
+
+    public create(): Shared.IBinaryReadStream {
+
+        if (this.maxStreams === 0) {
+
+            throw new E.errors.cmd_not_impl();
+        }
+        else if (this._closed) {
+
+            throw new E.errors.stream_closed();
+        }
+        else if (this.maxStreams >= 0 && Object.keys(this._streams).length === this.maxStreams) {
+
+            throw new E.errors.system_busy();
+        }
+
+        const stream = new TvBinaryReadStream(this._generateStreamId(), this.defaultTimeout);
+
+        this._streams[stream.id] = stream.on('close', () => {
+
+            delete this._streams[stream.id];
+        });
+
+        return stream;
+    }
+}
+
+/**
+ * Create a factory function to create a `IStreamManager` instance, associated to a single channel.
+ * When the associated channel is closed, all streams insides the stream manager will be aborted.
+ *
+ * @param defaultTimeout    The default timeout value of each new binary stream.
+ * @returns                 The factory function.
+ */
+export function createChannelStreamManagerFactory(
+    defaultTimeout: number = Constants.DEFAULT_STREAM_TIMEOUT,
+    maxStreams: number = Constants.DEFAULT_MAX_STREAMS,
+): Shared.IStreamManagerFactory {
+
+    return (ch) => {
+
+        const ret = new TvBinaryStreamManager(defaultTimeout, maxStreams);
+
+        ch.on('close', () => { ret.close(); });
+
+        return ret;
+    };
+}
+
+/**
+ * Create a factory function to create a `IStreamManager` instance, shared between all channels.
+ * So that the streams created could be used in different channels.
+ *
+ * @param defaultTimeout    The default timeout value of each new binary stream.
+ * @returns                 The factory function.
+ */
+export function createSharedStreamManagerFactory(
+    defaultTimeout: number = Constants.DEFAULT_STREAM_TIMEOUT,
+    maxStreams: number = Constants.DEFAULT_MAX_STREAMS,
+): Shared.IStreamManagerFactory {
+
+    const ret = new TvBinaryStreamManager(defaultTimeout, maxStreams);
+
+    return () => ret;
+}
+
+/**
+ * Create a factory function to create a `IStreamManager` instance, disabling all binary streams.
+ *
+ * > This is useful when you don't need binary streams.
+ *
+ * @returns                 The factory function.
+ */
+export function createDisabledStreamManagerFactory(): Shared.IStreamManagerFactory {
+
+    const mgr = new TvBinaryStreamManager(0, 0);
+
+    return () => mgr;
+}