Cloud Runner Develop - 1.0 R.C 1 (#437)

Release Candidate changeset 1 - For 1.0 Cloud Runner
2022-11-07 20:41:00 +00:00
parent 96555a0945
commit 4cca069ebb
76 changed files with 5325 additions and 2023 deletions
--- a/src/model/cloud-runner/workflows/build-automation-workflow.ts
+++ b/src/model/cloud-runner/workflows/build-automation-workflow.ts
@@ -1,32 +1,31 @@
 import CloudRunnerLogger from '../services/cloud-runner-logger';
 import { CloudRunnerFolders } from '../services/cloud-runner-folders';
 import { CloudRunnerStepState } from '../cloud-runner-step-state';
-import { CustomWorkflow } from './custom-workflow';
 import { WorkflowInterface } from './workflow-interface';
 import * as core from '@actions/core';
-import { CloudRunnerBuildCommandProcessor } from '../services/cloud-runner-build-command-process';
+import { CloudRunnerCustomHooks } from '../services/cloud-runner-custom-hooks';
 import path from 'path';
 import CloudRunner from '../cloud-runner';
+import CloudRunnerOptions from '../cloud-runner-options';
+import { CloudRunnerCustomSteps } from '../services/cloud-runner-custom-steps';

 export class BuildAutomationWorkflow implements WorkflowInterface {
  async run(cloudRunnerStepState: CloudRunnerStepState) {
    try {
-      return await BuildAutomationWorkflow.standardBuildAutomation(cloudRunnerStepState.image);
+      return await BuildAutomationWorkflow.standardBuildAutomation(cloudRunnerStepState.image, cloudRunnerStepState);
    } catch (error) {
      throw error;
    }
  }

-  private static async standardBuildAutomation(baseImage: any) {
+  private static async standardBuildAutomation(baseImage: any, cloudRunnerStepState: CloudRunnerStepState) {
+    // TODO accept post and pre build steps as yaml files in the repo
    try {
      CloudRunnerLogger.log(`Cloud Runner is running standard build automation`);

-      if (!CloudRunner.buildParameters.isCliMode) core.startGroup('pre build steps');
      let output = '';
-      if (CloudRunner.buildParameters.preBuildSteps !== '') {
-        output += await CustomWorkflow.runCustomJob(CloudRunner.buildParameters.preBuildSteps);
-      }
-      if (!CloudRunner.buildParameters.isCliMode) core.endGroup();
+
+      output += await CloudRunnerCustomSteps.RunPreBuildSteps(cloudRunnerStepState);
      CloudRunnerLogger.logWithTime('Configurable pre build step(s) time');

      if (!CloudRunner.buildParameters.isCliMode) core.startGroup('build');
@@ -34,23 +33,19 @@ export class BuildAutomationWorkflow implements WorkflowInterface {
      CloudRunnerLogger.logLine(` `);
      CloudRunnerLogger.logLine('Starting build automation job');

-      output += await CloudRunner.Provider.runTask(
+      output += await CloudRunner.Provider.runTaskInWorkflow(
        CloudRunner.buildParameters.buildGuid,
        baseImage.toString(),
        BuildAutomationWorkflow.BuildWorkflow,
        `/${CloudRunnerFolders.buildVolumeFolder}`,
        `/${CloudRunnerFolders.buildVolumeFolder}/`,
-        CloudRunner.cloudRunnerEnvironmentVariables,
-        CloudRunner.defaultSecrets,
+        cloudRunnerStepState.environment,
+        cloudRunnerStepState.secrets,
      );
      if (!CloudRunner.buildParameters.isCliMode) core.endGroup();
      CloudRunnerLogger.logWithTime('Build time');

-      if (!CloudRunner.buildParameters.isCliMode) core.startGroup('post build steps');
-      if (CloudRunner.buildParameters.postBuildSteps !== '') {
-        output += await CustomWorkflow.runCustomJob(CloudRunner.buildParameters.postBuildSteps);
-      }
-      if (!CloudRunner.buildParameters.isCliMode) core.endGroup();
+      output += await CloudRunnerCustomSteps.RunPostBuildSteps(cloudRunnerStepState);
      CloudRunnerLogger.logWithTime('Configurable post build step(s) time');

      CloudRunnerLogger.log(`Cloud Runner finished running standard build automation`);
@@ -62,62 +57,83 @@ export class BuildAutomationWorkflow implements WorkflowInterface {
  }

  private static get BuildWorkflow() {
-    const setupHooks = CloudRunnerBuildCommandProcessor.getHooks(CloudRunner.buildParameters.customJobHooks).filter(
-      (x) => x.step.includes(`setup`),
+    const setupHooks = CloudRunnerCustomHooks.getHooks(CloudRunner.buildParameters.customJobHooks).filter((x) =>
+      x.step.includes(`setup`),
    );
-    const buildHooks = CloudRunnerBuildCommandProcessor.getHooks(CloudRunner.buildParameters.customJobHooks).filter(
-      (x) => x.step.includes(`build`),
+    const buildHooks = CloudRunnerCustomHooks.getHooks(CloudRunner.buildParameters.customJobHooks).filter((x) =>
+      x.step.includes(`build`),
+    );
+    const builderPath = CloudRunnerFolders.ToLinuxFolder(
+      path.join(CloudRunnerFolders.builderPathAbsolute, 'dist', `index.js`),
    );
-    const builderPath = path.join(CloudRunnerFolders.builderPathAbsolute, 'dist', `index.js`).replace(/\\/g, `/`);

    return `apt-get update > /dev/null
-      apt-get install -y tar tree npm git-lfs jq git > /dev/null
-      npm install -g n > /dev/null
-      n stable > /dev/null
+      apt-get install -y curl tar tree npm git-lfs jq git > /dev/null
+      npm i -g n > /dev/null
+      n 16.15.1 > /dev/null
+      npm --version
+      node --version
+      ${BuildAutomationWorkflow.TreeCommand}
      ${setupHooks.filter((x) => x.hook.includes(`before`)).map((x) => x.commands) || ' '}
-      export GITHUB_WORKSPACE="${CloudRunnerFolders.repoPathAbsolute.replace(/\\/g, `/`)}"
+      export GITHUB_WORKSPACE="${CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.repoPathAbsolute)}"
      ${BuildAutomationWorkflow.setupCommands(builderPath)}
      ${setupHooks.filter((x) => x.hook.includes(`after`)).map((x) => x.commands) || ' '}
+      ${BuildAutomationWorkflow.TreeCommand}
      ${buildHooks.filter((x) => x.hook.includes(`before`)).map((x) => x.commands) || ' '}
-      ${BuildAutomationWorkflow.BuildCommands(builderPath, CloudRunner.buildParameters.buildGuid)}
-      ${buildHooks.filter((x) => x.hook.includes(`after`)).map((x) => x.commands) || ' '}`;
+      ${BuildAutomationWorkflow.BuildCommands(builderPath)}
+      ${buildHooks.filter((x) => x.hook.includes(`after`)).map((x) => x.commands) || ' '}
+      ${BuildAutomationWorkflow.TreeCommand}`;
  }

  private static setupCommands(builderPath) {
-    return `export GIT_DISCOVERY_ACROSS_FILESYSTEM=1
-    echo "game ci cloud runner clone"
-    mkdir -p ${CloudRunnerFolders.builderPathAbsolute.replace(/\\/g, `/`)}
-    git clone -q -b ${CloudRunner.buildParameters.cloudRunnerBranch} ${
+    const commands = `mkdir -p ${CloudRunnerFolders.ToLinuxFolder(
+      CloudRunnerFolders.builderPathAbsolute,
+    )} && git clone -q -b ${CloudRunner.buildParameters.cloudRunnerBranch} ${
      CloudRunnerFolders.unityBuilderRepoUrl
-    } "${CloudRunnerFolders.builderPathAbsolute.replace(/\\/g, `/`)}"
-    chmod +x ${builderPath}
-    echo "game ci cloud runner bootstrap"
-    node ${builderPath} -m remote-cli`;
+    } "${CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.builderPathAbsolute)}" && chmod +x ${builderPath}`;
+
+    const retainedWorkspaceCommands = `if [ -e "${CloudRunnerFolders.ToLinuxFolder(
+      CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute,
+    )}" ] && [ -e "${CloudRunnerFolders.ToLinuxFolder(
+      path.join(CloudRunnerFolders.repoPathAbsolute, `.git`),
+    )}" ]; then echo "Retained Workspace Already Exists!" ; fi`;
+
+    const cloneBuilderCommands = `if [ -e "${CloudRunnerFolders.ToLinuxFolder(
+      CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute,
+    )}" ] && [ -e "${CloudRunnerFolders.ToLinuxFolder(
+      path.join(CloudRunnerFolders.builderPathAbsolute, `.git`),
+    )}" ]; then echo "Builder Already Exists!"; else ${commands}; fi`;
+
+    return `export GIT_DISCOVERY_ACROSS_FILESYSTEM=1
+    echo "downloading game-ci..."
+    ${retainedWorkspaceCommands}
+    ${cloneBuilderCommands}
+    echo "bootstrap game ci cloud runner..."
+    node ${builderPath} -m remote-cli-pre-build`;
  }

-  private static BuildCommands(builderPath, guid) {
-    const linuxCacheFolder = CloudRunnerFolders.cacheFolderFull.replace(/\\/g, `/`);
+  private static BuildCommands(builderPath) {
    const distFolder = path.join(CloudRunnerFolders.builderPathAbsolute, 'dist');
    const ubuntuPlatformsFolder = path.join(CloudRunnerFolders.builderPathAbsolute, 'dist', 'platforms', 'ubuntu');

-    return `echo "game ci cloud runner init"
-    mkdir -p ${`${CloudRunnerFolders.projectBuildFolderAbsolute}/build`.replace(/\\/g, `/`)}
-    cd ${CloudRunnerFolders.projectPathAbsolute}
-    cp -r "${path.join(distFolder, 'default-build-script').replace(/\\/g, `/`)}" "/UnityBuilderAction"
-    cp -r "${path.join(ubuntuPlatformsFolder, 'entrypoint.sh').replace(/\\/g, `/`)}" "/entrypoint.sh"
-    cp -r "${path.join(ubuntuPlatformsFolder, 'steps').replace(/\\/g, `/`)}" "/steps"
+    return `echo "game ci cloud runner initalized"
+    mkdir -p ${`${CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.projectBuildFolderAbsolute)}/build`}
+    cd ${CloudRunnerFolders.ToLinuxFolder(CloudRunnerFolders.projectPathAbsolute)}
+    cp -r "${CloudRunnerFolders.ToLinuxFolder(path.join(distFolder, 'default-build-script'))}" "/UnityBuilderAction"
+    cp -r "${CloudRunnerFolders.ToLinuxFolder(path.join(ubuntuPlatformsFolder, 'entrypoint.sh'))}" "/entrypoint.sh"
+    cp -r "${CloudRunnerFolders.ToLinuxFolder(path.join(ubuntuPlatformsFolder, 'steps'))}" "/steps"
    chmod -R +x "/entrypoint.sh"
    chmod -R +x "/steps"
-    echo "game ci cloud runner start"
+    echo "game ci start"
    /entrypoint.sh
-    echo "game ci cloud runner push library to cache"
+    echo "game ci caching results"
    chmod +x ${builderPath}
-    node ${builderPath} -m cache-push --cachePushFrom ${
-      CloudRunnerFolders.libraryFolderAbsolute
-    } --artifactName lib-${guid} --cachePushTo ${linuxCacheFolder}/Library
-    echo "game ci cloud runner push build to cache"
-    node ${builderPath} -m cache-push --cachePushFrom ${
-      CloudRunnerFolders.projectBuildFolderAbsolute
-    } --artifactName build-${guid} --cachePushTo ${`${linuxCacheFolder}/build`.replace(/\\/g, `/`)}`;
+    node ${builderPath} -m remote-cli-post-build`;
+  }
+
+  private static get TreeCommand(): string {
+    return CloudRunnerOptions.cloudRunnerDebugTree
+      ? `tree -L 2 ${CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute} && tree -L 2 ${CloudRunnerFolders.cacheFolderForCacheKeyFull} && du -h -s /${CloudRunnerFolders.buildVolumeFolder}/ && du -h -s ${CloudRunnerFolders.cacheFolderForAllFull}`
+      : `#`;
  }
 }