feat: Enable machine parsable output with --format json (#283)

* feat: enable machine parsable output with format json

Co-authored-by: Seth Vargo <[email protected]>

Author: verbanicm

package-lock.json

@@ -32,6 +32,7 @@
     "@actions/core": "^1.6.0",
     "@actions/exec": "^1.1.0",
     "@actions/tool-cache": "^1.7.1",
+    "@google-github-actions/actions-utils": "^0.1.2",
     "@google-github-actions/setup-cloud-sdk": "^0.3.1"
   },
   "devDependencies": {
@@ -45,9 +46,9 @@
     "@typescript-eslint/parser": "^5.7.0",
     "@zeit/ncc": "^0.22.3",
     "chai": "^4.3.4",
+    "eslint": "^8.4.1",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-prettier": "^4.0.0",
-    "eslint": "^8.4.1",
     "google-auth-library": "^7.10.4",
     "googleapis": "^92.0.0",
     "lodash": "^4.17.21",

package.json

@@ -19,10 +19,26 @@ import { getExecOutput } from '@actions/exec';
 import * as toolCache from '@actions/tool-cache';
 import * as setupGcloud from '@google-github-actions/setup-cloud-sdk';
 import path from 'path';
+import { parseDeployResponse, parseUpdateTrafficResponse } from './output-parser';
 
 export const GCLOUD_METRICS_ENV_VAR = 'CLOUDSDK_METRICS_ENVIRONMENT';
 export const GCLOUD_METRICS_LABEL = 'github-actions-deploy-cloudrun';
 
+/**
+ * DeployCloudRunOutputs are the common GitHub action outputs created by this action
+ */
+export interface DeployCloudRunOutputs {
+  url?: string | null | undefined; // Type required to match run_v1.Schema$Service.status.url
+}
+
+/**
+ * ResponseTypes are the gcloud command response formats
+ */
+enum ResponseTypes {
+  DEPLOY,
+  UPDATE_TRAFFIC,
+}
+
 /**
  * Executes the main action. It includes the main business logic and is the
  * primary entry point. It is documented inline.
@@ -59,8 +75,10 @@ export async function run(): Promise<void> {
       );
     }
 
+    let responseType = ResponseTypes.DEPLOY; // Default response type for output parsing
     let installBeta = false; // Flag for installing gcloud beta components
     let cmd;
+
     // Throw errors if inputs aren't valid
     if (revTraffic && tagTraffic) {
       throw new Error('Both `revision_traffic` and `tag_traffic` inputs set - Please select one.');
@@ -71,6 +89,9 @@ export async function run(): Promise<void> {
 
     // Find base command
     if (revTraffic || tagTraffic) {
+      // Set response type for output parsing
+      responseType = ResponseTypes.UPDATE_TRAFFIC;
+
       // Update traffic
       cmd = [
         'run',
@@ -181,6 +202,9 @@ export async function run(): Promise<void> {
       cmd.unshift('beta');
     }
 
+    // Set output format to json
+    cmd.push('--format', 'json');
+
     const toolCommand = setupGcloud.getToolCommand();
     const options = { silent: true };
     const commandString = `${toolCommand} ${cmd.join(' ')}`;
@@ -193,25 +217,24 @@ export async function run(): Promise<void> {
       throw new Error(`failed to execute gcloud command \`${commandString}\`: ${errMsg}`);
     }
 
-    // gcloud outputs status information to stderr.
-    // TODO: update this to use JSON or YAML machine-readable output instead.
-    setUrlOutput(output.stdout + output.stderr);
+    // Map outputs by response type
+    const outputs: DeployCloudRunOutputs =
+      responseType === ResponseTypes.UPDATE_TRAFFIC
+        ? parseUpdateTrafficResponse(output.stdout)
+        : parseDeployResponse(output.stdout, { tag: tag });
+
+    // Map outputs to GitHub actions output
+    setActionOutputs(outputs);
   } catch (error) {
     core.setFailed(convertUnknown(error));
   }
 }
 
-export function setUrlOutput(output: string): string | undefined {
-  // regex to match Cloud Run URLs
-  const urlMatch = output.match(/https:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.app/g);
-  if (!urlMatch) {
-    core.warning('Can not find URL.');
-    return undefined;
-  }
-  // Match "tagged" URL or default to service URL
-  const url = urlMatch!.length > 1 ? urlMatch![1] : urlMatch![0];
-  core.setOutput('url', url);
-  return url;
+// Map output response to GitHub Action outputs
+export function setActionOutputs(outputs: DeployCloudRunOutputs): void {
+  Object.keys(outputs).forEach((key: string) => {
+    core.setOutput(key, outputs[key as keyof DeployCloudRunOutputs]);
+  });
 }
 
 export function parseFlags(flags: string): RegExpMatchArray {

src/deploy-cloudrun.ts

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { DeployCloudRunOutputs } from './deploy-cloudrun';
+import { run_v1 } from 'googleapis';
+import { errorMessage, presence } from '@google-github-actions/actions-utils';
+
+/**
+ * ParseInputs are the input values from GitHub actions used for parsing logic
+ */
+export interface ParseInputs {
+  [key: string]: string | boolean;
+}
+
+/**
+ * UpdateTrafficItem is the response type for the gcloud run services update-traffic command
+ */
+interface UpdateTrafficItem {
+  displayPercent: string;
+  displayRevisionId: string;
+  displayTags: string;
+  key: string;
+  latestRevision: boolean;
+  revisionName: string;
+  serviceUrl: string;
+  specPercent: string;
+  specTags: string;
+  statusPercent: string;
+  statusTags: string;
+  tags: string[];
+  urls: string[];
+}
+
+/**
+ * parseUpdateTrafficResponse parses the gcloud command response for update-traffic
+ * into a common DeployCloudRunOutputs object
+ *
+ * @param stdout
+ * @returns DeployCloudRunOutputs
+ */
+export function parseUpdateTrafficResponse(stdout: string | undefined): DeployCloudRunOutputs {
+  try {
+    stdout = presence(stdout);
+    if (!stdout || stdout === '{}' || stdout === '[]') {
+      throw new Error(`invalid input received`);
+    }
+
+    const outputJSON: UpdateTrafficItem[] = JSON.parse(stdout);
+
+    // Default to service url
+    const responseItem = outputJSON[0];
+    let url = responseItem?.serviceUrl;
+
+    // Maintain current logic to use first tag URL if present
+    for (const item of outputJSON) {
+      if (item?.urls?.length) {
+        url = item.urls[0];
+        break;
+      }
+    }
+
+    const outputs: DeployCloudRunOutputs = { url: url };
+
+    return outputs;
+  } catch (err) {
+    const msg = errorMessage(err);
+    throw new Error(`failed to parse update traffic response: ${msg}, stdout: ${stdout}`);
+  }
+}
+
+/**
+ * parseDeployResponse parses the gcloud command response for gcloud run deploy/replace
+ * into a common DeployCloudRunOutputs object
+ *
+ * @param stdout Standard output from gcloud command
+ * @param inputs Action inputs used in parsing logic
+ * @returns DeployCloudRunOutputs
+ */
+export function parseDeployResponse(
+  stdout: string | undefined,
+  inputs: ParseInputs | undefined,
+): DeployCloudRunOutputs {
+  try {
+    stdout = presence(stdout);
+    if (!stdout || stdout === '{}' || stdout === '[]') {
+      throw new Error(`invalid input received`);
+    }
+
+    const outputJSON: run_v1.Schema$Service = JSON.parse(stdout);
+
+    // Set outputs
+    const outputs: DeployCloudRunOutputs = {
+      url: outputJSON?.status?.url,
+    };
+
+    // Maintain current logic to use tag url if provided
+    if (inputs?.tag) {
+      const tagInfo = outputJSON?.status?.traffic?.find((t) => t.tag === inputs.tag);
+      if (tagInfo) {
+        outputs.url = tagInfo.url;
+      }
+    }
+
+    return outputs;
+  } catch (err) {
+    const msg = errorMessage(err);
+    throw new Error(
+      `failed to parse deploy response: ${msg}, stdout: ${stdout}, inputs: ${JSON.stringify(
+        inputs,
+      )}`,
+    );
+  }
+}