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

Release Candidate changeset 1 - For 1.0 Cloud Runner

src/model/cloud-runner/services/cloud-runner-build-command-process.ts

@@ -1,43 +0,0 @@
-import { BuildParameters } from '../..';
-import YAML from 'yaml';
-import CloudRunnerSecret from './cloud-runner-secret';
-import CloudRunner from '../cloud-runner';
-
-export class CloudRunnerBuildCommandProcessor {
-  public static ProcessCommands(commands: string, buildParameters: BuildParameters): string {
-    const hooks = CloudRunnerBuildCommandProcessor.getHooks(buildParameters.customJobHooks).filter((x) =>
-      x.step.includes(`all`),
-    );
-
-    return `echo "---"
-      echo "start cloud runner init"
-      ${CloudRunner.buildParameters.cloudRunnerIntegrationTests ? '' : '#'} printenv
-      echo "start of cloud runner job"
-      ${hooks.filter((x) => x.hook.includes(`before`)).map((x) => x.commands) || ' '}
-      ${commands}
-      ${hooks.filter((x) => x.hook.includes(`after`)).map((x) => x.commands) || ' '}
-      echo "end of cloud runner job"
-      echo "---${buildParameters.logId}"`;
-  }
-
-  public static getHooks(customJobHooks): Hook[] {
-    const experimentHooks = customJobHooks;
-    let output = new Array<Hook>();
-    if (experimentHooks && experimentHooks !== '') {
-      try {
-        output = YAML.parse(experimentHooks);
-      } catch (error) {
-        throw error;
-      }
-    }
-
-    return output.filter((x) => x.step !== undefined && x.hook !== undefined && x.hook.length > 0);
-  }
-}
-export class Hook {
-  public commands;
-  public secrets: CloudRunnerSecret[] = new Array<CloudRunnerSecret>();
-  public name;
-  public hook!: string[];
-  public step!: string[];
-}

src/model/cloud-runner/services/cloud-runner-custom-hooks.ts

