@tdengine/websocket 3.2.2 → 3.3.0

package/lib/test/helpers/wsFailoverProxy.js

@@ -0,0 +1,420 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsFailoverProxy = void 0;
+const http = __importStar(require("http"));
+const websocket_1 = require("websocket");
+const UPSTREAM_WS_URL = "ws://localhost:6041/ws";
+const SUPPORTED_PATH = "/ws";
+class WsFailoverProxy {
+    constructor(options) {
+        this._lockedPort = null;
+        this._httpServer = null;
+        this._wsServer = null;
+        this._running = false;
+        this._nextConnectionId = 1;
+        this._lifecycleChain = Promise.resolve();
+        this._tunnels = new Map();
+        this._eventLog = [];
+        if (!options.host || options.host.trim().length === 0) {
+            throw new Error("listen host must not be empty");
+        }
+        if (!Number.isInteger(options.port) ||
+            options.port < 0 ||
+            options.port > 65535) {
+            throw new Error(`invalid listen port: ${options.port}, expected 0-65535`);
+        }
+        this._listenHost = options.host;
+        this._requestedPort = options.port;
+        this._onEvent = options.onEvent;
+        this._control = {
+            restart: async (opts) => {
+                await this.restart(opts);
+            },
+            stop: async (reason) => {
+                await this.stop(reason);
+            },
+            isRunning: () => this.isRunning(),
+        };
+    }
+    static async create(options) {
+        const proxy = new WsFailoverProxy(options);
+        await proxy.start("initial start");
+        return proxy;
+    }
+    async start(reason) {
+        await this.enqueueLifecycle(async () => {
+            await this.startInternal(reason);
+        });
+    }
+    async stop(reason) {
+        await this.enqueueLifecycle(async () => {
+            await this.stopInternal(reason);
+        });
+    }
+    async restart(opts) {
+        await this.enqueueLifecycle(async () => {
+            const reason = opts?.reason || "restart";
+            const downtimeMs = Math.max(0, opts?.downtimeMs || 0);
+            await this.stopInternal(reason);
+            if (downtimeMs > 0) {
+                await sleep(downtimeMs);
+            }
+            await this.startInternal(reason);
+        });
+    }
+    isRunning() {
+        return this._running;
+    }
+    getPort() {
+        if (this._lockedPort === null) {
+            throw new Error("proxy has not started yet");
+        }
+        return this._lockedPort;
+    }
+    getHost() {
+        return this._listenHost;
+    }
+    getUrl() {
+        return `ws://${this._listenHost}:${this.getPort()}${SUPPORTED_PATH}`;
+    }
+    getEventLog() {
+        return [...this._eventLog];
+    }
+    async enqueueLifecycle(task) {
+        this._lifecycleChain = this._lifecycleChain.then(task, task);
+        await this._lifecycleChain;
+    }
+    async startInternal(reason) {
+        if (this._running) {
+            return;
+        }
+        const listenPort = this._lockedPort === null
+            ? this._requestedPort
+            : this._lockedPort;
+        const httpServer = http.createServer((_req, res) => {
+            res.statusCode = 404;
+            res.end();
+        });
+        await new Promise((resolve, reject) => {
+            const onError = (err) => {
+                httpServer.removeListener("listening", onListening);
+                reject(err);
+            };
+            const onListening = () => {
+                httpServer.removeListener("error", onError);
+                resolve();
+            };
+            httpServer.once("error", onError);
+            httpServer.once("listening", onListening);
+            httpServer.listen(listenPort, this._listenHost);
+        });
+        const address = httpServer.address();
+        if (!address || typeof address === "string") {
+            httpServer.close();
+            throw new Error("failed to get proxy listen address");
+        }
+        if (this._lockedPort === null) {
+            this._lockedPort = address.port;
+        }
+        const wsServer = new websocket_1.server({
+            httpServer,
+            autoAcceptConnections: false,
+        });
+        wsServer.on("request", (request) => {
+            this.handleClientRequest(request);
+        });
+        this._httpServer = httpServer;
+        this._wsServer = wsServer;
+        this._running = true;
+        this.emitEvent({
+            type: "proxy_started",
+            timestamp: Date.now(),
+            host: this._listenHost,
+            port: this.getPort(),
+            url: this.getUrl(),
+            reason,
+        });
+    }
+    async stopInternal(reason) {
+        if (!this._running && !this._httpServer && !this._wsServer) {
+            return;
+        }
+        this._running = false;
+        for (const tunnel of Array.from(this._tunnels.values())) {
+            this.closeTunnel(tunnel.id, `proxy stopping${reason ? `: ${reason}` : ""}`, "proxy");
+        }
+        if (this._wsServer) {
+            try {
+                this._wsServer.removeAllListeners("request");
+                this._wsServer.closeAllConnections();
+                this._wsServer.unmount();
+            }
+            catch (_err) {
+                // Ignore shutdown errors and continue releasing resources.
+            }
+        }
+        if (this._httpServer) {
+            await new Promise((resolve) => {
+                if (!this._httpServer || !this._httpServer.listening) {
+                    resolve();
+                    return;
+                }
+                this._httpServer.close(() => resolve());
+            });
+        }
+        this._wsServer = null;
+        this._httpServer = null;
+        this.emitEvent({
+            type: "proxy_stopped",
+            timestamp: Date.now(),
+            reason,
+        });
+    }
+    handleClientRequest(request) {
+        if (!this._running) {
+            request.reject(503, "proxy is not running");
+            return;
+        }
+        const path = request.resourceURL?.pathname || request.resource;
+        if (path !== SUPPORTED_PATH) {
+            request.reject(404, `unsupported path: ${path}`);
+            return;
+        }
+        const clientConn = request.accept(undefined, request.origin);
+        const connectionId = this._nextConnectionId;
+        this._nextConnectionId += 1;
+        const tunnel = {
+            id: connectionId,
+            closed: false,
+            messageSeq: 0,
+            clientConn,
+            pendingFrames: [],
+        };
+        this._tunnels.set(connectionId, tunnel);
+        this.emitEvent({
+            type: "client_connected",
+            timestamp: Date.now(),
+            connectionId,
+            path,
+            remoteAddress: request.remoteAddress,
+        });
+        clientConn.on("message", (message) => {
+            this.handleClientMessage(tunnel, message);
+        });
+        clientConn.on("close", (code, desc) => {
+            this.closeTunnel(connectionId, `client closed: ${code} ${desc}`, "client");
+        });
+        clientConn.on("error", (error) => {
+            this.emitError("client_error", error, connectionId);
+            this.closeTunnel(connectionId, `client error: ${error.message}`, "client");
+        });
+        this.connectUpstream(tunnel);
+    }
+    connectUpstream(tunnel) {
+        const upstreamClient = new websocket_1.client();
+        tunnel.upstreamClient = upstreamClient;
+        upstreamClient.on("connect", (upstreamConn) => {
+            if (tunnel.closed) {
+                upstreamConn.close();
+                return;
+            }
+            tunnel.upstreamConn = upstreamConn;
+            this.emitEvent({
+                type: "upstream_connected",
+                timestamp: Date.now(),
+                connectionId: tunnel.id,
+                upstreamUrl: UPSTREAM_WS_URL,
+            });
+            upstreamConn.on("message", (message) => {
+                this.handleUpstreamMessage(tunnel, message);
+            });
+            upstreamConn.on("close", (code, desc) => {
+                this.closeTunnel(tunnel.id, `upstream closed: ${code} ${desc}`, "upstream");
+            });
+            upstreamConn.on("error", (error) => {
+                this.emitError("upstream_error", error, tunnel.id);
+                this.closeTunnel(tunnel.id, `upstream error: ${error.message}`, "upstream");
+            });
+            this.flushPendingFrames(tunnel);
+        });
+        upstreamClient.on("connectFailed", (error) => {
+            this.emitError("upstream_connect_failed", error, tunnel.id);
+            this.closeTunnel(tunnel.id, `upstream connect failed: ${error.message}`, "upstream");
+        });
+        upstreamClient.connect(UPSTREAM_WS_URL);
+    }
+    handleClientMessage(tunnel, message) {
+        if (tunnel.closed) {
+            return;
+        }
+        if (message.type === "utf8") {
+            const rawData = message.utf8Data;
+            this.emitMessageEvent(tunnel, "client_to_upstream", false, rawData);
+            if (this.isConnected(tunnel.upstreamConn)) {
+                tunnel.upstreamConn.sendUTF(rawData);
+                return;
+            }
+            tunnel.pendingFrames.push({
+                isBinary: false,
+                data: rawData,
+            });
+            return;
+        }
+        const rawData = Buffer.from(message.binaryData);
+        this.emitMessageEvent(tunnel, "client_to_upstream", true, rawData);
+        if (this.isConnected(tunnel.upstreamConn)) {
+            tunnel.upstreamConn.sendBytes(rawData);
+            return;
+        }
+        tunnel.pendingFrames.push({
+            isBinary: true,
+            data: rawData,
+        });
+    }
+    handleUpstreamMessage(tunnel, message) {
+        if (tunnel.closed || !this.isConnected(tunnel.clientConn)) {
+            this.closeTunnel(tunnel.id, "client connection unavailable while forwarding upstream message", "client");
+            return;
+        }
+        if (message.type === "utf8") {
+            const rawData = message.utf8Data;
+            this.emitMessageEvent(tunnel, "upstream_to_client", false, rawData);
+            tunnel.clientConn.sendUTF(rawData);
+            return;
+        }
+        const rawData = Buffer.from(message.binaryData);
+        this.emitMessageEvent(tunnel, "upstream_to_client", true, rawData);
+        tunnel.clientConn.sendBytes(rawData);
+    }
+    flushPendingFrames(tunnel) {
+        if (!this.isConnected(tunnel.upstreamConn) || tunnel.closed) {
+            return;
+        }
+        while (tunnel.pendingFrames.length > 0) {
+            const frame = tunnel.pendingFrames.shift();
+            if (!frame) {
+                break;
+            }
+            if (frame.isBinary) {
+                tunnel.upstreamConn.sendBytes(frame.data);
+            }
+            else {
+                tunnel.upstreamConn.sendUTF(frame.data);
+            }
+        }
+    }
+    closeTunnel(connectionId, reason, source) {
+        const tunnel = this._tunnels.get(connectionId);
+        if (!tunnel || tunnel.closed) {
+            return;
+        }
+        tunnel.closed = true;
+        this._tunnels.delete(connectionId);
+        const isProxyInjectedFailure = source === "proxy";
+        this.safeCloseConnection(tunnel.clientConn, isProxyInjectedFailure);
+        this.safeCloseConnection(tunnel.upstreamConn, isProxyInjectedFailure);
+        this.emitEvent({
+            type: "tunnel_closed",
+            timestamp: Date.now(),
+            connectionId,
+            reason,
+            source,
+        });
+    }
+    isConnected(conn) {
+        return !!conn && conn.connected;
+    }
+    emitMessageEvent(tunnel, direction, isBinary, rawData) {
+        tunnel.messageSeq += 1;
+        this.emitEvent({
+            type: "message",
+            timestamp: Date.now(),
+            connectionId: tunnel.id,
+            direction,
+            isBinary,
+            byteLength: typeof rawData === "string"
+                ? Buffer.byteLength(rawData)
+                : rawData.byteLength,
+            rawData,
+            messageSeq: tunnel.messageSeq,
+        });
+    }
+    emitError(stage, error, connectionId, sourceEventType, details, notifyCallback = true) {
+        this.emitEvent({
+            type: "error",
+            timestamp: Date.now(),
+            connectionId,
+            error: normalizeError(error),
+            stage,
+            sourceEventType,
+            details,
+        }, notifyCallback);
+    }
+    emitEvent(event, notifyCallback = true) {
+        this._eventLog.push(event);
+        if (!notifyCallback || !this._onEvent) {
+            return;
+        }
+        void Promise.resolve(this._onEvent(event, this._control)).catch((err) => {
+            this.emitError("event_handler", err, event.connectionId, event.type, "event callback threw an error", false);
+        });
+    }
+    safeCloseConnection(conn, abnormal) {
+        try {
+            if (!this.isConnected(conn)) {
+                return;
+            }
+            if (abnormal) {
+                conn.close(1012, "proxy restart");
+                return;
+            }
+            conn.close();
+        }
+        catch (_err) {
+            // Ignore close failures.
+        }
+    }
+}
+exports.WsFailoverProxy = WsFailoverProxy;
+function normalizeError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    return new Error(String(error));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/lib/test/helpers/wsProxy.d.ts

