Resolve dependency cycles between actions-util and workflow

src/api-client.ts

@@ -1,15 +1,25 @@
+import * as os from "os";
+
 import * as core from "@actions/core";
 import * as githubUtils from "@actions/github/lib/utils";
 import * as retry from "@octokit/plugin-retry";
 import consoleLogLevel from "console-log-level";
 
 import {
+  ActionName,
+  ActionStatus,
   StatusReportBase,
   getActionVersion,
+  getOptionalInput,
+  getRef,
   getRequiredInput,
   getWorkflowEventName,
+  getWorkflowRunAttempt,
+  getWorkflowRunID,
 } from "./actions-util";
+import { EnvVar } from "./environment";
 import {
+  getCachedCodeQlVersion,
   getRequiredEnvParam,
   GITHUB_DOTCOM_URL,
   GitHubVariant,
@@ -17,6 +27,7 @@ import {
   isHTTPError,
   isInTestMode,
   parseGitHubUrl,
+  parseMatrixInput,
 } from "./util";
 
 const GITHUB_ENTERPRISE_VERSION_HEADER = "x-github-enterprise-version";
@@ -125,6 +136,99 @@ export async function getGitHubVersion(): Promise<GitHubVersion> {
   return cachedGitHubVersion;
 }
 
+/**
+ * Compose a StatusReport.
+ *
+ * @param actionName The name of the action, e.g. 'init', 'finish', 'upload-sarif'
+ * @param status The status. Must be 'success', 'failure', or 'starting'
+ * @param startedAt The time this action started executing.
+ * @param cause  Cause of failure (only supply if status is 'failure')
+ * @param exception Exception (only supply if status is 'failure')
+ */
+export async function createStatusReportBase(
+  actionName: ActionName,
+  status: ActionStatus,
+  actionStartedAt: Date,
+  cause?: string,
+  exception?: string
+): Promise<StatusReportBase> {
+  const commitOid = getOptionalInput("sha") || process.env["GITHUB_SHA"] || "";
+  const ref = await getRef();
+  const jobRunUUID = process.env[EnvVar.JOB_RUN_UUID] || "";
+  const workflowRunID = getWorkflowRunID();
+  const workflowRunAttempt = getWorkflowRunAttempt();
+  const workflowName = process.env["GITHUB_WORKFLOW"] || "";
+  const jobName = process.env["GITHUB_JOB"] || "";
+  const analysis_key = await getAnalysisKey();
+  let workflowStartedAt = process.env[EnvVar.WORKFLOW_STARTED_AT];
+  if (workflowStartedAt === undefined) {
+    workflowStartedAt = actionStartedAt.toISOString();
+    core.exportVariable(EnvVar.WORKFLOW_STARTED_AT, workflowStartedAt);
+  }
+  const runnerOs = getRequiredEnvParam("RUNNER_OS");
+  const codeQlCliVersion = getCachedCodeQlVersion();
+  const actionRef = process.env["GITHUB_ACTION_REF"];
+  const testingEnvironment = process.env[EnvVar.TESTING_ENVIRONMENT] || "";
+  // re-export the testing environment variable so that it is available to subsequent steps,
+  // even if it was only set for this step
+  if (testingEnvironment !== "") {
+    core.exportVariable(EnvVar.TESTING_ENVIRONMENT, testingEnvironment);
+  }
+
+  const statusReport: StatusReportBase = {
+    job_run_uuid: jobRunUUID,
+    workflow_run_id: workflowRunID,
+    workflow_run_attempt: workflowRunAttempt,
+    workflow_name: workflowName,
+    job_name: jobName,
+    analysis_key,
+    commit_oid: commitOid,
+    ref,
+    action_name: actionName,
+    action_ref: actionRef,
+    action_oid: "unknown", // TODO decide if it's possible to fill this in
+    started_at: workflowStartedAt,
+    action_started_at: actionStartedAt.toISOString(),
+    status,
+    testing_environment: testingEnvironment,
+    runner_os: runnerOs,
+    action_version: getActionVersion(),
+  };
+
+  // Add optional parameters
+  if (cause) {
+    statusReport.cause = cause;
+  }
+  if (exception) {
+    statusReport.exception = exception;
+  }
+  if (
+    status === "success" ||
+    status === "failure" ||
+    status === "aborted" ||
+    status === "user-error"
+  ) {
+    statusReport.completed_at = new Date().toISOString();
+  }
+  const matrix = getRequiredInput("matrix");
+  if (matrix) {
+    statusReport.matrix_vars = matrix;
+  }
+  if ("RUNNER_ARCH" in process.env) {
+    // RUNNER_ARCH is available only in GHES 3.4 and later
+    // Values other than X86, X64, ARM, or ARM64 are discarded server side
+    statusReport.runner_arch = process.env["RUNNER_ARCH"];
+  }
+  if (runnerOs === "Windows" || runnerOs === "macOS") {
+    statusReport.runner_os_release = os.release();
+  }
+  if (codeQlCliVersion !== undefined) {
+    statusReport.codeql_version = codeQlCliVersion;
+  }
+
+  return statusReport;
+}
+
 const GENERIC_403_MSG =
   "The repo on which this action is running is not opted-in to CodeQL code scanning.";
 const GENERIC_404_MSG =
@@ -212,3 +316,81 @@ export async function sendStatusReport<S extends StatusReportBase>(
     return true;
   }
 }