@@ -0,0 +1,117 @@
+import { BuildParameters, Input } from '../..';
+import YAML from 'yaml';
+import CloudRunnerSecret from './cloud-runner-secret';
+import { RemoteClientLogger } from '../remote-client/remote-client-logger';
+import path from 'path';
+import CloudRunnerOptions from '../cloud-runner-options';
+import * as fs from 'fs';
+import CloudRunnerLogger from './cloud-runner-logger';
+
+export class CloudRunnerCustomHooks {
+  // TODO also accept hooks as yaml files in the repo
+  public static ApplyHooksToCommands(commands: string, buildParameters: BuildParameters): string {
+    const hooks = CloudRunnerCustomHooks.getHooks(buildParameters.customJobHooks).filter((x) => x.step.includes(`all`));
+
+    return `echo "---"
+      echo "start cloud runner init"
+      ${CloudRunnerOptions.cloudRunnerDebugEnv ? `printenv` : `#`}
+      echo "start of cloud runner job"
+      ${hooks.filter((x) => x.hook.includes(`before`)).map((x) => x.commands) || ' '}
+      ${commands}
+      ${hooks.filter((x) => x.hook.includes(`after`)).map((x) => x.commands) || ' '}
+      echo "end of cloud runner job"
+      echo "---${buildParameters.logId}"`;
+  }
+
+  public static getHooks(customJobHooks): Hook[] {
+    const experimentHooks = customJobHooks;
+    let output = new Array<Hook>();
+    if (experimentHooks && experimentHooks !== '') {
+      try {
+        output = YAML.parse(experimentHooks);
+      } catch (error) {
+        throw error;
+      }
+    }
+
+    return output.filter((x) => x.step !== undefined && x.hook !== undefined && x.hook.length > 0);
+  }
+
+  static GetCustomHooksFromFiles(hookLifecycle: string): Hook[] {
+    const results: Hook[] = [];
+    RemoteClientLogger.log(`GetCustomStepFiles: ${hookLifecycle}`);
+    try {
+      const gameCiCustomStepsPath = path.join(process.cwd(), `game-ci`, `hooks`);
+      const files = fs.readdirSync(gameCiCustomStepsPath);
+      for (const file of files) {
+        if (!CloudRunnerOptions.customHookFiles.includes(file.replace(`.yaml`, ``))) {
+          continue;
+        }
+        const fileContents = fs.readFileSync(path.join(gameCiCustomStepsPath, file), `utf8`);
+        const fileContentsObject = CloudRunnerCustomHooks.ParseHooks(fileContents)[0];
+        if (fileContentsObject.hook.includes(hookLifecycle)) {
+          results.push(fileContentsObject);
+        }
+      }
+    } catch (error) {
+      RemoteClientLogger.log(`Failed Getting: ${hookLifecycle} \n ${JSON.stringify(error, undefined, 4)}`);
+    }
+    RemoteClientLogger.log(`Active Steps From Files: \n ${JSON.stringify(results, undefined, 4)}`);
+
+    return results;
+  }
+
+  private static ConvertYamlSecrets(object) {
+    if (object.secrets === undefined) {
+      object.secrets = [];
+
+      return;
+    }
+    object.secrets = object.secrets.map((x) => {
+      return {
+        ParameterKey: x.name,
+        EnvironmentVariable: Input.ToEnvVarFormat(x.name),
+        ParameterValue: x.value,
+      };
+    });
+  }
+
+  public static ParseHooks(steps: string): Hook[] {
+    if (steps === '') {
+      return [];
+    }
+
+    // if (CloudRunner.buildParameters?.cloudRunnerIntegrationTests) {
+
+    CloudRunnerLogger.log(`Parsing build hooks: ${steps}`);
+
+    // }
+    const isArray = steps.replace(/\s/g, ``)[0] === `-`;
+    const object: Hook[] = isArray ? YAML.parse(steps) : [YAML.parse(steps)];
+    for (const hook of object) {
+      CloudRunnerCustomHooks.ConvertYamlSecrets(hook);
+      if (hook.secrets === undefined) {
+        hook.secrets = [];
+      }
+    }
+    if (object === undefined) {
+      throw new Error(`Failed to parse ${steps}`);
+    }
+
+    return object;
+  }
+
+  public static getSecrets(hooks) {
+    const secrets = hooks.map((x) => x.secrets).filter((x) => x !== undefined && x.length > 0);
+
+    // eslint-disable-next-line unicorn/no-array-reduce
+    return secrets.length > 0 ? secrets.reduce((x, y) => [...x, ...y]) : [];
+  }
+}
+export class Hook {
+  public commands;
+  public secrets: CloudRunnerSecret[] = new Array<CloudRunnerSecret>();
+  public name;
+  public hook!: string[];
+  public step!: string[];
+}

src/model/cloud-runner/services/cloud-runner-custom-steps.ts

@@ -0,0 +1,206 @@
+import YAML from 'yaml';
+import CloudRunnerSecret from './cloud-runner-secret';
+import CloudRunner from '../cloud-runner';
+import * as core from '@actions/core';
+import { CustomWorkflow } from '../workflows/custom-workflow';
+import { RemoteClientLogger } from '../remote-client/remote-client-logger';
+import path from 'path';
+import * as fs from 'fs';
+import Input from '../../input';
+import CloudRunnerOptions from '../cloud-runner-options';
+
+export class CloudRunnerCustomSteps {
+  static GetCustomStepsFromFiles(hookLifecycle: string): CustomStep[] {
+    const results: CustomStep[] = [];
+    RemoteClientLogger.log(
+      `GetCustomStepFiles: ${hookLifecycle} CustomStepFiles: ${CloudRunnerOptions.customStepFiles}`,
+    );
+    try {
+      const gameCiCustomStepsPath = path.join(process.cwd(), `game-ci`, `steps`);
+      const files = fs.readdirSync(gameCiCustomStepsPath);
+      for (const file of files) {
+        if (!CloudRunnerOptions.customStepFiles.includes(file.replace(`.yaml`, ``))) {
+          RemoteClientLogger.log(`Skipping CustomStepFile: ${file}`);
+          continue;
+        }
+        const fileContents = fs.readFileSync(path.join(gameCiCustomStepsPath, file), `utf8`);
+        const fileContentsObject = CloudRunnerCustomSteps.ParseSteps(fileContents)[0];
+        if (fileContentsObject.hook === hookLifecycle) {
+          results.push(fileContentsObject);
+        }
+      }
+    } catch (error) {
+      RemoteClientLogger.log(`Failed Getting: ${hookLifecycle} \n ${JSON.stringify(error, undefined, 4)}`);
+    }
+    RemoteClientLogger.log(`Active Steps From Files: \n ${JSON.stringify(results, undefined, 4)}`);
+
+    const builtInCustomSteps: CustomStep[] = CloudRunnerCustomSteps.ParseSteps(
+      `- name: aws-s3-upload-build
+  image: amazon/aws-cli
+  hook: after
+  commands: |
+    aws configure set aws_access_key_id $AWS_ACCESS_KEY_ID --profile default
+    aws configure set aws_secret_access_key $AWS_SECRET_ACCESS_KEY --profile default
+    aws configure set region $AWS_DEFAULT_REGION --profile default
+    aws s3 cp /data/cache/$CACHE_KEY/build/build-$BUILD_GUID.tar.lz4 s3://game-ci-test-storage/cloud-runner-cache/$CACHE_KEY/build/build-$BUILD_GUID.tar.lz4
+    rm /data/cache/$CACHE_KEY/build/build-$BUILD_GUID.tar.lz4
+  secrets:
+  - name: awsAccessKeyId
+    value: ${process.env.AWS_ACCESS_KEY_ID || ``}
+  - name: awsSecretAccessKey
+    value: ${process.env.AWS_SECRET_ACCESS_KEY || ``}
+  - name: awsDefaultRegion
+    value: ${process.env.AWS_REGION || ``}
+- name: aws-s3-upload-cache
+  image: amazon/aws-cli
+  hook: after
+  commands: |
+    aws configure set aws_access_key_id $AWS_ACCESS_KEY_ID --profile default
+    aws configure set aws_secret_access_key $AWS_SECRET_ACCESS_KEY --profile default
+    aws configure set region $AWS_DEFAULT_REGION --profile default
+    aws s3 cp --recursive /data/cache/$CACHE_KEY/lfs s3://game-ci-test-storage/cloud-runner-cache/$CACHE_KEY/lfs
+    rm -r /data/cache/$CACHE_KEY/lfs
+    aws s3 cp --recursive /data/cache/$CACHE_KEY/Library s3://game-ci-test-storage/cloud-runner-cache/$CACHE_KEY/Library
+    rm -r /data/cache/$CACHE_KEY/Library
+  secrets:
+  - name: awsAccessKeyId
+    value: ${process.env.AWS_ACCESS_KEY_ID || ``}
+  - name: awsSecretAccessKey
+    value: ${process.env.AWS_SECRET_ACCESS_KEY || ``}
+  - name: awsDefaultRegion
+    value: ${process.env.AWS_REGION || ``}
+- name: aws-s3-pull-cache
+  image: amazon/aws-cli
+  hook: before
+  commands: |
+    aws configure set aws_access_key_id $AWS_ACCESS_KEY_ID --profile default
+    aws configure set aws_secret_access_key $AWS_SECRET_ACCESS_KEY --profile default
+    aws configure set region $AWS_DEFAULT_REGION --profile default
+    aws s3 ls game-ci-test-storage/cloud-runner-cache/ || true
+    aws s3 ls game-ci-test-storage/cloud-runner-cache/$CACHE_KEY/ || true
+    BUCKET1="game-ci-test-storage/cloud-runner-cache/$CACHE_KEY/Library/"
+    aws s3 ls $BUCKET1 || true
+    OBJECT1="$(aws s3 ls $BUCKET1 | sort | tail -n 1 | awk '{print $4}' || '')"
+    aws s3 cp s3://$BUCKET1$OBJECT1 /data/cache/$CACHE_KEY/Library/ || true
+    BUCKET2="game-ci-test-storage/cloud-runner-cache/$CACHE_KEY/lfs/"
+    aws s3 ls $BUCKET2 || true
+    OBJECT2="$(aws s3 ls $BUCKET2 | sort | tail -n 1 | awk '{print $4}' || '')"
+    aws s3 cp s3://$BUCKET2$OBJECT2 /data/cache/$CACHE_KEY/lfs/ || true
+  secrets:
+  - name: awsAccessKeyId
+    value: ${process.env.AWS_ACCESS_KEY_ID || ``}
+  - name: awsSecretAccessKey
+    value: ${process.env.AWS_SECRET_ACCESS_KEY || ``}
+  - name: awsDefaultRegion
+    value: ${process.env.AWS_REGION || ``}
+- name: debug-cache
+  image: ubuntu
+  hook: after
+  commands: |
+    apt-get update > /dev/null
+    ${CloudRunnerOptions.cloudRunnerDebugTree ? `apt-get install -y tree > /dev/null` : `#`}
+    ${CloudRunnerOptions.cloudRunnerDebugTree ? `tree -L 3 /data/cache` : `#`}
+  secrets:
+  - name: awsAccessKeyId
+    value: ${process.env.AWS_ACCESS_KEY_ID || ``}
+  - name: awsSecretAccessKey
+    value: ${process.env.AWS_SECRET_ACCESS_KEY || ``}
+  - name: awsDefaultRegion
+    value: ${process.env.AWS_REGION || ``}`,
+    ).filter((x) => CloudRunnerOptions.customStepFiles.includes(x.name) && x.hook === hookLifecycle);
+    if (builtInCustomSteps.length > 0) {
+      results.push(...builtInCustomSteps);
+    }
+
+    return results;
+  }
+
+  private static ConvertYamlSecrets(object) {
+    if (object.secrets === undefined) {
+      object.secrets = [];
+
+      return;
+    }
+    object.secrets = object.secrets.map((x) => {
+      return {
+        ParameterKey: x.name,
+        EnvironmentVariable: Input.ToEnvVarFormat(x.name),
+        ParameterValue: x.value,
+      };
+    });
+  }
+
+  public static ParseSteps(steps: string): CustomStep[] {
+    if (steps === '') {
+      return [];
+    }
+
+    // if (CloudRunner.buildParameters?.cloudRunnerIntegrationTests) {
+
+    // CloudRunnerLogger.log(`Parsing build steps: ${steps}`);
+
+    // }
+    const isArray = steps.replace(/\s/g, ``)[0] === `-`;
+    const object: CustomStep[] = isArray ? YAML.parse(steps) : [YAML.parse(steps)];
+    for (const step of object) {
+      CloudRunnerCustomSteps.ConvertYamlSecrets(step);
+      if (step.secrets === undefined) {
+        step.secrets = [];
+      }
+      if (step.image === undefined) {
+        step.image = `ubuntu`;
+      }
+    }
+    if (object === undefined) {
+      throw new Error(`Failed to parse ${steps}`);
+    }
+
+    return object;
+  }
+
+  static async RunPostBuildSteps(cloudRunnerStepState) {
+    let output = ``;
+    const steps: CustomStep[] = [
+      ...CloudRunnerCustomSteps.ParseSteps(CloudRunner.buildParameters.postBuildSteps),
+      ...CloudRunnerCustomSteps.GetCustomStepsFromFiles(`after`),
+    ];
+
+    if (steps.length > 0) {
+      if (!CloudRunner.buildParameters.isCliMode) core.startGroup('post build steps');
+      output += await CustomWorkflow.runCustomJob(
+        steps,
+        cloudRunnerStepState.environment,
+        cloudRunnerStepState.secrets,
+      );
+      if (!CloudRunner.buildParameters.isCliMode) core.endGroup();
+    }
+
+    return output;
+  }
+  static async RunPreBuildSteps(cloudRunnerStepState) {
+    let output = ``;
+    const steps: CustomStep[] = [
+      ...CloudRunnerCustomSteps.ParseSteps(CloudRunner.buildParameters.preBuildSteps),
+      ...CloudRunnerCustomSteps.GetCustomStepsFromFiles(`before`),
+    ];
+
+    if (steps.length > 0) {
+      if (!CloudRunner.buildParameters.isCliMode) core.startGroup('pre build steps');
+      output += await CustomWorkflow.runCustomJob(
+        steps,
+        cloudRunnerStepState.environment,
+        cloudRunnerStepState.secrets,
+      );
+      if (!CloudRunner.buildParameters.isCliMode) core.endGroup();
+    }
+
+    return output;
+  }
+}
+export class CustomStep {
+  public commands;
+  public secrets: CloudRunnerSecret[] = new Array<CloudRunnerSecret>();
+  public name;
+  public image: string = `ubuntu`;
+  public hook!: string;
+}

src/model/cloud-runner/services/cloud-runner-folders.ts

@@ -1,16 +1,27 @@
 import path from 'path';
-import { CloudRunner } from '../..';
+import CloudRunnerOptions from '../cloud-runner-options';
+import CloudRunner from './../cloud-runner';
 
 export class CloudRunnerFolders {
   public static readonly repositoryFolder = 'repo';
 
+  public static ToLinuxFolder(folder: string) {
+    return folder.replace(/\\/g, `/`);
+  }
+
   // Only the following paths that do not start a path.join with another "Full" suffixed property need to start with an absolute /
 
   public static get uniqueCloudRunnerJobFolderAbsolute(): string {
-    return path.join(`/`, CloudRunnerFolders.buildVolumeFolder, CloudRunner.buildParameters.buildGuid);
+    return CloudRunner.buildParameters && CloudRunner.buildParameters.retainWorkspace && CloudRunner.lockedWorkspace
+      ? path.join(`/`, CloudRunnerFolders.buildVolumeFolder, CloudRunner.lockedWorkspace)
+      : path.join(`/`, CloudRunnerFolders.buildVolumeFolder, CloudRunner.buildParameters.buildGuid);
   }
 
-  public static get cacheFolderFull(): string {
+  public static get cacheFolderForAllFull(): string {
+    return path.join('/', CloudRunnerFolders.buildVolumeFolder, CloudRunnerFolders.cacheFolder);
+  }
+
+  public static get cacheFolderForCacheKeyFull(): string {
     return path.join(
       '/',
       CloudRunnerFolders.buildVolumeFolder,
@@ -20,7 +31,12 @@ export class CloudRunnerFolders {
   }
 
   public static get builderPathAbsolute(): string {
-    return path.join(CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute, `builder`);
+    return path.join(
+      CloudRunnerOptions.useSharedBuilder
+        ? `/${CloudRunnerFolders.buildVolumeFolder}`
+        : CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute,
+      `builder`,
+    );
   }
 
   public static get repoPathAbsolute(): string {
@@ -48,11 +64,11 @@ export class CloudRunnerFolders {
   }
 
   public static get lfsCacheFolderFull() {
-    return path.join(CloudRunnerFolders.cacheFolderFull, `lfs`);
+    return path.join(CloudRunnerFolders.cacheFolderForCacheKeyFull, `lfs`);
   }
 
   public static get libraryCacheFolderFull() {
-    return path.join(CloudRunnerFolders.cacheFolderFull, `Library`);
+    return path.join(CloudRunnerFolders.cacheFolderForCacheKeyFull, `Library`);
   }
 
   public static get unityBuilderRepoUrl(): string {

src/model/cloud-runner/services/cloud-runner-options-reader.ts

@@ -0,0 +1,10 @@
+import Input from '../../input';
+import CloudRunnerOptions from '../cloud-runner-options';
+
+class CloudRunnerOptionsReader {
+  static GetProperties() {
+    return [...Object.getOwnPropertyNames(Input), ...Object.getOwnPropertyNames(CloudRunnerOptions)];
+  }
+}
+
+export default CloudRunnerOptionsReader;

src/model/cloud-runner/services/cloud-runner-query-override.ts

@@ -1,5 +1,6 @@
 import Input from '../../input';
 import { GenericInputReader } from '../../input-readers/generic-input-reader';
+import CloudRunnerOptions from '../cloud-runner-options';
 
 const formatFunction = (value, arguments_) => {
   for (const element of arguments_) {
@@ -12,6 +13,8 @@ const formatFunction = (value, arguments_) => {
 class CloudRunnerQueryOverride {
   static queryOverrides: any;
 
+  // TODO accept premade secret sources or custom secret source definition yamls
+
   public static query(key, alternativeKey) {
     if (CloudRunnerQueryOverride.queryOverrides && CloudRunnerQueryOverride.queryOverrides[key] !== undefined) {
       return CloudRunnerQueryOverride.queryOverrides[key];
@@ -28,11 +31,11 @@ class CloudRunnerQueryOverride {
   }
 
   private static shouldUseOverride(query) {
-    if (Input.readInputOverrideCommand() !== '') {
-      if (Input.readInputFromOverrideList() !== '') {
+    if (CloudRunnerOptions.readInputOverrideCommand() !== '') {
+      if (CloudRunnerOptions.readInputFromOverrideList() !== '') {
         const doesInclude =
-          Input.readInputFromOverrideList().split(',').includes(query) ||
-          Input.readInputFromOverrideList().split(',').includes(Input.ToEnvVarFormat(query));
+          CloudRunnerOptions.readInputFromOverrideList().split(',').includes(query) ||
+          CloudRunnerOptions.readInputFromOverrideList().split(',').includes(Input.ToEnvVarFormat(query));
 
         return doesInclude ? true : false;
       } else {
@@ -46,11 +49,13 @@ class CloudRunnerQueryOverride {
       throw new Error(`Should not be trying to run override query on ${query}`);
     }
 
-    return await GenericInputReader.Run(formatFunction(Input.readInputOverrideCommand(), [{ key: 0, value: query }]));
+    return await GenericInputReader.Run(
+      formatFunction(CloudRunnerOptions.readInputOverrideCommand(), [{ key: 0, value: query }]),
+    );
   }
 
   public static async PopulateQueryOverrideInput() {
-    const queries = Input.readInputFromOverrideList().split(',');
+    const queries = CloudRunnerOptions.readInputFromOverrideList().split(',');
     CloudRunnerQueryOverride.queryOverrides = new Array();
     for (const element of queries) {
       if (CloudRunnerQueryOverride.shouldUseOverride(element)) {

src/model/cloud-runner/services/cloud-runner-system.ts

@@ -2,6 +2,20 @@ import { exec } from 'child_process';
 import { RemoteClientLogger } from '../remote-client/remote-client-logger';
 
 export class CloudRunnerSystem {
+  public static async RunAndReadLines(command: string): Promise<string[]> {
+    const result = await CloudRunnerSystem.Run(command, false, true);
+
+    return result
+      .split(`\n`)
+      .map((x) => x.replace(`\r`, ``))
+      .filter((x) => x !== ``)
+      .map((x) => {
+        const lineValues = x.split(` `);
+
+        return lineValues[lineValues.length - 1];
+      });
+  }
+
   public static async Run(command: string, suppressError = false, suppressLogs = false) {
     for (const element of command.split(`\n`)) {
       if (!suppressLogs) {

src/model/cloud-runner/services/depdency-override-service.ts

@@ -1,22 +0,0 @@
-import Input from '../../input';
-import { CloudRunnerSystem } from './cloud-runner-system';
-
-class DependencyOverrideService {
-  public static async CheckHealth() {
-    if (Input.checkDependencyHealthOverride) {
-      try {
-        await CloudRunnerSystem.Run(Input.checkDependencyHealthOverride);
-      } catch {
-        return false;
-      }
-    }
-
-    return true;
-  }
-  public static async TryStartDependencies() {
-    if (Input.startDependenciesOverride) {
-      await CloudRunnerSystem.Run(Input.startDependenciesOverride);
-    }
-  }
-}
-export default DependencyOverrideService;

src/model/cloud-runner/services/follow-log-stream-service.ts

@@ -17,17 +17,16 @@ export class FollowLogStreamService {
       core.setOutput('build-result', 'failed');
       core.setFailed('unity build failed');
       core.error('BUILD FAILED!');
-    } else if (CloudRunner.buildParameters.cloudRunnerIntegrationTests && message.includes(': Listening for Jobs')) {
+    } else if (CloudRunner.buildParameters.cloudRunnerDebug && message.includes(': Listening for Jobs')) {
       core.setOutput('cloud runner stop watching', 'true');
       shouldReadLogs = false;
       shouldCleanup = false;
       core.warning('cloud runner stop watching');
     }
-    message = `[${CloudRunnerStatics.logPrefix}] ${message}`;
-    if (CloudRunner.buildParameters.cloudRunnerIntegrationTests) {
-      output += message;
+    if (CloudRunner.buildParameters.cloudRunnerDebug) {
+      output += `${message}\n`;
     }
-    CloudRunnerLogger.log(message);
+    CloudRunnerLogger.log(`[${CloudRunnerStatics.logPrefix}] ${message}`);
 
     return { shouldReadLogs, shouldCleanup, output };
   }

src/model/cloud-runner/services/shared-workspace-locking.ts

@@ -0,0 +1,279 @@
+import { CloudRunnerSystem } from './cloud-runner-system';
+import * as fs from 'fs';
+import CloudRunnerLogger from './cloud-runner-logger';
+import CloudRunnerOptions from '../cloud-runner-options';
+import BuildParameters from '../../build-parameters';
+import CloudRunner from '../cloud-runner';
+export class SharedWorkspaceLocking {
+  private static readonly workspaceBucketRoot = `s3://game-ci-test-storage/`;
+  private static readonly workspaceRoot = `${SharedWorkspaceLocking.workspaceBucketRoot}locks/`;
+  public static async GetAllWorkspaces(buildParametersContext: BuildParameters): Promise<string[]> {
+    if (!(await SharedWorkspaceLocking.DoesWorkspaceTopLevelExist(buildParametersContext))) {
+      return [];
+    }
+
+    return (
+      await SharedWorkspaceLocking.ReadLines(
+        `aws s3 ls ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/`,
+      )
+    ).map((x) => x.replace(`/`, ``));
+  }
+  public static async DoesWorkspaceTopLevelExist(buildParametersContext: BuildParameters) {
+    return (
+      (await SharedWorkspaceLocking.ReadLines(`aws s3 ls ${SharedWorkspaceLocking.workspaceBucketRoot}`))
+        .map((x) => x.replace(`/`, ``))
+        .includes(`locks`) &&
+      (await SharedWorkspaceLocking.ReadLines(`aws s3 ls ${SharedWorkspaceLocking.workspaceRoot}`))
+        .map((x) => x.replace(`/`, ``))
+        .includes(buildParametersContext.cacheKey)
+    );
+  }
+  public static async GetAllLocks(workspace: string, buildParametersContext: BuildParameters): Promise<string[]> {
+    if (!(await SharedWorkspaceLocking.DoesWorkspaceExist(workspace, buildParametersContext))) {
+      return [];
+    }
+
+    return (
+      await SharedWorkspaceLocking.ReadLines(
+        `aws s3 ls ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${workspace}/`,
+      )
+    )
+      .map((x) => x.replace(`/`, ``))
+      .filter((x) => x.includes(`_lock`));
+  }
+  public static async GetOrCreateLockedWorkspace(
+    workspace: string,
+    runId: string,
+    buildParametersContext: BuildParameters,
+  ) {
+    if (!CloudRunnerOptions.retainWorkspaces) {
+      return;
+    }
+    if (await SharedWorkspaceLocking.DoesWorkspaceTopLevelExist(buildParametersContext)) {
+      const workspaces = await SharedWorkspaceLocking.GetFreeWorkspaces(buildParametersContext);
+      CloudRunnerLogger.log(`run agent ${runId} is trying to access a workspace, free: ${JSON.stringify(workspaces)}`);
+      for (const element of workspaces) {
+        await new Promise((promise) => setTimeout(promise, 1000));
+        const lockResult = await SharedWorkspaceLocking.LockWorkspace(element, runId, buildParametersContext);
+        CloudRunnerLogger.log(`run agent: ${runId} try lock workspace: ${element} result: ${lockResult}`);
+
+        if (lockResult) {
+          CloudRunner.lockedWorkspace = element;
+
+          return true;
+        }
+      }
+    }
+
+    const createResult = await SharedWorkspaceLocking.CreateWorkspace(workspace, buildParametersContext, runId);
+    CloudRunnerLogger.log(
+      `run agent ${runId} didn't find a free workspace so created: ${workspace} createWorkspaceSuccess: ${createResult}`,
+    );
+
+    return createResult;
+  }
+
+  public static async DoesWorkspaceExist(workspace: string, buildParametersContext: BuildParameters) {
+    return (await SharedWorkspaceLocking.GetAllWorkspaces(buildParametersContext)).includes(workspace);
+  }
+  public static async HasWorkspaceLock(
+    workspace: string,
+    runId: string,
+    buildParametersContext: BuildParameters,
+  ): Promise<boolean> {
+    if (!(await SharedWorkspaceLocking.DoesWorkspaceExist(workspace, buildParametersContext))) {
+      return false;
+    }
+    const locks = (await SharedWorkspaceLocking.GetAllLocks(workspace, buildParametersContext))
+      .map((x) => {
+        return {
+          name: x,
+          timestamp: Number(x.split(`_`)[0]),
+        };
+      })
+      .sort((x) => x.timestamp);
+    const lockMatches = locks.filter((x) => x.name.includes(runId));
+    const includesRunLock = lockMatches.length > 0 && locks.indexOf(lockMatches[0]) === 0;
+    CloudRunnerLogger.log(
+      `Checking has workspace lock, runId: ${runId}, workspace: ${workspace}, success: ${includesRunLock} \n- Num of locks created by Run Agent: ${
+        lockMatches.length
+      } Num of Locks: ${locks.length}, Time ordered index for Run Agent: ${locks.indexOf(lockMatches[0])} \n \n`,
+    );
+
+    return includesRunLock;
+  }
+
+  public static async GetFreeWorkspaces(buildParametersContext: BuildParameters): Promise<string[]> {
+    const result: string[] = [];
+    const workspaces = await SharedWorkspaceLocking.GetAllWorkspaces(buildParametersContext);
+    for (const element of workspaces) {
+      await new Promise((promise) => setTimeout(promise, 1500));
+      const isLocked = await SharedWorkspaceLocking.IsWorkspaceLocked(element, buildParametersContext);
+      const isBelowMax = await SharedWorkspaceLocking.IsWorkspaceBelowMax(element, buildParametersContext);
+      if (!isLocked && isBelowMax) {
+        result.push(element);
+        CloudRunnerLogger.log(`workspace ${element} is free`);
+      } else {
+        CloudRunnerLogger.log(`workspace ${element} is NOT free ${!isLocked} ${isBelowMax}`);
+      }
+    }
+
+    return result;
+  }
+
+  public static async IsWorkspaceBelowMax(
+    workspace: string,
+    buildParametersContext: BuildParameters,
+  ): Promise<boolean> {
+    const workspaces = await SharedWorkspaceLocking.GetAllWorkspaces(buildParametersContext);
+    if (workspace === ``) {
+      return (
+        workspaces.length < buildParametersContext.maxRetainedWorkspaces ||
+        buildParametersContext.maxRetainedWorkspaces === 0
+      );
+    }
+    const ordered: any[] = [];
+    for (const ws of workspaces) {
+      ordered.push({
+        name: ws,
+        timestamp: await SharedWorkspaceLocking.GetWorkspaceTimestamp(ws, buildParametersContext),
+      });
+    }
+    ordered.sort((x) => x.timestamp);
+    const matches = ordered.filter((x) => x.name.includes(workspace));
+    const isWorkspaceBelowMax =
+      matches.length > 0 &&
+      (ordered.indexOf(matches[0]) < buildParametersContext.maxRetainedWorkspaces ||
+        buildParametersContext.maxRetainedWorkspaces === 0);
+
+    return isWorkspaceBelowMax;
+  }
+
+  public static async GetWorkspaceTimestamp(
+    workspace: string,
+    buildParametersContext: BuildParameters,
+  ): Promise<Number> {
+    if (workspace.split(`_`).length > 0) {
+      return Number(workspace.split(`_`)[1]);
+    }
+
+    if (!(await SharedWorkspaceLocking.DoesWorkspaceExist(workspace, buildParametersContext))) {
+      throw new Error("Workspace doesn't exist, can't call get all locks");
+    }
+
+    return (
+      await SharedWorkspaceLocking.ReadLines(
+        `aws s3 ls ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${workspace}/`,
+      )
+    )
+      .map((x) => x.replace(`/`, ``))
+      .filter((x) => x.includes(`_workspace`))
+      .map((x) => Number(x))[0];
+  }
+
+  public static async IsWorkspaceLocked(workspace: string, buildParametersContext: BuildParameters): Promise<boolean> {
+    if (!(await SharedWorkspaceLocking.DoesWorkspaceExist(workspace, buildParametersContext))) {
+      return false;
+    }
+    const files = await SharedWorkspaceLocking.ReadLines(
+      `aws s3 ls ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${workspace}/`,
+    );
+
+    const workspaceFileDoesNotExists =
+      files.filter((x) => {
+        return x.includes(`_workspace`);
+      }).length === 0;
+
+    const lockFilesExist =
+      files.filter((x) => {
+        return x.includes(`_lock`);
+      }).length > 0;
+
+    return workspaceFileDoesNotExists || lockFilesExist;
+  }
+
+  public static async CreateWorkspace(
+    workspace: string,
+    buildParametersContext: BuildParameters,
+    lockId: string = ``,
+  ): Promise<boolean> {
+    if (lockId !== ``) {
+      await SharedWorkspaceLocking.LockWorkspace(workspace, lockId, buildParametersContext);
+    }
+    const timestamp = Date.now();
+    const file = `${timestamp}_workspace`;
+    fs.writeFileSync(file, '');
+    await CloudRunnerSystem.Run(
+      `aws s3 cp ./${file} ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${workspace}/${file}`,
+      false,
+      true,
+    );
+    fs.rmSync(file);
+
+    const workspaces = await SharedWorkspaceLocking.ReadLines(
+      `aws s3 ls ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/`,
+    );
+
+    CloudRunnerLogger.log(`All workspaces ${workspaces}`);
+    if (!(await SharedWorkspaceLocking.IsWorkspaceBelowMax(workspace, buildParametersContext))) {
+      CloudRunnerLogger.log(`Workspace is below max ${workspaces} ${buildParametersContext.maxRetainedWorkspaces}`);
+      await SharedWorkspaceLocking.CleanupWorkspace(workspace, buildParametersContext);
+
+      return false;
+    }
+
+    return true;
+  }
+
+  public static async LockWorkspace(
+    workspace: string,
+    runId: string,
+    buildParametersContext: BuildParameters,
+  ): Promise<boolean> {
+    const file = `${Date.now()}_${runId}_lock`;
+    fs.writeFileSync(file, '');
+    await CloudRunnerSystem.Run(
+      `aws s3 cp ./${file} ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${workspace}/${file}`,
+      false,
+      true,
+    );
+    fs.rmSync(file);
+
+    return SharedWorkspaceLocking.HasWorkspaceLock(workspace, runId, buildParametersContext);
+  }
+
+  public static async ReleaseWorkspace(
+    workspace: string,
+    runId: string,
+    buildParametersContext: BuildParameters,
+  ): Promise<boolean> {
+    const file = (await SharedWorkspaceLocking.GetAllLocks(workspace, buildParametersContext)).filter((x) =>
+      x.includes(`_${runId}_lock`),
+    );
+    CloudRunnerLogger.log(`Deleting lock ${workspace}/${file}`);
+    CloudRunnerLogger.log(
+      `aws s3 rm ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${workspace}/${file}`,
+    );
+    await CloudRunnerSystem.Run(
+      `aws s3 rm ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${workspace}/${file}`,
+      false,
+      true,
+    );
+
+    return !SharedWorkspaceLocking.HasWorkspaceLock(workspace, runId, buildParametersContext);
+  }
+
+  public static async CleanupWorkspace(workspace: string, buildParametersContext: BuildParameters) {
+    await CloudRunnerSystem.Run(
+      `aws s3 rm ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${workspace} --recursive`,
+      false,
+      true,
+    );
+  }
+
+  private static async ReadLines(command: string): Promise<string[]> {
+    return CloudRunnerSystem.RunAndReadLines(command);
+  }
+}
+
+export default SharedWorkspaceLocking;

src/model/cloud-runner/services/task-parameter-serializer.ts

@@ -1,72 +1,137 @@
-import { CloudRunner, Input } from '../..';
-import ImageEnvironmentFactory from '../../image-environment-factory';
+import { Input } from '../..';
 import CloudRunnerEnvironmentVariable from './cloud-runner-environment-variable';
-import { CloudRunnerBuildCommandProcessor } from './cloud-runner-build-command-process';
+import { CloudRunnerCustomHooks } from './cloud-runner-custom-hooks';
 import CloudRunnerSecret from './cloud-runner-secret';
 import CloudRunnerQueryOverride from './cloud-runner-query-override';
+import CloudRunnerOptionsReader from './cloud-runner-options-reader';
+import BuildParameters from '../../build-parameters';
+import CloudRunnerOptions from '../cloud-runner-options';
+import * as core from '@actions/core';
 
 export class TaskParameterSerializer {
-  public static readBuildEnvironmentVariables(): CloudRunnerEnvironmentVariable[] {
-    return [
-      {
-        name: 'ContainerMemory',
-        value: CloudRunner.buildParameters.cloudRunnerMemory,
-      },
-      {
-        name: 'ContainerCpu',
-        value: CloudRunner.buildParameters.cloudRunnerCpu,
-      },
-      {
-        name: 'BUILD_TARGET',
-        value: CloudRunner.buildParameters.targetPlatform,
-      },
-      ...TaskParameterSerializer.serializeBuildParamsAndInput,
-    ];
-  }
-  private static get serializeBuildParamsAndInput() {
-    let array = new Array();
-    array = TaskParameterSerializer.readBuildParameters(array);
-    array = TaskParameterSerializer.readInput(array);
-    const configurableHooks = CloudRunnerBuildCommandProcessor.getHooks(CloudRunner.buildParameters.customJobHooks);
-    const secrets = configurableHooks.map((x) => x.secrets).filter((x) => x !== undefined && x.length > 0);
-    if (secrets.length > 0) {
-      // eslint-disable-next-line unicorn/no-array-reduce
-      array.push(secrets.reduce((x, y) => [...x, ...y]));
-    }
+  static readonly blocked = new Set(['0', 'length', 'prototype', '', 'unityVersion']);
+  public static createCloudRunnerEnvironmentVariables(
+    buildParameters: BuildParameters,
+  ): CloudRunnerEnvironmentVariable[] {
+    const result = this.uniqBy(
+      [
+        {
+          name: 'ContainerMemory',
+          value: buildParameters.cloudRunnerMemory,
+        },
+        {
+          name: 'ContainerCpu',
+          value: buildParameters.cloudRunnerCpu,
+        },
+        {
+          name: 'BUILD_TARGET',
+          value: buildParameters.targetPlatform,
+        },
+        ...TaskParameterSerializer.serializeFromObject(buildParameters),
+        ...TaskParameterSerializer.readInput(),
+        ...CloudRunnerCustomHooks.getSecrets(CloudRunnerCustomHooks.getHooks(buildParameters.customJobHooks)),
+      ]
+        .filter(
+          (x) =>
+            !TaskParameterSerializer.blocked.has(x.name) &&
+            x.value !== '' &&
+            x.value !== undefined &&
+            x.name !== `CUSTOM_JOB` &&
+            x.name !== `GAMECI_CUSTOM_JOB` &&
+            x.value !== `undefined`,
+        )
+        .map((x) => {
+          x.name = TaskParameterSerializer.ToEnvVarFormat(x.name);
+          x.value = `${x.value}`;
 
-    array = array.filter(
-      (x) => x.value !== undefined && x.name !== '0' && x.value !== '' && x.name !== 'prototype' && x.name !== 'length',
+          if (buildParameters.cloudRunnerDebug && Number(x.name) === Number.NaN) {
+            core.info(`[ERROR] found a number in task param serializer ${JSON.stringify(x)}`);
+          }
+
+          return x;
+        }),
+      (item) => item.name,
     );
-    array = array.map((x) => {
-      x.name = Input.ToEnvVarFormat(x.name);
-      x.value = `${x.value}`;
 
-      return x;
+    return result;
+  }
+
+  static uniqBy(a, key) {
+    const seen = {};
+
+    return a.filter(function (item) {
+      const k = key(item);
+
+      return seen.hasOwnProperty(k) ? false : (seen[k] = true);
     });
-
-    return array;
   }
 
-  private static readBuildParameters(array: any[]) {
-    const keys = Object.keys(CloudRunner.buildParameters);
+  public static readBuildParameterFromEnvironment(): BuildParameters {
+    const buildParameters = new BuildParameters();
+    const keys = [
+      ...new Set(
+        Object.getOwnPropertyNames(process.env)
+          .filter((x) => !this.blocked.has(x) && x.startsWith('GAMECI_'))
+          .map((x) => TaskParameterSerializer.UndoEnvVarFormat(x)),
+      ),
+    ];
+
     for (const element of keys) {
-      array.push({
-        name: element,
-        value: CloudRunner.buildParameters[element],
-      });
+      if (element !== `customJob`) {
+        buildParameters[element] = process.env[`GAMECI_${TaskParameterSerializer.ToEnvVarFormat(element)}`];
+      }
+    }
+
+    return buildParameters;
+  }
+
+  private static readInput() {
+    return TaskParameterSerializer.serializeFromType(Input);
+  }
+
+  public static ToEnvVarFormat(input): string {
+    return CloudRunnerOptions.ToEnvVarFormat(input);
+  }
+
+  public static UndoEnvVarFormat(element): string {
+    return this.camelize(element.replace('GAMECI_', '').toLowerCase().replace(/_+/g, ' '));
+  }
+
+  private static camelize(string) {
+    return string
+      .replace(/^\w|[A-Z]|\b\w/g, function (word, index) {
+        return index === 0 ? word.toLowerCase() : word.toUpperCase();
+      })
+      .replace(/\s+/g, '');
+  }
+
+  private static serializeFromObject(buildParameters) {
+    const array: any[] = [];
+    const keys = Object.getOwnPropertyNames(buildParameters).filter((x) => !this.blocked.has(x));
+    for (const element of keys) {
+      array.push(
+        {
+          name: `GAMECI_${TaskParameterSerializer.ToEnvVarFormat(element)}`,
+          value: buildParameters[element],
+        },
+        {
+          name: element,
+          value: buildParameters[element],
+        },
+      );
     }
-    array.push({ name: 'buildParameters', value: JSON.stringify(CloudRunner.buildParameters) });
 
     return array;
   }
 
-  private static readInput(array: any[]) {
-    const input = Object.getOwnPropertyNames(Input);
+  private static serializeFromType(type) {
+    const array: any[] = [];
+    const input = CloudRunnerOptionsReader.GetProperties();
     for (const element of input) {
-      if (typeof Input[element] !== 'function' && array.filter((x) => x.name === element).length === 0) {
+      if (typeof type[element] !== 'function' && array.filter((x) => x.name === element).length === 0) {
         array.push({
           name: element,
-          value: `${Input[element]}`,
+          value: `${type[element]}`,
         });
       }
     }
@@ -79,17 +144,7 @@ export class TaskParameterSerializer {
     array = TaskParameterSerializer.tryAddInput(array, 'UNITY_SERIAL');
     array = TaskParameterSerializer.tryAddInput(array, 'UNITY_EMAIL');
     array = TaskParameterSerializer.tryAddInput(array, 'UNITY_PASSWORD');
-    array.push(
-      ...ImageEnvironmentFactory.getEnvironmentVariables(CloudRunner.buildParameters)
-        .filter((x) => array.every((y) => y.ParameterKey !== x.name))
-        .map((x) => {
-          return {
-            ParameterKey: x.name,
-            EnvironmentVariable: x.name,
-            ParameterValue: x.value,
-          };
-        }),
-    );
+    array = TaskParameterSerializer.tryAddInput(array, 'UNITY_LICENSE');
 
     return array;
   }
@@ -102,7 +157,7 @@ export class TaskParameterSerializer {
   s;
   private static tryAddInput(array, key): CloudRunnerSecret[] {
     const value = TaskParameterSerializer.getValue(key);
-    if (value !== undefined && value !== '') {
+    if (value !== undefined && value !== '' && value !== 'null') {
       array.push({
         ParameterKey: key,
         EnvironmentVariable: key,