@@ -0,0 +1,110 @@
+type WsProxyDirection = "client_to_upstream" | "upstream_to_client";
+type WsProxyEventType = "proxy_started" | "proxy_stopped" | "client_connected" | "upstream_connected" | "message" | "tunnel_closed" | "error";
+interface WsProxyEventBase {
+    type: WsProxyEventType;
+    timestamp: number;
+    connectionId?: number;
+}
+export interface WsProxyStartedEvent extends WsProxyEventBase {
+    type: "proxy_started";
+    host: string;
+    port: number;
+    url: string;
+    reason?: string;
+}
+export interface WsProxyStoppedEvent extends WsProxyEventBase {
+    type: "proxy_stopped";
+    reason?: string;
+}
+export interface WsProxyClientConnectedEvent extends WsProxyEventBase {
+    type: "client_connected";
+    connectionId: number;
+    path: string;
+    remoteAddress: string;
+}
+export interface WsProxyUpstreamConnectedEvent extends WsProxyEventBase {
+    type: "upstream_connected";
+    connectionId: number;
+    upstreamUrl: string;
+}
+export interface WsProxyMessageEvent extends WsProxyEventBase {
+    type: "message";
+    connectionId: number;
+    direction: WsProxyDirection;
+    isBinary: boolean;
+    byteLength: number;
+    rawData: Buffer | string;
+    messageSeq: number;
+}
+export interface WsProxyTunnelClosedEvent extends WsProxyEventBase {
+    type: "tunnel_closed";
+    connectionId: number;
+    reason: string;
+    source: "client" | "upstream" | "proxy";
+}
+export interface WsProxyErrorEvent extends WsProxyEventBase {
+    type: "error";
+    error: Error;
+    stage: string;
+    sourceEventType?: WsProxyEventType;
+    details?: string;
+}
+export type WsProxyEvent = WsProxyStartedEvent | WsProxyStoppedEvent | WsProxyClientConnectedEvent | WsProxyUpstreamConnectedEvent | WsProxyMessageEvent | WsProxyTunnelClosedEvent | WsProxyErrorEvent;
+export interface WsProxyControl {
+    restart(opts?: {
+        downtimeMs?: number;
+        reason?: string;
+    }): Promise<void>;
+    stop(reason?: string): Promise<void>;
+    isRunning(): boolean;
+}
+export type WsProxyEventHandler = (event: WsProxyEvent, control: WsProxyControl) => void | Promise<void>;
+export interface WsProxyOptions {
+    host: string;
+    port: number;
+    onEvent?: WsProxyEventHandler;
+}
+export declare class WsProxy {
+    private readonly _listenHost;
+    private readonly _requestedPort;
+    private _lockedPort;
+    private readonly _onEvent?;
+    private readonly _control;
+    private _httpServer;
+    private _wsServer;
+    private _running;
+    private _nextConnectionId;
+    private _lifecycleChain;
+    private readonly _tunnels;
+    private readonly _eventLog;
+    constructor(options: WsProxyOptions);
+    static create(options: WsProxyOptions): Promise<WsProxy>;
+    start(reason?: string): Promise<void>;
+    stop(reason?: string): Promise<void>;
+    restart(opts?: {
+        downtimeMs?: number;
+        reason?: string;
+    }): Promise<void>;
+    isRunning(): boolean;
+    getPort(): number;
+    getHost(): string;
+    getUrl(): string;
+    getEventLog(): WsProxyEvent[];
+    private enqueueLifecycle;
+    private startInternal;
+    private stopInternal;
+    private handleClientRequest;
+    private connectUpstream;
+    private buildUpstreamUrl;
+    private handleClientMessage;
+    private handleUpstreamMessage;
+    private flushPendingFrames;
+    private closeTunnel;
+    private isConnected;
+    private emitMessageEvent;
+    private emitError;
+    private emitEvent;
+    private safeCloseConnection;
+}
+export {};
+//# sourceMappingURL=wsProxy.d.ts.map

package/lib/test/helpers/wsProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsProxy.d.ts","sourceRoot":"","sources":["../../../test/helpers/wsProxy.ts"],"names":[],"mappings":"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"}