@tdengine/websocket 3.2.2 → 3.3.0

package/lib/src/tmq/wsTmq.js

@@ -13,27 +13,32 @@ const tmqResponse_1 = require("./tmqResponse");
 const reqid_1 = require("../common/reqid");
 const log_1 = __importDefault(require("../common/log"));
 const wsResponse_1 = require("../client/wsResponse");
+const utils_1 = require("../common/utils");
+const constant_2 = require("../common/constant");
 class WsConsumer {
     constructor(wsConfig) {
-        this._wsConfig = new config_1.TmqConfig(wsConfig);
-        log_1.default.debug(this._wsConfig);
-        if (wsConfig.size == 0 || !this._wsConfig.url) {
+        this._config = new config_1.TmqConfig(wsConfig);
+        if (log_1.default.isDebugEnabled()) {
+            log_1.default.debug("WsConsumer config: " + (0, utils_1.maskTmqConfigForLog)(this._config));
+        }
+        if (wsConfig.size == 0 || !this._config.dsn) {
             throw new wsError_1.WebSocketInterfaceError(wsError_1.ErrorCode.ERR_INVALID_URL, "invalid url, password or username needed.");
         }
-        this._wsClient = new wsClient_1.WsClient(this._wsConfig.url, this._wsConfig.timeout);
+        this._wsClient = new wsClient_1.WsClient(this._config.dsn, this._config.timeout);
+        this.bindSessionRecoveryHook();
         this._lastMessageID = BigInt(0);
     }
     async init() {
         let wsSql = null;
         try {
-            if (this._wsConfig.sql_url) {
-                wsSql = new wsClient_1.WsClient(this._wsConfig.sql_url, this._wsConfig.timeout);
+            if (this._config.sqlDsn) {
+                wsSql = new wsClient_1.WsClient(this._config.sqlDsn, this._config.timeout);
                 await wsSql.connect();
                 await wsSql.checkVersion();
                 await this._wsClient.ready();
             }
             else {
-                throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `connection creation failed, url: ${this._wsConfig.url}`);
+                throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `connection creation failed, dsn: ${this._config.dsn}`);
             }
         }
         catch (e) {
@@ -49,32 +54,54 @@ class WsConsumer {
     }
     static async newConsumer(wsConfig) {
         if (wsConfig.size == 0 || !wsConfig.get(constant_1.TMQConstants.WS_URL)) {
-            throw new wsError_1.WebSocketInterfaceError(wsError_1.ErrorCode.ERR_INVALID_URL, "invalid url, password or username needed.");
+            throw new wsError_1.WebSocketInterfaceError(wsError_1.ErrorCode.ERR_INVALID_URL, "Invalid DSN");
         }
-        let wsConsumer = new WsConsumer(wsConfig);
+        const wsConsumer = new WsConsumer(wsConfig);
         return await wsConsumer.init();
     }
-    async subscribe(topics, reqId) {
-        if (!topics || topics.length == 0) {
-            throw new wsError_1.TaosResultError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "WsTmq Subscribe params is error!");
-        }
-        let queryMsg = {
+    bindSessionRecoveryHook() {
+        this._wsClient.setSessionRecoveryHook(async () => {
+            await this.recoverSessionContext();
+        });
+    }
+    buildSubscribeMessage(topics, reqId) {
+        const user = this._config.user === null
+            ? null
+            : (0, utils_1.safeDecodeURIComponent)(this._config.user);
+        const password = this._config.password === null
+            ? null
+            : (0, utils_1.safeDecodeURIComponent)(this._config.password);
+        return {
             action: constant_1.TMQMessageType.Subscribe,
             args: {
                 req_id: reqid_1.ReqId.getReqID(reqId),
-                user: this._wsConfig.user,
-                password: this._wsConfig.password,
-                group_id: this._wsConfig.group_id,
-                client_id: this._wsConfig.client_id,
+                user,
+                password,
+                group_id: this._config.group_id,
+                client_id: this._config.client_id,
                 topics: topics,
-                offset_rest: this._wsConfig.offset_rest,
-                auto_commit: this._wsConfig.auto_commit,
-                auto_commit_interval_ms: this._wsConfig.auto_commit_interval_ms,
-                config: this._wsConfig.otherConfigs,
+                offset_rest: this._config.offset_rest,
+                auto_commit: String(this._config.auto_commit),
+                auto_commit_interval_ms: String(this._config.auto_commit_interval_ms),
+                config: Object.fromEntries(this._config.otherConfigs),
+                connector: constant_2.ConnectorInfo,
             },
         };
-        this._topics = topics;
-        return await this._wsClient.exec(JSON.stringify(queryMsg));
+    }
+    async recoverSessionContext() {
+        if (!this._topics || this._topics.length === 0) {
+            return;
+        }
+        log_1.default.info(`Recovering TMQ session context, re-subscribing ${this._topics.length} topic(s).`);
+        await this._wsClient.sendMsgDirect(JSON.stringify(this.buildSubscribeMessage(this._topics)), false);
+    }
+    async subscribe(topics, reqId) {
+        if (!topics || topics.length == 0) {
+            throw new wsError_1.TaosResultError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "WsTmq Subscribe params is error!");
+        }
+        let queryMsg = this.buildSubscribeMessage(topics, reqId);
+        await this._wsClient.exec(JSON.stringify(queryMsg));
+        this._topics = [...topics];
     }
     async unsubscribe(reqId) {
         let queryMsg = {
@@ -83,14 +110,15 @@ class WsConsumer {
                 req_id: reqid_1.ReqId.getReqID(reqId),
             },
         };
-        return await this._wsClient.exec(JSON.stringify(queryMsg));
+        await this._wsClient.exec(JSON.stringify(queryMsg));
+        this._topics = undefined;
     }
     async poll(timeoutMs, reqId) {
-        if (this._wsConfig.auto_commit) {
+        if (this._config.auto_commit) {
             if (this._commitTime) {
                 let currTime = new Date().getTime();
                 let diff = Math.abs(currTime - this._commitTime);
-                if (diff >= this._wsConfig.auto_commit_interval_ms) {
+                if (diff >= this._config.auto_commit_interval_ms) {
                     await this.doCommit();
                     this._commitTime = new Date().getTime();
                 }

package/lib/test/bulkPulling/a.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=a.test.d.ts.map

package/lib/test/bulkPulling/a.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a.test.d.ts","sourceRoot":"","sources":["../../../test/bulkPulling/a.test.ts"],"names":[],"mappings":""}

package/lib/test/bulkPulling/a.test.js

@@ -0,0 +1,166 @@
+"use strict";
+// import { w3cwebsocket } from "websocket";
+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 });
+// test("test ws", async () => {
+//     const conn = new w3cwebsocket(
+//         "ws://localhost:6041/ws",
+//         undefined,
+//         undefined,
+//         undefined,
+//         undefined,
+//         {
+//             maxReceivedFrameSize: 0x60000000,
+//             maxReceivedMessageSize: 0x60000000,
+//         }
+//     );
+//     conn.onopen = function () {
+//         console.log("websocket connection opened");
+//     };
+//     conn.onmessage = function (message) {
+//         console.log("Received message:", message.data);
+//     };
+//     conn.onerror = function (err: Error) {
+//         console.error(`webSocket connection failed, url: ${this.url}, error: ${err.message}`);
+//     };
+//     conn.onclose = function () {
+//         console.log("websocket connection closed");
+//     };
+//     // cannot call send() while not connected
+//     conn.send("hello world");
+//     conn.close();
+// });
+const websocket_1 = require("websocket");
+const utils_1 = require("../helpers/utils");
+const log_1 = __importStar(require("../../src/common/log"));
+(0, log_1.setLevel)("debug");
+function waitForOpen(conn, timeoutMs = 5000) {
+    if (conn.readyState === websocket_1.w3cwebsocket.OPEN) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            cleanup();
+            reject(new Error(`waitForOpen timeout after ${timeoutMs}ms`));
+        }, timeoutMs);
+        const cleanup = () => {
+            clearTimeout(timer);
+            conn.onopen = prevOpen;
+            conn.onerror = prevError;
+            conn.onclose = prevClose;
+        };
+        const prevOpen = conn.onopen;
+        const prevError = conn.onerror;
+        const prevClose = conn.onclose;
+        conn.onopen = function () {
+            prevOpen?.call(this);
+            cleanup();
+            resolve();
+        };
+        conn.onerror = function (err) {
+            prevError?.call(this, err);
+            cleanup();
+            reject(err);
+        };
+        conn.onclose = function (e) {
+            prevClose?.call(this, e);
+            cleanup();
+            reject(new Error(`socket closed before open: ${e.code} ${e.reason || ""}`.trim()));
+        };
+    });
+}
+function waitForClose(conn, timeoutMs = 5000) {
+    if (conn.readyState === websocket_1.w3cwebsocket.CLOSED) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            cleanup();
+            reject(new Error(`waitForClose timeout after ${timeoutMs}ms`));
+        }, timeoutMs);
+        const cleanup = () => {
+            clearTimeout(timer);
+            conn.onclose = prevClose;
+            conn.onerror = prevError;
+        };
+        const prevClose = conn.onclose;
+        const prevError = conn.onerror;
+        conn.onclose = function (e) {
+            prevClose?.call(this, e);
+            cleanup();
+            resolve();
+        };
+        conn.onerror = function (err) {
+            prevError?.call(this, err);
+            cleanup();
+            reject(err);
+        };
+    });
+}
+test("test ws", async () => {
+    const conn = new websocket_1.w3cwebsocket("ws://localhost:6041/ws", undefined, undefined, undefined, undefined, {
+        maxReceivedFrameSize: 0x60000000,
+        maxReceivedMessageSize: 0x60000000,
+    });
+    conn.onopen = function () {
+        console.log("websocket connection opened");
+    };
+    conn.onmessage = function (message) {
+        console.log("Received message:", message.data);
+    };
+    conn.onerror = function (err) {
+        console.error(`webSocket connection failed, url: ${this.url}, error: ${err.message}`);
+    };
+    conn.onclose = function (e) {
+        console.log("websocket connection closed, event", e);
+    };
+    await waitForOpen(conn);
+    // cannot call send() while not connected
+    conn.send("hello world");
+    // conn.close();
+    // await waitForClose(conn);
+    // restart taosadapter
+    console.log("Please restart taosadapter now...");
+    log_1.default.info("Please restart taosadapter now...");
+    await (0, utils_1.Sleep)(5000);
+    // cannot call send() while not connected
+    conn.send("hello world after close"); // should not throw, but will be ignored
+    await (0, utils_1.Sleep)(5000);
+}, 15000);
+test("test url", async () => {
+    const url = new URL("ws://user:pass@localhost:6041/dbname?param1=value1&param2=value2");
+    console.log("url", url);
+    console.log(url.port);
+});

