@opentap/runner-client 2.7.1-alpha.1.2 → 2.7.1-alpha.1.3

package/lib/BaseClient.d.ts

@@ -29,6 +29,7 @@ export declare class BaseClient {
     set timeout(value: number);
     constructor(baseSubject: string, options: ConnectionOptions);
     private withTimeout;
+    private flattenArrays;
     /**
      * Send a request to the nats server.
      * @param subject The subject to request
@@ -50,12 +51,15 @@ export declare class BaseClient {
      */
     private buildHeaders;
     /**
-     * Subscribes to given subject.
+     * Subscribes to given subject with support for chunks. If a message is not chunked,
+     * it will be treated as a normal message and passed to the callback immediately.
      * @param subject The subject to subscribe
      * @param options Subscription options
+     * @param fromJS A method to convert the json payload to an object of type T
+     * @param callback Callback which receives the final payload
      * @returns Subscription object
      */
-    protected subscribe(subject: string, options: SubscriptionOptions): Subscription;
+    protected subscribeChunked<T>(subject: string, options: SubscriptionOptions, fromJS: (obj: T) => T, callback: (result: T | undefined, error: Error | null) => void): Subscription;
     protected encode(payload: any): Uint8Array;
     /**
      * Check if the the response is an error from the server.

package/lib/BaseClient.js

@@ -54,6 +54,33 @@ var Events;
 (function (Events) {
     Events["ERROR"] = "error_event";
 })(Events || (Events = {}));
+var RequestInfo = /** @class */ (function () {
+    function RequestInfo(msg) {
+        this.chunked = false;
+        this.chunkSize = 0;
+        this.chunkNumber = 0;
+        this.requestId = '';
+        // We assume the message is chunked if it contains the following three headers:
+        var chunkSize = this.getHeader(msg, 'ChunkSize');
+        var chunkNumber = this.getHeader(msg, 'ChunkNumber');
+        var requestId = this.getHeader(msg, 'RequestId');
+        if (chunkSize && chunkNumber && requestId) {
+            this.chunked = true;
+            this.chunkSize = parseInt(chunkSize, 10);
+            this.chunkNumber = parseInt(chunkNumber, 10);
+            this.requestId = requestId;
+        }
+    }
+    RequestInfo.prototype.getHeader = function (msg, name) {
+        var _a, _b;
+        var values = (_b = (_a = msg.headers) === null || _a === void 0 ? void 0 : _a.values(name)) !== null && _b !== void 0 ? _b : [];
+        if (values.length > 0) {
+            return values[0];
+        }
+        return null;
+    };
+    return RequestInfo;
+}());
 var BaseClient = /** @class */ (function () {
     function BaseClient(baseSubject, options) {
         this.domainAccess = new Map();
@@ -102,6 +129,17 @@ var BaseClient = /** @class */ (function () {
     BaseClient.prototype.withTimeout = function (promise, timeout) {
         return Promise.race([promise, new Promise(function (_, reject) { return setTimeout(function () { return reject(new Error(ErrorCode.Timeout)); }, timeout); })]);
     };
+    BaseClient.prototype.flattenArrays = function (dataArrays) {
+        var flattenedSize = dataArrays.reduce(function (sum, array) { return sum + array.length; }, 0);
+        var flattenedArray = new Uint8Array(flattenedSize);
+        var k = 0;
+        dataArrays.map(function (m) {
+            for (var i = 0; i < m.length; i++) {
+                flattenedArray[k++] = m[i];
+            }
+        });
+        return flattenedArray;
+    };
     /**
      * Send a request to the nats server.
      * @param subject The subject to request
@@ -170,22 +208,10 @@ var BaseClient = /** @class */ (function () {
                             return reject(Error('Response is not a valid chunk.'));
                         }
                         if (parseInt(finalMessageNumber) !== messages.length) {
-                            return reject(Error("Expected {finalMessageNumber} chunks, but received ".concat(messages.length, ". ") +
+                            return reject(Error("Expected ".concat(finalMessageNumber, " chunks, but received ").concat(messages.length, ". ") +
                                 "The connection may have been interrupted."));
                         }
-                        // Concatenate the payloads
-                        // When there are many chunks, doing a single allocation
-                        // is significantly faster than concatenating arrays in sequence
-                        var dataArrays = messages.map(function (m) { return m.data; });
-                        var flattenedSize = dataArrays.reduce(function (sum, array) { return sum + array.length; }, 0);
-                        var flattenedArray = new Uint8Array(flattenedSize);
-                        var k = 0;
-                        dataArrays.map(function (m) {
-                            for (var i = 0; i < m.length; i++) {
-                                flattenedArray[k++] = m[i];
-                            }
-                        });
-                        return resolve(flattenedArray);
+                        return resolve(_this.flattenArrays(messages.map(function (m) { return m.data; })));
                     };
                 })
                     .then(function (byteArray) {
@@ -256,12 +282,15 @@ var BaseClient = /** @class */ (function () {
         return _headers;
     };
     /**
-     * Subscribes to given subject.
+     * Subscribes to given subject with support for chunks. If a message is not chunked,
+     * it will be treated as a normal message and passed to the callback immediately.
      * @param subject The subject to subscribe
      * @param options Subscription options
+     * @param fromJS A method to convert the json payload to an object of type T
+     * @param callback Callback which receives the final payload
      * @returns Subscription object
      */
-    BaseClient.prototype.subscribe = function (subject, options) {
+    BaseClient.prototype.subscribeChunked = function (subject, options, fromJS, callback) {
         if (!subject)
             throw Error('Subject is not defined!');
         if (!this.connection)
@@ -269,7 +298,97 @@ var BaseClient = /** @class */ (function () {
         if (this.connection.isClosed())
             throw Error('Connection has been closed! Please reconnect!');
         var natsSubject = "".concat(this.baseSubject, ".").concat(subject);
-        return this.connection.subscribe(natsSubject, options);
+        function respond(bytes, err) {
+            if (err) {
+                callback(undefined, err);
+                return;
+            }
+            try {
+                var jsonCodec = JSONCodec();
+                var jsObject = jsonCodec.decode(bytes);
+                var result = fromJS(jsObject);
+                callback(result, null);
+            }
+            catch (error) {
+                callback(undefined, error);
+            }
+        }
+        // Make a reference to this method to use inside RequestHandler
+        var flattenArrays = this.flattenArrays;
+        // This class represents a single request, which may be comprised of several chunks.
+        // We declare it inside this closure because it needs to access a few closure
+        var RequestHandler = /** @class */ (function () {
+            function RequestHandler() {
+                this.messages = [];
+                this.lastUpdate = Date.now();
+            }
+            // We consider a message expired if there has been no activity for 60 seconds.
+            // Since chunked messages can potentially be quite large, we need to ensure
+            // that they can be garbage collected.
+            // Note that a message is explicitly cleaned up if it is completed. This only applies
+            // if the message was interrupted.
+            RequestHandler.prototype.expired = function () {
+                var now = Date.now();
+                if (now - this.lastUpdate > 60000) {
+                    return true;
+                }
+                return false;
+            };
+            // Handle a message. Return true if the message was terminated, otherwise return false.
+            RequestHandler.prototype.handleMessage = function (msg, requestInfo, error) {
+                // If there was a nats error, terminate immediately.
+                if (error) {
+                    respond(new Uint8Array(), error);
+                    return true;
+                }
+                // If the message is not chunked, it is finished after a single message.
+                if (requestInfo.chunked === false) {
+                    respond(msg.data, null);
+                    return true;
+                }
+                // Otherwise, the message is finished if we have determined this to be the last chunk.
+                // This is the case if the chunk is smaller than the max chunk size.
+                this.lastUpdate = Date.now();
+                this.messages.push(msg);
+                if (msg.data.length === 0 || msg.data.length < requestInfo.chunkSize) {
+                    if (requestInfo.chunkNumber != this.messages.length) {
+                        respond(new Uint8Array(), Error("Expected ".concat(requestInfo.chunkNumber, " chunks, but received ").concat(this.messages.length, ". ") +
+                            "The connection may have been interrupted."));
+                    }
+                    respond(flattenArrays(this.messages.map(function (m) { return m.data; })), null);
+                    return true;
+                }
+                return false;
+            };
+            return RequestHandler;
+        }());
+        var requestHandlers = new Map();
+        options = __assign(__assign({}, options), { callback: function (error, msg) {
+                var requestInfo = new RequestInfo(msg);
+                var requestHandler = new RequestHandler();
+                if (requestHandlers.has(requestInfo.requestId)) {
+                    requestHandler = requestHandlers.get(requestInfo.requestId);
+                }
+                else {
+                    requestHandlers.set(requestInfo.requestId, requestHandler);
+                }
+                var done = requestHandler.handleMessage(msg, requestInfo, error);
+                // The message was terminated, so we can remove the handler from the lut
+                if (done)
+                    requestHandlers.delete(requestInfo.requestId);
+                // If a client doesn't send the terminating chunk,
+                // this object can't be garbage collected.
+                // This is especially an issue because this object
+                // holds onto chunks, and can therefore become quite leaky.
+                // We should check if a request handler can be collected periodically.
+                requestHandlers.forEach(function (value, key) {
+                    if (value.expired()) {
+                        requestHandlers.delete(key);
+                    }
+                });
+            } });
+        var subscription = this.connection.subscribe(natsSubject, options);
+        return subscription;
     };
     BaseClient.prototype.encode = function (payload) {
         if (!payload) {

package/lib/SessionClient.js

@@ -13,19 +13,7 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 import { BreakPoints, CommonContext, CommonSettings, DataGridControl, Image, Interaction, ListItemType, LogList, Result, RunStatus, SessionEvent, Setting, TestPlan, TestRun, TestStepType, TestStepValidationError, WatchDog, } from './DTOs';
-import { JSONCodec } from 'nats.ws';
 import { BaseClient } from './BaseClient';
 var SessionClient = /** @class */ (function (_super) {
     __extends(SessionClient, _super);
@@ -40,21 +28,7 @@ var SessionClient = /** @class */ (function (_super) {
      * @returns Subscription object
      */
     SessionClient.prototype.connectSessionLogs = function (sessionLogsHandler, options) {
-        return this.subscribe('SessionLogs', __assign(__assign({}, options), { callback: function (error, encodedMessage) {
-                if (error) {
-                    sessionLogsHandler(undefined, error);
-                    return;
-                }
-                try {
-                    var jsonCodec = JSONCodec();
-                    var logListJson = jsonCodec.decode(encodedMessage === null || encodedMessage === void 0 ? void 0 : encodedMessage.data);
-                    var logList = LogList.fromJS(logListJson);
-                    sessionLogsHandler(logList, error);
-                }
-                catch (error) {
-                    sessionLogsHandler(undefined, error);
-                }
-            } }));
+        return this.subscribeChunked('SessionLogs', options || {}, LogList.fromJS, sessionLogsHandler);
     };
     /**
      * @param eventHandler Function to be called when session event or error is received
@@ -62,23 +36,8 @@ var SessionClient = /** @class */ (function (_super) {
      * @returns Subscription object
      */
     SessionClient.prototype.connectSessionEvents = function (eventHandler, options) {
-        var callback = function (error, encodedMessage) {
-            if (error) {
-                eventHandler(undefined, error);
-                return;
-            }
-            try {
-                var jsonCodec = JSONCodec();
-                var sessionEventJs = jsonCodec.decode(encodedMessage === null || encodedMessage === void 0 ? void 0 : encodedMessage.data);
-                var sessionEvent = SessionEvent.fromJS(sessionEventJs);
-                eventHandler(sessionEvent, error);
-            }
-            catch (error) {
-                eventHandler(undefined, error);
-            }
-        };
-        this.subscriptions.push(this.subscribe('Events', __assign(__assign({}, options), { callback: callback })));
-        this.subscriptions.push(this.subscribe('Events.*', __assign(__assign({}, options), { callback: callback })));
+        this.subscriptions.push(this.subscribeChunked('Events', options || {}, SessionEvent.fromJS, eventHandler));
+        this.subscriptions.push(this.subscribeChunked('Events.*', options || {}, SessionEvent.fromJS, eventHandler));
     };
     /**
      * @param resultHandler Function to be called when result or error is received
@@ -88,36 +47,8 @@ var SessionClient = /** @class */ (function (_super) {
      */
     SessionClient.prototype.connectSessionResults = function (resultHandler, testRunHandler, options) {
         return [
-            this.subscribe('OnResult', __assign(__assign({}, options), { callback: function (error, encodedMessage) {
-                    if (error) {
-                        resultHandler(undefined, error);
-                        return;
-                    }
-                    try {
-                        var jsonCodec = JSONCodec();
-                        var resultJs = jsonCodec.decode(encodedMessage === null || encodedMessage === void 0 ? void 0 : encodedMessage.data);
-                        var result = Result.fromJS(resultJs);
-                        resultHandler(result, error);
-                    }
-                    catch (error) {
-                        resultHandler(undefined, error);
-                    }
-                } })),
-            this.subscribe('OnTestRun', __assign(__assign({}, options), { callback: function (error, encodedMessage) {
-                    if (error) {
-                        testRunHandler(undefined, error);
-                        return;
-                    }
-                    try {
-                        var jsonCodec = JSONCodec();
-                        var testRunJs = jsonCodec.decode(encodedMessage === null || encodedMessage === void 0 ? void 0 : encodedMessage.data);
-                        var testRun = TestRun.fromJS(testRunJs);
-                        testRunHandler(testRun, error);
-                    }
-                    catch (error) {
-                        testRunHandler(undefined, error);
-                    }
-                } })),
+            this.subscribeChunked('OnResult', options || {}, Result.fromJS, resultHandler),
+            this.subscribeChunked('OnTestRun', options || {}, TestRun.fromJS, testRunHandler),
         ];
     };
     /**

package/lib/SystemClient.d.ts

@@ -8,6 +8,7 @@ export interface RunnerLifetimeEvent {
 }
 export declare class SystemClient extends BaseClient {
     constructor(baseSubject: string, options: ConnectionOptions);
+    private callbackConverter;
     /**
      * Subscribe to the lifetime event.
      * @param listener

package/lib/SystemClient.js

@@ -13,25 +13,29 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 import { BaseClient } from './BaseClient';
-import { JSONCodec } from 'nats.ws';
+import { NatsError } from 'nats.ws';
 import { TestPlanRunCompletedEventArgs, TestPlanRunStartEventArgs, TestStepRunCompletedEventArgs, TestStepRunStartEventArgs, } from './DTOs';
 var SystemClient = /** @class */ (function (_super) {
     __extends(SystemClient, _super);
     function SystemClient(baseSubject, options) {
         return _super.call(this, baseSubject, options) || this;
     }
+    // The callbacks in this file are structured differently from the callbacks in BaseClient.
+    // This converter performs the appropriate error conversions and arguments flips
+    // so we can use these callbacks as input to subscribeChunked.
+    SystemClient.prototype.callbackConverter = function (subject, cb) {
+        var _this = this;
+        return function (result, error) {
+            if (error instanceof NatsError) {
+                var err = _this.natsErrorHandler(error, subject);
+                cb(err, null);
+            }
+            else {
+                cb(null, result || null);
+            }
+        };
+    };
     /**
      * Subscribe to the lifetime event.
      * @param listener
@@ -39,22 +43,9 @@ var SystemClient = /** @class */ (function (_super) {
      * @returns {Subscription}
      */
     SystemClient.prototype.subscribeLifetimeEventListener = function (listener, options) {
-        var _this = this;
         var subject = '*.Events.Lifetime';
-        return this.subscribe(subject, __assign(__assign({}, options), { callback: function (error, message) {
-                if (error) {
-                    listener(_this.natsErrorHandler(error, subject), null);
-                    return;
-                }
-                try {
-                    var jsonCodec = JSONCodec();
-                    var data = jsonCodec.decode(message === null || message === void 0 ? void 0 : message.data);
-                    listener(null, data);
-                }
-                catch (error) {
-                    listener(_this.natsErrorHandler(error, subject), null);
-                }
-            } }));
+        var callback = this.callbackConverter(subject, listener);
+        return this.subscribeChunked(subject, options || {}, function (t) { return t; }, callback);
     };
     /**
      * Subscribe to the test step run start events for the given Runner and Run ID.
@@ -65,23 +56,9 @@ var SystemClient = /** @class */ (function (_super) {
      * @param  {SubscriptionOptions} options?
      */
     SystemClient.prototype.subscribeTestStepRunStartEventListener = function (runnerId, runId, listener, options) {
-        var _this = this;
         var subject = "".concat(runnerId, ".Runs.").concat(runId, ".Events.TestStepRunStart");
-        return this.subscribe(subject, __assign(__assign({}, options), { callback: function (error, message) {
-                if (error) {
-                    listener(_this.natsErrorHandler(error, subject), null);
-                    return;
-                }
-                try {
-                    var jsonCodec = JSONCodec();
-                    var testStepRunStartEventArgsJs = jsonCodec.decode(message === null || message === void 0 ? void 0 : message.data);
-                    var testStepRunStartEventArgs = TestStepRunStartEventArgs.fromJS(testStepRunStartEventArgsJs);
-                    listener(null, testStepRunStartEventArgs);
-                }
-                catch (error) {
-                    listener(_this.natsErrorHandler(error, subject), null);
-                }
-            } }));
+        var callback = this.callbackConverter(subject, listener);
+        return this.subscribeChunked(subject, options || {}, TestStepRunStartEventArgs.fromJS, callback);
     };
     /**
      * Subscribe to the test step run completed events for the given Runner and Run ID.
@@ -92,23 +69,9 @@ var SystemClient = /** @class */ (function (_super) {
      * @param  {SubscriptionOptions} options?
      */
     SystemClient.prototype.subscribeTestStepRunCompletedEventListener = function (runnerId, runId, listener, options) {
-        var _this = this;
         var subject = "".concat(runnerId, ".Runs.").concat(runId, ".Events.TestStepRunCompleted");
-        return this.subscribe(subject, __assign(__assign({}, options), { callback: function (error, message) {
-                if (error) {
-                    listener(_this.natsErrorHandler(error, subject), null);
-                    return;
-                }
-                try {
-                    var jsonCodec = JSONCodec();
-                    var testStepRunCompletedEventArgsJs = jsonCodec.decode(message === null || message === void 0 ? void 0 : message.data);
-                    var testStepRunCompletedEventArgs = TestStepRunCompletedEventArgs.fromJS(testStepRunCompletedEventArgsJs);
-                    listener(null, testStepRunCompletedEventArgs);
-                }
-                catch (error) {
-                    listener(_this.natsErrorHandler(error, subject), null);
-                }
-            } }));
+        var callback = this.callbackConverter(subject, listener);
+        return this.subscribeChunked(subject, options || {}, TestStepRunCompletedEventArgs.fromJS, callback);
     };
     /**
      * Subscribe to the test plan run start events for the given Runner and Run ID.
@@ -119,23 +82,9 @@ var SystemClient = /** @class */ (function (_super) {
      * @param  {SubscriptionOptions} options?
      */
     SystemClient.prototype.subscribeTestPlanRunStartEventListener = function (runnerId, runId, listener, options) {
-        var _this = this;
         var subject = "".concat(runnerId, ".Runs.").concat(runId, ".Events.TestPlanRunStart");
-        return this.subscribe(subject, __assign(__assign({}, options), { callback: function (error, message) {
-                if (error) {
-                    listener(_this.natsErrorHandler(error, subject), null);
-                    return;
-                }
-                try {
-                    var jsonCodec = JSONCodec();
-                    var testPlanRunStartEventArgsJs = jsonCodec.decode(message === null || message === void 0 ? void 0 : message.data);
-                    var testPlanRunStartEventArgs = TestPlanRunStartEventArgs.fromJS(testPlanRunStartEventArgsJs);
-                    listener(null, testPlanRunStartEventArgs);
-                }
-                catch (error) {
-                    listener(_this.natsErrorHandler(error, subject), null);
-                }
-            } }));
+        var callback = this.callbackConverter(subject, listener);
+        return this.subscribeChunked(subject, options || {}, TestPlanRunStartEventArgs.fromJS, callback);
     };
     /**
      * Subscribe to the test plan run completed events for the given Runner and Run ID.
@@ -146,23 +95,9 @@ var SystemClient = /** @class */ (function (_super) {
      * @param  {SubscriptionOptions} options?
      */
     SystemClient.prototype.subscribeTestPlanRunCompletedEventListener = function (runnerId, runId, listener, options) {
-        var _this = this;
         var subject = "".concat(runnerId, ".Runs.").concat(runId, ".Events.TestPlanRunCompleted");
-        return this.subscribe(subject, __assign(__assign({}, options), { callback: function (error, message) {
-                if (error) {
-                    listener(_this.natsErrorHandler(error, subject), null);
-                    return;
-                }
-                try {
-                    var jsonCodec = JSONCodec();
-                    var testPlanRunCompletedEventArgsJs = jsonCodec.decode(message === null || message === void 0 ? void 0 : message.data);
-                    var testPlanRunCompletedEventArgs = TestPlanRunCompletedEventArgs.fromJS(testPlanRunCompletedEventArgsJs);
-                    listener(null, testPlanRunCompletedEventArgs);
-                }
-                catch (error) {
-                    listener(_this.natsErrorHandler(error, subject), null);
-                }
-            } }));
+        var callback = this.callbackConverter(subject, listener);
+        return this.subscribeChunked(subject, options || {}, TestPlanRunCompletedEventArgs.fromJS, callback);
     };
     return SystemClient;
 }(BaseClient));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentap/runner-client",
-  "version": "2.7.1-alpha.1.2",
+  "version": "2.7.1-alpha.1.3",
   "description": "This is the web client for the OpenTAP Runner.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",