@opentap/runner-client 2.3.2 → 2.3.3-alpha.1.1

package/lib/BaseClient.d.ts

@@ -1,5 +1,11 @@
 import { ComponentSettingsBase, ComponentSettingsIdentifier, ComponentSettingsListItem, DataGridControl, ErrorResponse, FileParameter, FileResponse, ListItemType, ProfileGroup, RepositoryPackageReference, RepositorySettingsPackageDefinition, SettingsTapPackage } from './DTOs';
-import { ConnectionOptions, RequestOptions, Subscription, SubscriptionOptions } from 'nats.ws';
+import { ConnectionOptions, Subscription, SubscriptionOptions, PublishOptions } from 'nats.ws';
+interface BaseClientRequestOptions {
+    publishOptions?: PublishOptions;
+    rawResponse?: boolean;
+    fullSubject?: boolean;
+    timeout?: number;
+}
 export declare class BaseClient {
     private connection;
     private baseSubject;
@@ -9,7 +15,6 @@ export declare class BaseClient {
     private _accessToken;
     private _headers;
     private _timeout;
-    private _chunkSize;
     /** Get request access token */
     get accessToken(): string;
     /** Set request access token */
@@ -23,6 +28,7 @@ export declare class BaseClient {
     /** Set timeout in milliseconds. Default is 40000 milliseconds */
     set timeout(value: number);
     constructor(baseSubject: string, options: ConnectionOptions);
+    private withTimeout;
     /**
      * Send a request to the nats server.
      * @param subject The subject to request
@@ -30,7 +36,7 @@ export declare class BaseClient {
      * @param options (optional)
      * @returns Promise of an object
      */
-    protected request<T>(subject: string, payload?: any, options?: RequestOptions, rawResponse?: boolean, fullSubject?: boolean): Promise<T>;
+    protected request<T>(subject: string, payload?: any, options?: BaseClientRequestOptions): Promise<T>;
     /**
      * Handle the error
      * @param error
@@ -50,14 +56,6 @@ export declare class BaseClient {
      * @returns Subscription object
      */
     protected subscribe(subject: string, options: SubscriptionOptions): Subscription;
-    /**
-     * Receive a chunked file specified by a request response
-     * @param requestResponse Contains a reply subject and a file descriptor which can be used to download chunks
-     * @param rawResponse If true, the response should not be decoded
-     * @param opts Request options
-     * @returns
-     */
-    private downloadChunkedRequest;
     protected encode(payload: any): Uint8Array;
     /**
      * Check if the the response is an error from the server.
@@ -246,3 +244,4 @@ export declare class BaseClient {
      */
     downloadSettingsPackage(settingsTapPackage: SettingsTapPackage): Promise<FileResponse>;
 }
+export {};

package/lib/BaseClient.js

@@ -45,17 +45,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { ComponentSettingsBase, ComponentSettingsIdentifier, ComponentSettingsListItem, DataGridControl, ErrorResponse, FileDescriptor, ListItemType, ProfileGroup, } from './DTOs';
-import { Empty, ErrorCode, JSONCodec, NatsError, StringCodec, connect, headers, } from 'nats.ws';
+import { Empty, ErrorCode, JSONCodec, StringCodec, connect, headers, } from 'nats.ws';
 import { EventEmitter } from 'events';
 var DEFAULT_TIMEOUT = 40000; // default timeout of 40 seconds
 var Events;
@@ -66,7 +57,6 @@ var BaseClient = /** @class */ (function () {
     function BaseClient(baseSubject, options) {
         this.domainAccess = new Map();
         this._headers = new Headers();
-        this._chunkSize = 512000;
         this.baseSubject = baseSubject;
         this.connectionOptions = __assign({}, options) || {};
         this.connectionOptions.timeout = (options === null || options === void 0 ? void 0 : options.timeout) || DEFAULT_TIMEOUT;
@@ -108,6 +98,9 @@ var BaseClient = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    BaseClient.prototype.withTimeout = function (promise, timeout) {
+        return Promise.race([promise, new Promise(function (_, reject) { return setTimeout(function () { return reject(new Error(ErrorCode.Timeout)); }, timeout); })]);
+    };
     /**
      * Send a request to the nats server.
      * @param subject The subject to request
@@ -115,74 +108,113 @@ var BaseClient = /** @class */ (function () {
      * @param options (optional)
      * @returns Promise of an object
      */
-    BaseClient.prototype.request = function (subject, payload, options, rawResponse, fullSubject) {
+    BaseClient.prototype.request = function (subject, payload, options) {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function () {
-            var originalSubject, data, headers, timeout, opts, fileDescriptor, getChunk, requestResponse, dataSubject, i, result, error, ex_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        // Prepend the base subject if the given subject does not start with that
-                        if (!fullSubject) {
-                            subject = "".concat(this.baseSubject, ".Request.").concat(subject);
+            var data, headers, timeout, replySubject, chunkSize, requestId, opts, fileDescriptor, chunkNumber, getChunk, subscription, responsePromise, chunk, i;
+            var _this = this;
+            return __generator(this, function (_d) {
+                // Prepend the base subject if the given subject does not start with that
+                if (!(options === null || options === void 0 ? void 0 : options.fullSubject)) {
+                    subject = "".concat(this.baseSubject, ".Request.").concat(subject);
+                }
+                if (!this.connection)
+                    return [2 /*return*/, Promise.reject("".concat(subject, ": Connection is down! Please try again!"))];
+                if (this.connection.isClosed())
+                    return [2 /*return*/, Promise.reject("".concat(subject, ": Connection has been closed! Please reconnect!"))];
+                data = this.encode(payload);
+                headers = this.buildHeaders();
+                timeout = (options === null || options === void 0 ? void 0 : options.timeout) || this.timeout;
+                replySubject = crypto.randomUUID();
+                chunkSize = ((_c = (_b = (_a = this.connection) === null || _a === void 0 ? void 0 : _a.info) === null || _b === void 0 ? void 0 : _b.max_payload) !== null && _c !== void 0 ? _c : 512000) - 2000;
+                // The Session and the Client need to agree on the chunk size. Put it in a header.
+                headers.append('ChunkSize', chunkSize.toString());
+                requestId = crypto.randomUUID();
+                headers.append('RequestId', requestId);
+                opts = __assign(__assign({}, options === null || options === void 0 ? void 0 : options.publishOptions), { headers: headers, reply: replySubject });
+                fileDescriptor = new FileDescriptor(data.length, chunkSize);
+                chunkNumber = 1;
+                headers.set('ChunkNumber', chunkNumber.toString());
+                getChunk = function (chunk) {
+                    var offset = chunk * fileDescriptor.chunkSize;
+                    return data.slice(offset, offset + fileDescriptor.chunkSize);
+                };
+                subscription = this.connection.subscribe(replySubject);
+                responsePromise = new Promise(function (resolve, reject) {
+                    var messages = [];
+                    subscription.callback = function (error, message) {
+                        var _a;
+                        if (error) {
+                            reject(error);
                         }
-                        originalSubject = subject;
-                        if (!this.connection)
-                            return [2 /*return*/, Promise.reject("".concat(subject, ": Connection is down! Please try again!"))];
-                        if (this.connection.isClosed())
-                            return [2 /*return*/, Promise.reject("".concat(subject, ": Connection has been closed! Please reconnect!"))];
-                        data = this.encode(payload);
-                        headers = this.buildHeaders();
-                        headers.append('ChunkSize', this._chunkSize.toString());
-                        timeout = (options === null || options === void 0 ? void 0 : options.timeout) || this.timeout;
-                        opts = __assign(__assign({}, options), { timeout: timeout, headers: headers });
-                        fileDescriptor = new FileDescriptor(data.length, this._chunkSize);
-                        getChunk = function (chunk) {
-                            var offset = chunk * fileDescriptor.chunkSize;
-                            return data.slice(offset, offset + fileDescriptor.chunkSize);
-                        };
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 9, , 10]);
-                        requestResponse = void 0;
-                        dataSubject = subject;
-                        i = 0;
-                        _a.label = 2;
-                    case 2:
-                        if (!(i < fileDescriptor.numberOfChunks)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, this.connection.request(dataSubject, getChunk(i), opts)];
-                    case 3:
-                        requestResponse = _a.sent();
-                        dataSubject = requestResponse.reply;
-                        _a.label = 4;
-                    case 4:
-                        i++;
-                        return [3 /*break*/, 2];
-                    case 5:
-                        if (!(fileDescriptor.fileSize % fileDescriptor.chunkSize === 0)) return [3 /*break*/, 7];
-                        return [4 /*yield*/, this.connection.request(dataSubject, Empty, opts)];
-                    case 6:
-                        requestResponse = _a.sent();
-                        _a.label = 7;
-                    case 7: return [4 /*yield*/, this.downloadChunkedRequest(requestResponse, rawResponse, opts)];
-                    case 8:
-                        result = _a.sent();
-                        if (this.isErrorResponse(result)) {
-                            error = ErrorResponse.fromJS(result);
-                            this.eventEmitter.emit(Events.ERROR, error);
-                            return [2 /*return*/, Promise.reject(error)];
+                        // Put all the response chunks in an array in the order they are received
+                        messages.push(message);
+                        // If the chunk has a size equal to the chunkSize, we should expect another message
+                        if (message.data.length === chunkSize) {
+                            return;
                         }
-                        return [2 /*return*/, result];
-                    case 9:
-                        ex_1 = _a.sent();
-                        if (ex_1 instanceof NatsError) {
-                            return [2 /*return*/, Promise.reject(this.natsErrorHandler(ex_1, originalSubject))];
+                        // If the chunk has a length smaller than the chunkSize, the message is complete
+                        // If the final message was received, we can safely unsubscribe
+                        subscription.unsubscribe();
+                        // Check if the number of the final message is equal to the number of
+                        // messages we received. If this is not the case, we dropped a chunk,
+                        // likely due to a network error. In this case, the entire message is invalid.
+                        var finalMessage = message;
+                        var finalMessageNumber = (_a = finalMessage.headers) === null || _a === void 0 ? void 0 : _a.get('ChunkNumber');
+                        if (!finalMessageNumber) {
+                            return reject('Response is not a valid chunk.');
                         }
-                        else {
-                            return [2 /*return*/, Promise.reject(ex_1)];
+                        if (parseInt(finalMessageNumber) !== messages.length) {
+                            return reject("Expected {finalMessageNumber} chunks, but received ".concat(messages.length, ". ") +
+                                "The connection may have been interrupted.");
                         }
-                        return [3 /*break*/, 10];
-                    case 10: return [2 /*return*/];
+                        // 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);
+                    };
+                })
+                    .then(function (byteArray) {
+                    if (byteArray.length === 0) {
+                        return Promise.resolve(undefined);
+                    }
+                    var jsonCodec = JSONCodec();
+                    // If a raw response is requested, we should avoid decoding the bytes.
+                    var response = (options === null || options === void 0 ? void 0 : options.rawResponse) ? byteArray : jsonCodec.decode(byteArray);
+                    return _this.isErrorResponse(response) ? Promise.reject(ErrorResponse.fromJS(response)) : Promise.resolve(response);
+                })
+                    .catch(function (err) {
+                    return Promise.reject(_this.natsErrorHandler(err, subject));
+                });
+                chunk = getChunk(0);
+                this.connection.publish(subject, chunk, opts);
+                chunkNumber += 1;
+                for (i = 1; i < fileDescriptor.numberOfChunks; i++) {
+                    headers.set('ChunkNumber', chunkNumber.toString());
+                    chunk = getChunk(i);
+                    this.connection.publish(subject, chunk, opts);
+                    chunkNumber += 1;
+                }
+                // In the special case where the last published chunk was full, we need to publish
+                // an empty message
+                if (data.length > 0 && data.length % fileDescriptor.chunkSize === 0) {
+                    headers.set('ChunkNumber', chunkNumber.toString());
+                    this.connection.publish(subject, Empty, opts);
                 }
+                // Now that we have sent the terminating chunk, the result should arrive on our promise.
+                return [2 /*return*/, this.withTimeout(responsePromise, timeout).catch(function (err) {
+                        subscription.unsubscribe();
+                        return Promise.reject(_this.natsErrorHandler(err, subject));
+                    })];
             });
         });
     };
@@ -234,50 +266,6 @@ var BaseClient = /** @class */ (function () {
         var natsSubject = "".concat(this.baseSubject, ".").concat(subject);
         return this.connection.subscribe(natsSubject, options);
     };
-    /**
-     * Receive a chunked file specified by a request response
-     * @param requestResponse Contains a reply subject and a file descriptor which can be used to download chunks
-     * @param rawResponse If true, the response should not be decoded
-     * @param opts Request options
-     * @returns
-     */
-    BaseClient.prototype.downloadChunkedRequest = function (requestResponse, rawResponse, opts) {
-        return __awaiter(this, void 0, void 0, function () {
-            var result, resultCodec;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.connection)
-                            return [2 /*return*/, Promise.reject('Chunking: Connection is down! Please try again!')];
-                        if (this.connection.isClosed())
-                            return [2 /*return*/, Promise.reject("Chunking: Connection has been closed! Please reconnect!")];
-                        result = new Uint8Array([]);
-                        _a.label = 1;
-                    case 1:
-                        result = new Uint8Array(__spreadArray(__spreadArray([], Array.from(result), true), Array.from(requestResponse.data), true));
-                        // Acknowledge that the final chunk was received
-                        if (requestResponse.data.length < this._chunkSize) {
-                            this.connection.publish(requestResponse.reply, Empty, opts);
-                            return [3 /*break*/, 4];
-                        }
-                        return [4 /*yield*/, this.connection.request(requestResponse.reply, Empty, opts)];
-                    case 2:
-                        requestResponse = _a.sent();
-                        _a.label = 3;
-                    case 3: return [3 /*break*/, 1];
-                    case 4:
-                        if (result.length !== 0) {
-                            // The runner skips the encoding step if the return type is a byte array, so we must also skip the decoding step in this case.
-                            if (rawResponse)
-                                return [2 /*return*/, Promise.resolve(result)];
-                            resultCodec = JSONCodec();
-                            return [2 /*return*/, resultCodec.decode(result)];
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
     BaseClient.prototype.encode = function (payload) {
         if (!payload) {
             return Empty;

package/lib/RunnerClient.js

@@ -51,7 +51,7 @@ var RunnerClient = /** @class */ (function (_super) {
      */
     RunnerClient.prototype.resolveImage = function (images, timeout) {
         return (images === null || images === void 0 ? void 0 : images.length) > 0
-            ? this.request('ResolveImage', images, { timeout: timeout || this.timeout })
+            ? this.request('ResolveImage', images, { timeout: timeout })
                 .then(function (imageJs) { return Image.fromJS(imageJs); })
                 .then(this.success())
                 .catch(this.error())

package/lib/SessionClient.js

@@ -218,7 +218,9 @@ var SessionClient = /** @class */ (function (_super) {
             return Promise.reject('The source of the provided resource is not a nats subject.');
         }
         var subject = resource.source.slice(runnerResourcePrefix.length);
-        return this.request(subject, undefined, undefined, true, true).then(this.success()).catch(this.error());
+        return this.request(subject, undefined, { rawResponse: true, fullSubject: true })
+            .then(this.success())
+            .catch(this.error());
     };
     /**
      * Load test plan using a test plan TapPackage from a repository

package/package.json

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