@opentap/runner-client 2.2.4-alpha.1.1 → 2.2.4

package/lib/BaseClient.d.ts

@@ -1,5 +1,5 @@
 import { ComponentSettingsBase, ComponentSettingsIdentifier, ComponentSettingsListItem, DataGridControl, ErrorResponse, FileParameter, FileResponse, ListItemType, ProfileGroup, RepositoryPackageReference, RepositorySettingsPackageDefinition, SettingsTapPackage } from './DTOs';
-import { ConnectionOptions, RequestOptions, Subscription, SubscriptionOptions, Msg } from 'nats.ws';
+import { ConnectionOptions, RequestOptions, Subscription, SubscriptionOptions } from 'nats.ws';
 export declare class BaseClient {
     private connection;
     private baseSubject;
@@ -52,20 +52,30 @@ export declare class BaseClient {
      */
     protected subscribe(subject: string, options: SubscriptionOptions): Subscription;
     /**
-     * Send an object to the nats server with chunks.
-     * @param subject The subject to request
-     * @param payload (optional)
-     * @param options (optional)
-     * @returns Promise of an object
+     * Make a request to the runner with a chunked payload. The response will be received in chunks.
+     * @param subject The request subject.
+     * @param payload The request body which will be chunked
+     * @param options Optional request options
+     * @param rawResponse If true, the response will not be decoded
+     * @returns
      */
-    protected sendChunked<T>(subject: string, payload?: any, options?: RequestOptions, rawResponse?: boolean): Promise<T>;
-    receiveFile<T>(msg: Msg, rawResponse?: boolean, opts?: RequestOptions): Promise<T>;
+    protected sendChunked<T>(subject: string, payload: any, options?: RequestOptions, rawResponse?: boolean): Promise<T>;
     /**
-     * Request an object to the nats server with chunks.
-     * @param subject The subject to request
-     * @param payload (optional)
-     * @param options (optional)
-     * @returns Promise of an object
+     * 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;
+    /**
+     * Make a request to the runner whose response will be sent in chunked
+     * @param subject The request subject
+     * @param payload Optional request body
+     * @param options Optional request options
+     * @param rawResponse If true, the return value will not be decoded
+     * @param fullSubject If true, the base subject will not be prepended
+     * @returns
      */
     protected requestChunked<T>(subject: string, payload?: any, options?: RequestOptions, rawResponse?: boolean, fullSubject?: boolean): Promise<T>;
     /**

package/lib/BaseClient.js

@@ -189,15 +189,16 @@ var BaseClient = /** @class */ (function () {
         return this.connection.subscribe(natsSubject, options);
     };
     /**
-     * Send an object to the nats server with chunks.
-     * @param subject The subject to request
-     * @param payload (optional)
-     * @param options (optional)
-     * @returns Promise of an object
+     * Make a request to the runner with a chunked payload. The response will be received in chunks.
+     * @param subject The request subject.
+     * @param payload The request body which will be chunked
+     * @param options Optional request options
+     * @param rawResponse If true, the response will not be decoded
+     * @returns
      */
     BaseClient.prototype.sendChunked = function (subject, payload, options, rawResponse) {
         return __awaiter(this, void 0, void 0, function () {
-            var stringCodec, data, headers, opts, fileDescriptor, msg, jsonCodec, response, error, getChunk, dataSubject, i;
+            var stringCodec, data, headers, opts, fileDescriptor, requestResponse, jsonCodec, response, error, getChunk, dataSubject, i;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -220,46 +221,59 @@ var BaseClient = /** @class */ (function () {
                             return [2 /*return*/, Promise.reject("".concat(subject, ": File is empty!"))];
                         return [4 /*yield*/, this.connection.request(subject, stringCodec.encode(JSON.stringify(fileDescriptor)), opts)];
                     case 1:
-                        msg = _a.sent();
-                        if (msg.data.length > 0) {
+                        requestResponse = _a.sent();
+                        if (requestResponse.data.length > 0) {
                             jsonCodec = JSONCodec();
-                            response = jsonCodec.decode(msg.data);
+                            response = jsonCodec.decode(requestResponse.data);
                             if (this.isErrorResponse(response)) {
                                 error = ErrorResponse.fromJS(response);
                                 this.eventEmitter.emit(Events.ERROR, error);
                                 return [2 /*return*/, Promise.reject(error)];
                             }
                         }
-                        if (!msg.reply) {
+                        // This should never happen. If it does happen, it likely means we are targetting an incompatible Runner version.
+                        if (!requestResponse.reply) {
                             return [2 /*return*/, Promise.reject('Send chunks: Runner did not return a reply subject.')];
                         }
                         getChunk = function (chunk) {
                             var offset = chunk * fileDescriptor.chunkSize;
                             return data.slice(offset, offset + fileDescriptor.chunkSize);
                         };
-                        dataSubject = msg.reply;
+                        dataSubject = requestResponse.reply;
                         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:
-                        msg = _a.sent();
-                        dataSubject = msg.reply;
+                        // The runner must acknowledge that it has received each chunk.
+                        // Likewise, we must wait for the runner to acknowledge each chunk
+                        // before sending the next one, because the acknowledge from the runner
+                        // contains the subject where we should send the next chunk.
+                        requestResponse = _a.sent();
+                        dataSubject = requestResponse.reply;
                         _a.label = 4;
                     case 4:
                         i++;
                         return [3 /*break*/, 2];
                     case 5: 
-                    // Receive a response based on the last message
-                    return [2 /*return*/, this.receiveFile(msg, rawResponse, opts)];
+                    // The response to any chunked request is itself a chunked response.
+                    // The last acknowledge from the runner indicates the subject where the response can be downloaded from.
+                    return [2 /*return*/, this.downloadChunkedRequest(requestResponse, rawResponse, opts)];
                 }
             });
         });
     };
-    BaseClient.prototype.receiveFile = function (msg, rawResponse, opts) {
+    /**
+     * 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 jsonCodec, fdResponse, error, fd, dataSubject, result, k, i, j, resultCodec;
+            var jsonCodec, responseBody, error, fileDescriptor, dataSubject, result, bytesReceived, i, j, resultCodec;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -268,41 +282,44 @@ var BaseClient = /** @class */ (function () {
                         if (this.connection.isClosed())
                             return [2 /*return*/, Promise.reject("Chunking: Connection has been closed! Please reconnect!")];
                         jsonCodec = JSONCodec();
-                        fdResponse = jsonCodec.decode(msg.data);
-                        if (this.isErrorResponse(fdResponse)) {
-                            error = ErrorResponse.fromJS(fdResponse);
+                        responseBody = jsonCodec.decode(requestResponse.data);
+                        if (this.isErrorResponse(responseBody)) {
+                            error = ErrorResponse.fromJS(responseBody);
                             this.eventEmitter.emit(Events.ERROR, error);
                             return [2 /*return*/, Promise.reject(error)];
                         }
-                        fd = FileDescriptor.fromJS(fdResponse);
-                        if (!msg.reply || !fd || fd.numberOfChunks === 0) {
+                        fileDescriptor = FileDescriptor.fromJS(responseBody);
+                        if (!requestResponse.reply || !fileDescriptor || fileDescriptor.numberOfChunks === 0) {
                             return [2 /*return*/, Promise.reject('Chunking: Response payload does not indicate a chunked response.')];
                         }
-                        dataSubject = msg.reply;
-                        result = new Uint8Array(fd.fileSize);
-                        k = 0;
+                        dataSubject = requestResponse.reply;
+                        result = new Uint8Array(fileDescriptor.fileSize);
+                        bytesReceived = 0;
                         i = 0;
                         _a.label = 1;
                     case 1:
-                        if (!(i < fd.numberOfChunks)) return [3 /*break*/, 4];
+                        if (!(i < fileDescriptor.numberOfChunks)) return [3 /*break*/, 4];
                         return [4 /*yield*/, this.connection.request(dataSubject, Empty, opts)];
                     case 2:
-                        msg = _a.sent();
-                        dataSubject = msg.reply;
-                        for (j = 0; j < msg.data.length; j++) {
-                            result[k++] = msg.data[j];
+                        // Send a request with an empty payload to acknowledge that we received the previous chunk
+                        // The response body contains the current chunk.
+                        // The reply subject of the response indicates where we can get the next chunk
+                        requestResponse = _a.sent();
+                        dataSubject = requestResponse.reply;
+                        for (j = 0; j < requestResponse.data.length; j++) {
+                            result[bytesReceived++] = requestResponse.data[j];
                         }
                         _a.label = 3;
                     case 3:
                         i++;
                         return [3 /*break*/, 1];
                     case 4:
-                        // Send an empty message to acknowledge the final chunk was received
+                        // Send an empty message to acknowledge that the final chunk was received
                         this.connection.publish(dataSubject, Empty);
-                        if (k !== fd.fileSize) {
-                            return [2 /*return*/, Promise.reject("Unexpected repsonse size. Got ".concat(k, " bytes, but expected ").concat(fd.fileSize, "."))];
+                        if (bytesReceived !== fileDescriptor.fileSize) {
+                            return [2 /*return*/, Promise.reject("Unexpected repsonse size. Got ".concat(bytesReceived, " bytes, but expected ").concat(fileDescriptor.fileSize, "."))];
                         }
-                        // Avoid decoding the response if the expected response is bytearray
+                        // 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();
@@ -312,15 +329,17 @@ var BaseClient = /** @class */ (function () {
         });
     };
     /**
-     * Request an object to the nats server with chunks.
-     * @param subject The subject to request
-     * @param payload (optional)
-     * @param options (optional)
-     * @returns Promise of an object
+     * Make a request to the runner whose response will be sent in chunked
+     * @param subject The request subject
+     * @param payload Optional request body
+     * @param options Optional request options
+     * @param rawResponse If true, the return value will not be decoded
+     * @param fullSubject If true, the base subject will not be prepended
+     * @returns
      */
     BaseClient.prototype.requestChunked = function (subject, payload, options, rawResponse, fullSubject) {
         return __awaiter(this, void 0, void 0, function () {
-            var data, stringCodec, headers, opts, msg;
+            var data, stringCodec, headers, opts, requestResponse;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -342,8 +361,8 @@ var BaseClient = /** @class */ (function () {
                         opts = __assign(__assign({}, options), { timeout: this.timeout, headers: headers });
                         return [4 /*yield*/, this.connection.request(subject, data, opts)];
                     case 1:
-                        msg = _a.sent();
-                        return [2 /*return*/, this.receiveFile(msg, rawResponse, opts)];
+                        requestResponse = _a.sent();
+                        return [2 /*return*/, this.downloadChunkedRequest(requestResponse, rawResponse, opts)];
                 }
             });
         });

package/package.json

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