feat: Add batch support

README.md

@@ -183,7 +183,7 @@ In order to use this tool,
 you must first `git checkout` the commit that you want to test.
 
 ```
-npx @aws-actions/codebuild-run-build -p ProjectName -r remoteName
+npx https://github.com/aws-actions/aws-codebuild-run-build.git -p ProjectName -r remoteName
 ```
 
 This will use whatever commit you have checked out

action.yml

@@ -10,6 +10,9 @@ inputs:
  buildspec-override:
  description: 'Buildspec Override'
  required: false
+ batch:
+ description: 'Run as an AWS CodeBuild batch'
+ required: false
  env-vars-for-codebuild:
  description: 'Comma separated list of environment variables to send to CodeBuild'
  required: false

code-build.js

@@ -9,7 +9,9 @@ const assert = require("assert");
 module.exports = {
  runBuild,
  build,
+ buildBatch,
  waitForBuildEndTime,
+ waitForBatchBuildEndTime,
  inputs2Parameters,
  githubInputs,
  buildSdk,
@@ -22,8 +24,13 @@ function runBuild() {
 
  // Get input options for startBuild
  const params = inputs2Parameters(githubInputs());
+ const isBatch = core.getInput("batch").toUpper() === "TRUE";
 
- return build(sdk, params);
+ if (isBatch) {
+ return buildBatch(sdk, params);
+ } else {
+ return build(sdk, params);
+ }
 }
 
 async function build(sdk, params) {
@@ -34,6 +41,113 @@ async function build(sdk, params) {
  return waitForBuildEndTime(sdk, start.build);
 }
 
+async function buildBatch(sdk, params) {
+ // Start the batch
+ const { buildBatch } = await sdk.codeBuild.startBuildBatch(params).promise();
+ const { id } = buildBatch;
+
+ // Wait for the batch to "complete"
+ return waitForBatchBuildEndTime(sdk, { id });
+}
+
+async function waitForBatchBuildEndTime(sdk, { id, observedBuilds = [] }) {
+ const { codeBuild, wait = 2000 } = sdk;
+
+ /* Batch builds take a long time,
+ * and there is a fare amount
+ * of eventual constancy involved.
+ * The first time I enter,
+ * I never expect this wait
+ * to impact performance.
+ * But for every recursive call,
+ * this wait makes a simple gate
+ * to keep from throttling myself.
+ */
+ await new Promise((resolve) => setTimeout(resolve, wait));
+
+ const { buildBatches } = await codeBuild
+ .batchGetBuildBatches({ ids: [id] })
+ .promise();
+ const [current] = buildBatches;
+ const { buildGroups } = current;
+
+ /* Immediately after the batch is started,
+ * the build group will be empty.
+ * I have to wait for the first build,
+ * that will process the list/matrix
+ * that start all the builds
+ * that do the work.
+ */
+ if (!buildGroups) return waitForBatchBuildEndTime(sdk, { id });
+
+ // The build ids I have not yet waited for.
+ const ids = buildGroups
+ .map(({ currentBuildSummary }) => currentBuildSummary.arn)
+ .filter((arn) => !observedBuilds.includes(arn));
+
+ /* Don't try and get the status of 0 builds.
+ * It would be nice to not have an if here,
+ * but it is nicer to not make the remote call.
+ */
+ if (ids.length) {
+ // Get the information for the builds to wait for
+ const { builds } = await codeBuild.batchGetBuilds({ ids }).promise();
+
+ for (const build of builds) {
+ console.log(`=========== START: ${build.id} =============`);
+ await waitForBuildEndTime(sdk, build)
+ /* Just because this build failed,
+ * I still need to stream the other results.
+ * waitForBuildEndTime is supposed to handle
+ * all retirable errors.
+ * It may be better to
+ * gather up these errors
+ * and throw when the batch has completed.
+ */
+ .catch((e) => {
+ console.log(`Error in build ${build.id}: ${e.stack} `);
+ });
+ console.log(`============================================`);
+ }
+
+ /* Update the observed builds
+ * since they have now been observed.
+ * The `currentBuildSummary` does not have the id.
+ * It only has the arn,
+ * so while the id is nice to pass around,
+ * the arn is what I want to keep here.
+ * Otherwise each build will need to be streamed twice.
+ */
+ observedBuilds = observedBuilds.concat(builds.map(({ arn }) => arn));
+ }
+
+ /* Just because I have processed
+ * all the builds in the buildGroup
+ * this does not mean
+ * that the batch is complete.
+ * This is especially true with the first build.
+ * The first build in the batch generally
+ * is how all the needed builds are calculated.
+ * So the first time I'm here,
+ * I expect to have 1 build.
+ * After that first build,
+ * I expect to recurse
+ * and then have the complete set.
+ * But why not just recurse until
+ * the batch is no longer in progress?
+ */
+ if (current.buildBatchStatus === "IN_PROGRESS")
+ return waitForBatchBuildEndTime(sdk, {
+ id,
+ observedBuilds,
+ });
+
+ /* If the batch is not IN_PROGRESS
+ * this is as good as it gets.
+ */
+ return current;
+}
+
 async function waitForBuildEndTime(sdk, { id, logs }, nextToken) {
  const {
  codeBuild,

local.js

@@ -8,7 +8,7 @@ const cb = require("./code-build");
 const assert = require("assert");
 const yargs = require("yargs");
 
-const { projectName, buildspecOverride, envPassthrough, remote } = yargs
+const { projectName, buildspecOverride, envPassthrough, remote, batch } = yargs
  .option("project-name", {
  alias: "p",
  describe: "AWS CodeBuild Project Name",
@@ -30,6 +30,11 @@ const { projectName, buildspecOverride, envPassthrough, remote } = yargs
  describe: "remote name to publish to",
  default: "origin",
  type: "string",
+ })
+ .option("batch", {
+ describe: "Run as AWS CodeBuild batch build",
+ type: "boolean",
+ default: false,
  }).argv;
 
 const BRANCH_NAME = uuid();
@@ -46,7 +51,8 @@ const sdk = cb.buildSdk();
 
 pushBranch(remote, BRANCH_NAME);
 
-cb.build(sdk, params)
+// Need to select batch or build mode
+(batch ? cb.buildBatch(sdk, params) : cb.build(sdk, params))
  .then(() => deleteBranch(remote, BRANCH_NAME))
  .catch((err) => {
  deleteBranch(remote, BRANCH_NAME);

test/code-build-test.js

@@ -6,6 +6,7 @@ const {
  githubInputs,
  inputs2Parameters,
  waitForBuildEndTime,
+ waitForBatchBuildEndTime,
 } = require("../code-build");
 const { expect } = require("chai");
 
@@ -418,7 +419,97 @@ describe("waitForBuildEndTime", () => {
  });
 });
 
-function help(builds, logs) {
+describe("waitForBatchBuildEndTime", () => {
+ it("basic usage", async () => {
+ const buildID = "buildID";
+ const cloudWatchLogsArn =
+ "arn:aws:logs:us-west-2:111122223333:log-group:/aws/codebuild/CloudWatchLogGroup:log-stream:1234abcd-12ab-34cd-56ef-1234567890ab";
+
+ const buildReplies = [
+ {
+ builds: [
+ {
+ id: buildID,
+ logs: { cloudWatchLogsArn },
+ endTime: "endTime",
+ arn: buildID,
+ },
+ ],
+ },
+ {
+ builds: [
+ {
+ id: buildID,
+ logs: { cloudWatchLogsArn },
+ endTime: "endTime",
+ arn: buildID,
+ },
+ ],
+ },
+ ];
+ const logReplies = [{ events: [] }];
+ const batchReplies = [
+ {
+ buildBatches: [{}],
+ },
+ {
+ buildBatches: [
+ {
+ buildBatchStatus: "IN_PROGRESS",
+ buildGroups: [
+ {
+ currentBuildSummary: {
+ arn: buildID,
+ },
+ },
+ ],
+ },
+ ],
+ },
+ {
+ buildBatches: [
+ {
+ buildBatchStatus: "SUCCESS",
+ buildGroups: [
+ {
+ currentBuildSummary: {
+ arn: buildID,
+ },
+ },
+ ],
+ },
+ ],
+ },
+ ];
+ let countBuild = 0;
+ let countLog = 0;
+ let countBatch = 0;
+ const sdk = help(
+ () => buildReplies[countBuild++],
+ () => logReplies[countLog++],
+ () => batchReplies[countBatch++]
+ );
+
+ const test = await waitForBatchBuildEndTime(sdk, {
+ id: buildID,
+ logs: { cloudWatchLogsArn },
+ });
+
+ expect(test).to.equal(batchReplies.pop().buildBatches[0]);
+
+ /* These counts extensively tests
+ * the underlying logic.
+ * Given the linearity
+ * of the function,
+ * I assert that this is adequate.
+ */
+ expect(countBuild).to.equal(2);
+ expect(countLog).to.equal(1);
+ expect(countBatch).to.equal(3);
+ });
+});
+
+function help(builds, logs, batches) {
  const codeBuild = {
  batchGetBuilds() {
  return {
@@ -427,6 +518,13 @@ function help(builds, logs) {
  },
  };
  },
+ batchGetBuildBatches() {
+ return {
+ async promise() {
+ return ret(batches);
+ },
+ };
+ },
  };
 
  const cloudWatchLogs = {

wallaby.conf.js

@@ -0,0 +1,12 @@
+// Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+module.exports = function () {
+ return {
+ files: ["./code-build.js"],
+ tests: ["test/code-build-test.js"],
+ testFramework: "mocha",
+ env: { type: "node" },
+ debug: true,
+ };
+};