🔊 Add some logging for the current status

Author: boredland

dist/action.js

@@ -17627,12 +17627,12 @@ var require_lib = __commonJS({
             throw new Error("Client has already been disposed.");
           }
           const parsedUrl = new URL(requestUrl);
-          let info = this._prepareRequest(verb, parsedUrl, headers);
+          let info2 = this._prepareRequest(verb, parsedUrl, headers);
           const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb) ? this._maxRetries + 1 : 1;
           let numTries = 0;
           let response;
           do {
-            response = yield this.requestRaw(info, data);
+            response = yield this.requestRaw(info2, data);
             if (response && response.message && response.message.statusCode === HttpCodes.Unauthorized) {
               let authenticationHandler;
               for (const handler of this.handlers) {
@@ -17642,7 +17642,7 @@ var require_lib = __commonJS({
                 }
               }
               if (authenticationHandler) {
-                return authenticationHandler.handleAuthentication(this, info, data);
+                return authenticationHandler.handleAuthentication(this, info2, data);
               } else {
                 return response;
               }
@@ -17665,8 +17665,8 @@ var require_lib = __commonJS({
                   }
                 }
               }
-              info = this._prepareRequest(verb, parsedRedirectUrl, headers);
-              response = yield this.requestRaw(info, data);
+              info2 = this._prepareRequest(verb, parsedRedirectUrl, headers);
+              response = yield this.requestRaw(info2, data);
               redirectsRemaining--;
             }
             if (!response.message.statusCode || !HttpResponseRetryCodes.includes(response.message.statusCode)) {
@@ -17695,7 +17695,7 @@ var require_lib = __commonJS({
        * @param info
        * @param data
        */
-      requestRaw(info, data) {
+      requestRaw(info2, data) {
         return __awaiter(this, void 0, void 0, function* () {
           return new Promise((resolve, reject) => {
             function callbackForResult(err, res) {
@@ -17707,7 +17707,7 @@ var require_lib = __commonJS({
                 resolve(res);
               }
             }
-            this.requestRawWithCallback(info, data, callbackForResult);
+            this.requestRawWithCallback(info2, data, callbackForResult);
           });
         });
       }
@@ -17717,12 +17717,12 @@ var require_lib = __commonJS({
        * @param data
        * @param onResult
        */
-      requestRawWithCallback(info, data, onResult) {
+      requestRawWithCallback(info2, data, onResult) {
         if (typeof data === "string") {
-          if (!info.options.headers) {
-            info.options.headers = {};
+          if (!info2.options.headers) {
+            info2.options.headers = {};
           }
-          info.options.headers["Content-Length"] = Buffer.byteLength(data, "utf8");
+          info2.options.headers["Content-Length"] = Buffer.byteLength(data, "utf8");
         }
         let callbackCalled = false;
         function handleResult(err, res) {
@@ -17731,7 +17731,7 @@ var require_lib = __commonJS({
             onResult(err, res);
           }
         }
-        const req = info.httpModule.request(info.options, (msg) => {
+        const req = info2.httpModule.request(info2.options, (msg) => {
           const res = new HttpClientResponse(msg);
           handleResult(void 0, res);
         });
@@ -17743,7 +17743,7 @@ var require_lib = __commonJS({
           if (socket) {
             socket.end();
           }
-          handleResult(new Error(`Request timeout: ${info.options.path}`));
+          handleResult(new Error(`Request timeout: ${info2.options.path}`));
         });
         req.on("error", function(err) {
           handleResult(err);
@@ -17779,27 +17779,27 @@ var require_lib = __commonJS({
         return this._getProxyAgentDispatcher(parsedUrl, proxyUrl);
       }
       _prepareRequest(method, requestUrl, headers) {
-        const info = {};
-        info.parsedUrl = requestUrl;
-        const usingSsl = info.parsedUrl.protocol === "https:";
-        info.httpModule = usingSsl ? https : http;
+        const info2 = {};
+        info2.parsedUrl = requestUrl;
+        const usingSsl = info2.parsedUrl.protocol === "https:";
+        info2.httpModule = usingSsl ? https : http;
         const defaultPort = usingSsl ? 443 : 80;
-        info.options = {};
-        info.options.host = info.parsedUrl.hostname;
-        info.options.port = info.parsedUrl.port ? parseInt(info.parsedUrl.port) : defaultPort;
-        info.options.path = (info.parsedUrl.pathname || "") + (info.parsedUrl.search || "");
-        info.options.method = method;
-        info.options.headers = this._mergeHeaders(headers);
+        info2.options = {};
+        info2.options.host = info2.parsedUrl.hostname;
+        info2.options.port = info2.parsedUrl.port ? parseInt(info2.parsedUrl.port) : defaultPort;
+        info2.options.path = (info2.parsedUrl.pathname || "") + (info2.parsedUrl.search || "");
+        info2.options.method = method;
+        info2.options.headers = this._mergeHeaders(headers);
         if (this.userAgent != null) {
-          info.options.headers["user-agent"] = this.userAgent;
+          info2.options.headers["user-agent"] = this.userAgent;
         }
-        info.options.agent = this._getAgent(info.parsedUrl);
+        info2.options.agent = this._getAgent(info2.parsedUrl);
         if (this.handlers) {
           for (const handler of this.handlers) {
-            handler.prepareRequest(info.options);
+            handler.prepareRequest(info2.options);
           }
         }
-        return info;
+        return info2;
       }
       _mergeHeaders(headers) {
         if (this.requestOptions && this.requestOptions.headers) {
@@ -19789,10 +19789,10 @@ Support boolean input list: \`true | True | TRUE | false | False | FALSE\``);
       (0, command_1.issueCommand)("notice", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message);
     }
     exports2.notice = notice;
-    function info(message) {
+    function info2(message) {
       process.stdout.write(message + os.EOL);
     }
-    exports2.info = info;
+    exports2.info = info2;
     function startGroup(name) {
       (0, command_1.issue)("group", name);
     }
@@ -19924,7 +19924,7 @@ void (async () => {
     (deployment) => deployment.deployment_uuid
   );
   const status = Object.fromEntries(
-    deploymentUUIDs.map((uuid2) => [uuid2, "pending"])
+    deploymentUUIDs.map((uuid2) => [uuid2, "queued"])
   );
   const endTime = Date.now() + waitTimeSeconds * 1e3;
   const pause = 5e3;
@@ -19934,10 +19934,16 @@ void (async () => {
       process.exit(1);
     }
     for (const uuid2 of deploymentUUIDs.filter(
-      (uuid3) => status[uuid3] !== "finished"
+      (uuid3) => status[uuid3] !== "finished" && status[uuid3] !== "failed"
     )) {
-      status[uuid2] = await getDeploymentStatus(uuid2);
-      (0, import_core.debug)(`Deployment ${uuid2} status: ${status[uuid2]}`);
+      const nextStatus = await getDeploymentStatus(uuid2);
+      if (nextStatus !== status[uuid2]) {
+        (0, import_core.info)(`Deployment ${uuid2} status: ${nextStatus}`);
+        status[uuid2] = nextStatus;
+      }
+      if (status[uuid2] === "failed") {
+        (0, import_core.setFailed)(`Deployment ${uuid2} failed`);
+      }
     }
     await new Promise((resolve) => setTimeout(resolve, pause));
   }

src/action.ts

@@ -1,4 +1,4 @@
-import { debug, getInput, setFailed } from "@actions/core";
+import { debug, getInput, info, setFailed } from "@actions/core";
 
 const waitTimeSeconds = Number.parseInt(getInput("wait", { required: false }));
 const apiKey = getInput("api-key", { required: true });
@@ -96,7 +96,7 @@ void (async () => {
   );
 
   const status = Object.fromEntries(
-    deploymentUUIDs.map((uuid) => [uuid, "pending"]),
+    deploymentUUIDs.map((uuid) => [uuid, "queued"]),
   );
   const endTime = Date.now() + waitTimeSeconds * 1000;
   // Pause between attempts
@@ -109,10 +109,17 @@ void (async () => {
     }
 
     for (const uuid of deploymentUUIDs.filter(
-      (uuid) => status[uuid] !== "finished",
+      (uuid) => status[uuid] !== "finished" && status[uuid] !== "failed",
     )) {
-      status[uuid] = await getDeploymentStatus(uuid);
-      debug(`Deployment ${uuid} status: ${status[uuid]}`);
+      const nextStatus = await getDeploymentStatus(uuid);
+      if (nextStatus !== status[uuid]) {
+        info(`Deployment ${uuid} status: ${nextStatus}`);
+        status[uuid] = nextStatus;
+      }
+
+      if (status[uuid] === "failed") {
+        setFailed(`Deployment ${uuid} failed`);
+      }
     }
 
     await new Promise((resolve) => setTimeout(resolve, pause));