+
+/**
+ * Get the path of the currently executing workflow relative to the repository root.
+ */
+export async function getWorkflowRelativePath(): Promise<string> {
+  const repo_nwo = getRequiredEnvParam("GITHUB_REPOSITORY").split("/");
+  const owner = repo_nwo[0];
+  const repo = repo_nwo[1];
+  const run_id = Number(getRequiredEnvParam("GITHUB_RUN_ID"));
+
+  const apiClient = getApiClient();
+  const runsResponse = await apiClient.request(
+    "GET /repos/:owner/:repo/actions/runs/:run_id?exclude_pull_requests=true",
+    {
+      owner,
+      repo,
+      run_id,
+    }
+  );
+  const workflowUrl = runsResponse.data.workflow_url;
+
+  const workflowResponse = await apiClient.request(`GET ${workflowUrl}`);
+
+  return workflowResponse.data.path;
+}
+
+/**
+ * Get the analysis key parameter for the current job.
+ *
+ * This will combine the workflow path and current job name.
+ * Computing this the first time requires making requests to
+ * the GitHub API, but after that the result will be cached.
+ */
+export async function getAnalysisKey(): Promise<string> {
+  const analysisKeyEnvVar = "CODEQL_ACTION_ANALYSIS_KEY";
+
+  let analysisKey = process.env[analysisKeyEnvVar];
+  if (analysisKey !== undefined) {
+    return analysisKey;
+  }
+
+  const workflowPath = await getWorkflowRelativePath();
+  const jobName = getRequiredEnvParam("GITHUB_JOB");
+
+  analysisKey = `${workflowPath}:${jobName}`;
+  core.exportVariable(analysisKeyEnvVar, analysisKey);
+  return analysisKey;
+}
+
+export async function getAutomationID(): Promise<string> {
+  const analysis_key = await getAnalysisKey();
+  const environment = getRequiredInput("matrix");
+
+  return computeAutomationID(analysis_key, environment);
+}
+
+export function computeAutomationID(
+  analysis_key: string,
+  environment: string | undefined
+): string {
+  let automationID = `${analysis_key}/`;
+
+  const matrix = parseMatrixInput(environment);
+  if (matrix !== undefined) {
+    // the id has to be deterministic so we sort the fields
+    for (const entry of Object.entries(matrix).sort()) {
+      if (typeof entry[1] === "string") {
+        automationID += `${entry[0]}:${entry[1]}/`;
+      } else {
+        // In code scanning we just handle the string values,
+        // the rest get converted to the empty string
+        automationID += `${entry[0]}:/`;
+      }
+    }
+  }
+
+  return automationID;
+}