package/lib/test/bulkPulling/cloud.tmq.test.js

@@ -6,13 +6,14 @@ const wsConnectorPool_1 = require("../../src/client/wsConnectorPool");
 const log_1 = require("../../src/common/log");
 const config_1 = require("../../src/common/config");
 const wsSql_1 = require("../../src/sql/wsSql");
+const utils_1 = require("../utils");
 beforeAll(async () => {
     const url = `wss://${process.env.TDENGINE_CLOUD_URL}?token=${process.env.TDENGINE_CLOUD_TOKEN}`;
     let wsSql = null;
     try {
         const conf = new config_1.WSConfig(url);
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
         wsSql = await wsSql_1.WsSql.open(conf);
         let sql = `INSERT INTO dmeters.d1001 USING dmeters.meters (groupid, location) TAGS(2, 'SanFrancisco')
             VALUES (NOW + 1a, 10.30000, 219, 0.31000) (NOW + 2a, 12.60000, 218, 0.33000) (NOW + 3a, 12.30000, 221, 0.31000)

package/lib/test/bulkPulling/decimal.test.js

@@ -13,8 +13,8 @@ let dropTopic = `DROP TOPIC IF EXISTS topic_decimal_test;`;
 (0, log_1.setLevel)("debug");
 beforeAll(async () => {
     let conf = new config_1.WSConfig(dns);
-    conf.setUser("root");
-    conf.setPwd("taosdata");
+    conf.setUser((0, utils_1.testUsername)());
+    conf.setPwd((0, utils_1.testPassword)());
     let wsSql = await wsSql_1.WsSql.open(conf);
     await wsSql.exec(dropTopic);
     await wsSql.exec("drop database if exists power");
@@ -58,8 +58,8 @@ describe("TDWebSocket.WsSql()", () => {
     jest.setTimeout(20 * 1000);
     test("insert recoder", async () => {
         let conf = new config_1.WSConfig(dns);
-        conf.setUser("root");
-        conf.setPwd("taosdata");
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
         let wsSql = await wsSql_1.WsSql.open(conf);
         let taosResult = await wsSql.exec("use power");
         console.log(taosResult);
@@ -96,8 +96,8 @@ describe("TDWebSocket.WsSql()", () => {
 test("normal Subscribe", async () => {
     let configMap = new Map([
         [constant_1.TMQConstants.GROUP_ID, "gId"],
-        [constant_1.TMQConstants.CONNECT_USER, "root"],
-        [constant_1.TMQConstants.CONNECT_PASS, "taosdata"],
+        [constant_1.TMQConstants.CONNECT_USER, (0, utils_1.testUsername)()],
+        [constant_1.TMQConstants.CONNECT_PASS, (0, utils_1.testPassword)()],
         [constant_1.TMQConstants.AUTO_OFFSET_RESET, "earliest"],
         [constant_1.TMQConstants.CLIENT_ID, "test_tmq_client"],
         [constant_1.TMQConstants.WS_URL, dns],
@@ -143,8 +143,8 @@ test("normal Subscribe", async () => {
 });
 afterAll(async () => {
     let conf = new config_1.WSConfig(dns);
-    conf.setUser("root");
-    conf.setPwd("taosdata");
+    conf.setUser((0, utils_1.testUsername)());
+    conf.setPwd((0, utils_1.testPassword)());
     let wsSql = await wsSql_1.WsSql.open(conf);
     await wsSql.exec(dropTopic);
     await wsSql.exec("drop database power");

package/lib/test/bulkPulling/dsn.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dsn.test.d.ts.map

package/lib/test/bulkPulling/dsn.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dsn.test.d.ts","sourceRoot":"","sources":["../../../test/bulkPulling/dsn.test.ts"],"names":[],"mappings":""}