continue building async-workflow support

dist/index.js

@@ -574,6 +574,13 @@ class Cli {
             return yield __1.CloudRunner.run(buildParameter, baseImage.toString());
         });
     }
+    static asyncronousWorkflow() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const buildParameter = yield __1.BuildParameters.create();
+            const baseImage = new __1.ImageTag(buildParameter);
+            return yield __1.CloudRunner.run(buildParameter, baseImage.toString());
+        });
+    }
     static GarbageCollect() {
         return __awaiter(this, void 0, void 0, function* () {
             const buildParameter = yield __1.BuildParameters.create();
@@ -629,6 +636,9 @@ __decorate([
 __decorate([
     cli_functions_repository_1.CliFunction(`cli-build`, `runs a cloud runner build`)
 ], Cli, "CLIBuild", null);
+__decorate([
+    cli_functions_repository_1.CliFunction(`async-workflow`, `runs a cloud runner build`)
+], Cli, "asyncronousWorkflow", null);
 __decorate([
     cli_functions_repository_1.CliFunction(`garbage-collect`, `runs garbage collection`)
 ], Cli, "GarbageCollect", null);
@@ -1593,7 +1603,7 @@ class AWSTaskRunner {
             cloud_runner_logger_1.default.log('Cloud runner job is starting');
             yield AWSTaskRunner.waitUntilTaskRunning(taskArn, cluster);
             cloud_runner_logger_1.default.log(`Cloud runner job status is running ${(_p = (yield AWSTaskRunner.describeTasks(cluster, taskArn))) === null || _p === void 0 ? void 0 : _p.lastStatus}`);
-            if (!cloud_runner_options_1.default.watchCloudRunnerToEnd) {
+            if (!cloud_runner_options_1.default.watchCloudRunnerToEnd || cloud_runner_options_1.default.asyncCloudRunner) {
                 const shouldCleanup = false;
                 const output = '';
                 cloud_runner_logger_1.default.log(`Watch Cloud Runner To End: false`);
@@ -5608,6 +5618,53 @@ exports.TaskParameterSerializer = TaskParameterSerializer;
 TaskParameterSerializer.blocked = new Set(['0', 'length', 'prototype', '', 'unityVersion']);
 
 
+/***/ }),
+
+/***/ 8231:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AsyncWorkflow = void 0;
+const cloud_runner_logger_1 = __importDefault(__nccwpck_require__(22855));
+const cloud_runner_folders_1 = __nccwpck_require__(13527);
+const cloud_runner_1 = __importDefault(__nccwpck_require__(79144));
+class AsyncWorkflow {
+    static runAsyncWorkflow(environmentVariables, secrets) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                cloud_runner_logger_1.default.log(`Cloud Runner is running async mode`);
+                let output = '';
+                output += yield cloud_runner_1.default.Provider.runTaskInWorkflow(cloud_runner_1.default.buildParameters.buildGuid, `ubuntu`, `apt-get update > /dev/null
+apt-get install -y curl tar tree npm git git-lfs jq git > /dev/null
+mkdir /builder
+git clone -q -b ${cloud_runner_1.default.buildParameters.cloudRunnerBranch} /builder "builder"
+node "builder/dist/index.js" -m async-workflow
+        `, `/${cloud_runner_folders_1.CloudRunnerFolders.buildVolumeFolder}`, `/${cloud_runner_folders_1.CloudRunnerFolders.buildVolumeFolder}/`, environmentVariables, secrets);
+                return output;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+}
+exports.AsyncWorkflow = AsyncWorkflow;
+
+
 /***/ }),
 
 /***/ 94655:
@@ -5831,10 +5888,15 @@ const cloud_runner_step_state_1 = __nccwpck_require__(50121);
 const custom_workflow_1 = __nccwpck_require__(3786);
 const build_automation_workflow_1 = __nccwpck_require__(94655);
 const cloud_runner_1 = __importDefault(__nccwpck_require__(79144));
+const cloud_runner_options_1 = __importDefault(__nccwpck_require__(96552));
+const async_workflow_1 = __nccwpck_require__(8231);
 class WorkflowCompositionRoot {
     run(cloudRunnerStepState) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                if (cloud_runner_options_1.default.asyncCloudRunner) {
+                    return yield async_workflow_1.AsyncWorkflow.runAsyncWorkflow(cloudRunnerStepState.environment, cloudRunnerStepState.secrets);
+                }
                 if (cloud_runner_1.default.buildParameters.customJob !== '') {
                     return yield custom_workflow_1.CustomWorkflow.runCustomJobFromString(cloud_runner_1.default.buildParameters.customJob, cloudRunnerStepState.environment, cloudRunnerStepState.secrets);
                 }

src/model/cli/cli.ts

@@ -109,6 +109,14 @@ export class Cli {
     return await CloudRunner.run(buildParameter, baseImage.toString());
   }
 
+  @CliFunction(`async-workflow`, `runs a cloud runner build`)
+  public static async asyncronousWorkflow(): Promise<string> {
+    const buildParameter = await BuildParameters.create();
+    const baseImage = new ImageTag(buildParameter);
+
+    return await CloudRunner.run(buildParameter, baseImage.toString());
+  }
+
   @CliFunction(`garbage-collect`, `runs garbage collection`)
   public static async GarbageCollect(): Promise<string> {
     const buildParameter = await BuildParameters.create();

src/model/cloud-runner/providers/aws/aws-task-runner.ts

@@ -58,7 +58,7 @@ class AWSTaskRunner {
     CloudRunnerLogger.log(
       `Cloud runner job status is running ${(await AWSTaskRunner.describeTasks(cluster, taskArn))?.lastStatus}`,
     );
-    if (!CloudRunnerOptions.watchCloudRunnerToEnd) {
+    if (!CloudRunnerOptions.watchCloudRunnerToEnd || CloudRunnerOptions.asyncCloudRunner) {
       const shouldCleanup: boolean = false;
       const output: string = '';
       CloudRunnerLogger.log(`Watch Cloud Runner To End: false`);

src/model/cloud-runner/workflows/async-workflow.ts

@@ -0,0 +1,37 @@
+import CloudRunnerSecret from '../services/cloud-runner-secret';
+import CloudRunnerEnvironmentVariable from '../services/cloud-runner-environment-variable';
+import CloudRunnerLogger from '../services/cloud-runner-logger';
+import { CloudRunnerFolders } from '../services/cloud-runner-folders';
+import CloudRunner from '../cloud-runner';
+
+export class AsyncWorkflow {
+  public static async runAsyncWorkflow(
+    environmentVariables: CloudRunnerEnvironmentVariable[],
+    secrets: CloudRunnerSecret[],
+  ): Promise<string> {
+    try {
+      CloudRunnerLogger.log(`Cloud Runner is running async mode`);
+
+      let output = '';
+
+      output += await CloudRunner.Provider.runTaskInWorkflow(
+        CloudRunner.buildParameters.buildGuid,
+        `ubuntu`,
+        `apt-get update > /dev/null
+apt-get install -y curl tar tree npm git git-lfs jq git > /dev/null
+mkdir /builder
+git clone -q -b ${CloudRunner.buildParameters.cloudRunnerBranch} /builder "builder"
+node "builder/dist/index.js" -m async-workflow
+        `,
+        `/${CloudRunnerFolders.buildVolumeFolder}`,
+        `/${CloudRunnerFolders.buildVolumeFolder}/`,
+        environmentVariables,
+        secrets,
+      );
+
+      return output;
+    } catch (error) {
+      throw error;
+    }
+  }
+}

src/model/cloud-runner/workflows/workflow-composition-root.ts

@@ -3,10 +3,16 @@ import { CustomWorkflow } from './custom-workflow';
 import { WorkflowInterface } from './workflow-interface';
 import { BuildAutomationWorkflow } from './build-automation-workflow';
 import CloudRunner from '../cloud-runner';
+import CloudRunnerOptions from '../cloud-runner-options';
+import { AsyncWorkflow } from './async-workflow';
 
 export class WorkflowCompositionRoot implements WorkflowInterface {
   async run(cloudRunnerStepState: CloudRunnerStepState) {
     try {
+      if (CloudRunnerOptions.asyncCloudRunner) {
+        return await AsyncWorkflow.runAsyncWorkflow(cloudRunnerStepState.environment, cloudRunnerStepState.secrets);
+      }
+
       if (CloudRunner.buildParameters.customJob !== '') {
         return await CustomWorkflow.runCustomJobFromString(
           CloudRunner.buildParameters.customJob,