Cloud runner develop - latest fixes (#524)

2026-02-03 23:49:08 +08:00 · 2023-03-27 12:14:23 +01:00
parent 309d668d63
commit 7abb3a409d
91 changed files with 4943 additions and 3599 deletions
--- a/src/model/cloud-runner/services/cloud-runner-constants.ts
+++ b/src/model/cloud-runner/services/cloud-runner-constants.ts
@@ -1,4 +0,0 @@
-class CloudRunnerConstants {
-  static alphabet = '0123456789abcdefghijklmnopqrstuvwxyz';
-}
-export default CloudRunnerConstants;
--- a/src/model/cloud-runner/services/cloud-runner-custom-hooks.ts
+++ b/src/model/cloud-runner/services/cloud-runner-custom-hooks.ts
@@ -1,114 +0,0 @@
-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 'node:path';
-import CloudRunnerOptions from '../cloud-runner-options';
-import fs from 'node: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: string): Hook[] {
-    const experimentHooks = customJobHooks;
-    let output = new Array<Hook>();
-    if (experimentHooks && experimentHooks !== '') {
-      output = YAML.parse(experimentHooks);
-    }
-
-    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: Hook) {
-    if (object.secrets === undefined) {
-      object.secrets = [];
-
-      return;
-    }
-    object.secrets = object.secrets.map((x) => {
-      return {
-        ParameterKey: x.ParameterKey,
-        EnvironmentVariable: Input.ToEnvVarFormat(x.ParameterKey),
-        ParameterValue: x.ParameterValue,
-      };
-    });
-  }
-
-  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: Hook[]) {
-    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!: string[];
-  public secrets: CloudRunnerSecret[] = new Array<CloudRunnerSecret>();
-  public name!: string;
-  public hook!: string[];
-  public step!: string[];
-}
--- a/src/model/cloud-runner/services/cloud-runner-environment-variable.ts
+++ b/src/model/cloud-runner/services/cloud-runner-environment-variable.ts
@@ -1,5 +0,0 @@
-class CloudRunnerEnvironmentVariable {
-  public name!: string;
-  public value!: string;
-}
-export default CloudRunnerEnvironmentVariable;
--- a/src/model/cloud-runner/services/cloud-runner-folders.ts
+++ b/src/model/cloud-runner/services/cloud-runner-folders.ts
@@ -1,89 +0,0 @@
-import path from 'node:path';
-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 CloudRunner.buildParameters && CloudRunner.buildParameters.retainWorkspace && CloudRunner.lockedWorkspace
-      ? path.join(`/`, CloudRunnerFolders.buildVolumeFolder, CloudRunner.lockedWorkspace)
-      : path.join(`/`, CloudRunnerFolders.buildVolumeFolder, CloudRunner.buildParameters.buildGuid);
-  }
-
-  public static get cacheFolderForAllFull(): string {
-    return path.join('/', CloudRunnerFolders.buildVolumeFolder, CloudRunnerFolders.cacheFolder);
-  }
-
-  public static get cacheFolderForCacheKeyFull(): string {
-    return path.join(
-      '/',
-      CloudRunnerFolders.buildVolumeFolder,
-      CloudRunnerFolders.cacheFolder,
-      CloudRunner.buildParameters.cacheKey,
-    );
-  }
-
-  public static get builderPathAbsolute(): string {
-    return path.join(
-      CloudRunnerOptions.useSharedBuilder
-        ? `/${CloudRunnerFolders.buildVolumeFolder}`
-        : CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute,
-      `builder`,
-    );
-  }
-
-  public static get repoPathAbsolute(): string {
-    return path.join(CloudRunnerFolders.uniqueCloudRunnerJobFolderAbsolute, CloudRunnerFolders.repositoryFolder);
-  }
-
-  public static get projectPathAbsolute(): string {
-    return path.join(CloudRunnerFolders.repoPathAbsolute, CloudRunner.buildParameters.projectPath);
-  }
-
-  public static get libraryFolderAbsolute(): string {
-    return path.join(CloudRunnerFolders.projectPathAbsolute, `Library`);
-  }
-
-  public static get projectBuildFolderAbsolute(): string {
-    return path.join(CloudRunnerFolders.repoPathAbsolute, CloudRunner.buildParameters.buildPath);
-  }
-
-  public static get lfsFolderAbsolute(): string {
-    return path.join(CloudRunnerFolders.repoPathAbsolute, `.git`, `lfs`);
-  }
-
-  public static get purgeRemoteCaching(): boolean {
-    return process.env.PURGE_REMOTE_BUILDER_CACHE !== undefined;
-  }
-
-  public static get lfsCacheFolderFull() {
-    return path.join(CloudRunnerFolders.cacheFolderForCacheKeyFull, `lfs`);
-  }
-
-  public static get libraryCacheFolderFull() {
-    return path.join(CloudRunnerFolders.cacheFolderForCacheKeyFull, `Library`);
-  }
-
-  public static get unityBuilderRepoUrl(): string {
-    return `https://${CloudRunner.buildParameters.gitPrivateToken}@github.com/game-ci/unity-builder.git`;
-  }
-
-  public static get targetBuildRepoUrl(): string {
-    return `https://${CloudRunner.buildParameters.gitPrivateToken}@github.com/${CloudRunner.buildParameters.githubRepo}.git`;
-  }
-
-  public static get buildVolumeFolder() {
-    return 'data';
-  }
-
-  public static get cacheFolder() {
-    return 'cache';
-  }
-}
--- a/src/model/cloud-runner/services/cloud-runner-guid.ts
+++ b/src/model/cloud-runner/services/cloud-runner-guid.ts
@@ -1,11 +0,0 @@
-import { customAlphabet } from 'nanoid';
-import CloudRunnerConstants from './cloud-runner-constants';
-
-class CloudRunnerNamespace {
-  static generateGuid(runNumber: string | number, platform: string) {
-    const nanoid = customAlphabet(CloudRunnerConstants.alphabet, 4);
-
-    return `${runNumber}-${platform.toLowerCase().replace('standalone', '')}-${nanoid()}`;
-  }
-}
-export default CloudRunnerNamespace;
--- a/src/model/cloud-runner/services/cloud-runner-options-reader.ts
+++ b/src/model/cloud-runner/services/cloud-runner-options-reader.ts
@@ -1,10 +0,0 @@
-import Input from '../../input';
-import CloudRunnerOptions from '../cloud-runner-options';
-
-class CloudRunnerOptionsReader {
-  static GetProperties() {
-    return [...Object.getOwnPropertyNames(Input), ...Object.getOwnPropertyNames(CloudRunnerOptions)];
-  }
-}
-
-export default CloudRunnerOptionsReader;
--- a/src/model/cloud-runner/services/cloud-runner-query-override.ts
+++ b/src/model/cloud-runner/services/cloud-runner-query-override.ts
@@ -1,67 +0,0 @@
-import Input from '../../input';
-import { GenericInputReader } from '../../input-readers/generic-input-reader';
-import CloudRunnerOptions from '../cloud-runner-options';
-
-const formatFunction = (value: string, arguments_: any[]) => {
-  for (const element of arguments_) {
-    value = value.replace(`{${element.key}}`, element.value);
-  }
-
-  return value;
-};
-
-class CloudRunnerQueryOverride {
-  static queryOverrides: { [key: string]: string } | undefined;
-
-  // TODO accept premade secret sources or custom secret source definition yamls
-
-  public static query(key: string, alternativeKey: string) {
-    if (CloudRunnerQueryOverride.queryOverrides && CloudRunnerQueryOverride.queryOverrides[key] !== undefined) {
-      return CloudRunnerQueryOverride.queryOverrides[key];
-    }
-    if (
-      CloudRunnerQueryOverride.queryOverrides &&
-      alternativeKey &&
-      CloudRunnerQueryOverride.queryOverrides[alternativeKey] !== undefined
-    ) {
-      return CloudRunnerQueryOverride.queryOverrides[alternativeKey];
-    }
-
-    return;
-  }
-
-  private static shouldUseOverride(query: string) {
-    if (CloudRunnerOptions.readInputOverrideCommand() !== '') {
-      if (CloudRunnerOptions.readInputFromOverrideList() !== '') {
-        const doesInclude =
-          CloudRunnerOptions.readInputFromOverrideList().split(',').includes(query) ||
-          CloudRunnerOptions.readInputFromOverrideList().split(',').includes(Input.ToEnvVarFormat(query));
-
-        return doesInclude ? true : false;
-      } else {
-        return true;
-      }
-    }
-  }
-
-  private static async queryOverride(query: string) {
-    if (!this.shouldUseOverride(query)) {
-      throw new Error(`Should not be trying to run override query on ${query}`);
-    }
-
-    return await GenericInputReader.Run(
-      formatFunction(CloudRunnerOptions.readInputOverrideCommand(), [{ key: 0, value: query }]),
-    );
-  }
-
-  public static async PopulateQueryOverrideInput() {
-    const queries = CloudRunnerOptions.readInputFromOverrideList().split(',');
-    CloudRunnerQueryOverride.queryOverrides = {};
-    for (const element of queries) {
-      if (CloudRunnerQueryOverride.shouldUseOverride(element)) {
-        CloudRunnerQueryOverride.queryOverrides[element] = await CloudRunnerQueryOverride.queryOverride(element);
-      }
-    }
-  }
-}
-export default CloudRunnerQueryOverride;
--- a/src/model/cloud-runner/services/cloud-runner-secret.ts
+++ b/src/model/cloud-runner/services/cloud-runner-secret.ts
@@ -1,6 +0,0 @@
-class CloudRunnerSecret {
-  public ParameterKey!: string;
-  public EnvironmentVariable!: string;
-  public ParameterValue!: string;
-}
-export default CloudRunnerSecret;
--- a/src/model/cloud-runner/services/core/cloud-runner-logger.ts
+++ b/src/model/cloud-runner/services/core/cloud-runner-logger.ts
--- a/src/model/cloud-runner/services/core/cloud-runner-system.ts
+++ b/src/model/cloud-runner/services/core/cloud-runner-system.ts
@@ -1,5 +1,5 @@
 import { exec } from 'child_process';
-import { RemoteClientLogger } from '../remote-client/remote-client-logger';
+import { RemoteClientLogger } from '../../remote-client/remote-client-logger';

 export class CloudRunnerSystem {
  public static async RunAndReadLines(command: string): Promise<string[]> {
--- a/src/model/cloud-runner/services/core/follow-log-stream-service.ts
+++ b/src/model/cloud-runner/services/core/follow-log-stream-service.ts
@@ -0,0 +1,57 @@
+import GitHub from '../../../github';
+import CloudRunner from '../../cloud-runner';
+import { CloudRunnerStatics } from '../../options/cloud-runner-statics';
+import CloudRunnerLogger from './cloud-runner-logger';
+import * as core from '@actions/core';
+
+export class FollowLogStreamService {
+  static Reset() {
+    FollowLogStreamService.DidReceiveEndOfTransmission = false;
+  }
+  static errors = ``;
+  public static DidReceiveEndOfTransmission = false;
+  public static handleIteration(message: string, shouldReadLogs: boolean, shouldCleanup: boolean, output: string) {
+    if (message.includes(`---${CloudRunner.buildParameters.logId}`)) {
+      CloudRunnerLogger.log('End of log transmission received');
+      FollowLogStreamService.DidReceiveEndOfTransmission = true;
+      shouldReadLogs = false;
+    } else if (message.includes('Rebuilding Library because the asset database could not be found!')) {
+      GitHub.updateGitHubCheck(`Library was not found, importing new Library`, ``);
+      core.warning('LIBRARY NOT FOUND!');
+      core.setOutput('library-found', 'false');
+    } else if (message.includes('Build succeeded')) {
+      GitHub.updateGitHubCheck(`Build succeeded`, `Build succeeded`);
+      core.setOutput('build-result', 'success');
+    } else if (message.includes('Build fail')) {
+      GitHub.updateGitHubCheck(
+        `Build failed\n${FollowLogStreamService.errors}`,
+        `Build failed`,
+        `failure`,
+        `completed`,
+      );
+      core.setOutput('build-result', 'failed');
+      core.setFailed('unity build failed');
+      core.error('BUILD FAILED!');
+    } else if (message.toLowerCase().includes('error ')) {
+      core.error(message);
+      FollowLogStreamService.errors += `\n${message}`;
+    } else if (message.toLowerCase().includes('error: ')) {
+      core.error(message);
+      FollowLogStreamService.errors += `\n${message}`;
+    } else if (message.toLowerCase().includes('command failed: ')) {
+      FollowLogStreamService.errors += `\n${message}`;
+    } else if (message.toLowerCase().includes('invalid ')) {
+      FollowLogStreamService.errors += `\n${message}`;
+    } else if (message.toLowerCase().includes('incompatible  ')) {
+      FollowLogStreamService.errors += `\n${message}`;
+    } else if (message.toLowerCase().includes('cannot be found')) {
+      FollowLogStreamService.errors += `\n${message}`;
+    }
+    if (CloudRunner.buildParameters.cloudRunnerDebug) {
+      output += `${message}\n`;
+    }
+    CloudRunnerLogger.log(`[${CloudRunnerStatics.logPrefix}] ${message}`);
+
+    return { shouldReadLogs, shouldCleanup, output };
+  }
+}
--- a/src/model/cloud-runner/services/core/shared-workspace-locking.ts
+++ b/src/model/cloud-runner/services/core/shared-workspace-locking.ts
@@ -1,18 +1,17 @@
 import { CloudRunnerSystem } from './cloud-runner-system';
 import fs from 'node:fs';
 import CloudRunnerLogger from './cloud-runner-logger';
-import CloudRunnerOptions from '../cloud-runner-options';
-import BuildParameters from '../../build-parameters';
-import CloudRunner from '../cloud-runner';
+import BuildParameters from '../../../build-parameters';
+import CloudRunner from '../../cloud-runner';
 export class SharedWorkspaceLocking {
-  private static get workspaceBucketRoot() {
-    return `s3://${CloudRunner.buildParameters.awsBaseStackName}/`;
+  public static get workspaceBucketRoot() {
+    return `s3://${CloudRunner.buildParameters.awsStackName}/`;
  }
-  private static get workspaceRoot() {
+  public static get workspaceRoot() {
    return `${SharedWorkspaceLocking.workspaceBucketRoot}locks/`;
  }
  public static async GetAllWorkspaces(buildParametersContext: BuildParameters): Promise<string[]> {
-    if (!(await SharedWorkspaceLocking.DoesWorkspaceTopLevelExist(buildParametersContext))) {
+    if (!(await SharedWorkspaceLocking.DoesCacheKeyTopLevelExist(buildParametersContext))) {
      return [];
    }

@@ -20,79 +19,95 @@ export class SharedWorkspaceLocking {
      await SharedWorkspaceLocking.ReadLines(
        `aws s3 ls ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/`,
      )
-    ).map((x) => x.replace(`/`, ``));
-  }
-  public static async DoesWorkspaceTopLevelExist(buildParametersContext: BuildParameters) {
-    await SharedWorkspaceLocking.ReadLines(`aws s3 ls ${SharedWorkspaceLocking.workspaceBucketRoot}`);
-
-    return (await SharedWorkspaceLocking.ReadLines(`aws s3 ls ${SharedWorkspaceLocking.workspaceRoot}`))
+    )
      .map((x) => x.replace(`/`, ``))
-      .includes(buildParametersContext.cacheKey);
+      .filter((x) => x.endsWith(`_workspace`))
+      .map((x) => x.split(`_`)[1]);
  }
-  public static async GetAllLocks(workspace: string, buildParametersContext: BuildParameters): Promise<string[]> {
+  public static async DoesCacheKeyTopLevelExist(buildParametersContext: BuildParameters) {
+    try {
+      const rootLines = await SharedWorkspaceLocking.ReadLines(
+        `aws s3 ls ${SharedWorkspaceLocking.workspaceBucketRoot}`,
+      );
+      const lockFolderExists = rootLines.map((x) => x.replace(`/`, ``)).includes(`locks`);
+
+      if (lockFolderExists) {
+        const lines = await SharedWorkspaceLocking.ReadLines(`aws s3 ls ${SharedWorkspaceLocking.workspaceRoot}`);
+
+        return lines.map((x) => x.replace(`/`, ``)).includes(buildParametersContext.cacheKey);
+      } else {
+        return false;
+      }
+    } catch {
+      return false;
+    }
+  }
+
+  public static NewWorkspaceName() {
+    return `${CloudRunner.retainedWorkspacePrefix}-${CloudRunner.buildParameters.buildGuid}`;
+  }
+  public static async GetAllLocksForWorkspace(
+    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}/`,
+        `aws s3 ls ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/`,
      )
    )
      .map((x) => x.replace(`/`, ``))
-      .filter((x) => x.includes(`_lock`));
+      .filter((x) => x.includes(workspace) && x.endsWith(`_lock`));
  }
-  public static async GetOrCreateLockedWorkspace(
-    workspace: string,
-    runId: string,
-    buildParametersContext: BuildParameters,
-  ) {
-    if (!CloudRunnerOptions.retainWorkspaces) {
-      return;
+  public static async GetLockedWorkspace(workspace: string, runId: string, buildParametersContext: BuildParameters) {
+    if (buildParametersContext.maxRetainedWorkspaces === 0) {
+      return false;
    }

-    try {
-      if (await SharedWorkspaceLocking.DoesWorkspaceTopLevelExist(buildParametersContext)) {
-        const workspaces = await SharedWorkspaceLocking.GetFreeWorkspaces(buildParametersContext);
+    if (await SharedWorkspaceLocking.DoesCacheKeyTopLevelExist(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) {
+        const lockResult = await SharedWorkspaceLocking.LockWorkspace(element, runId, buildParametersContext);
        CloudRunnerLogger.log(
-          `run agent ${runId} is trying to access a workspace, free: ${JSON.stringify(workspaces)}`,
+          `run agent: ${runId} try lock workspace: ${element} locking attempt result: ${lockResult}`,
        );
-        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;
-          }
+        if (lockResult) {
+          return true;
        }
      }
-    } catch {
-      return;
    }

-    const createResult = await SharedWorkspaceLocking.CreateWorkspace(workspace, buildParametersContext, runId);
+    if (await SharedWorkspaceLocking.DoesWorkspaceExist(workspace, buildParametersContext)) {
+      workspace = SharedWorkspaceLocking.NewWorkspaceName();
+      CloudRunner.lockedWorkspace = workspace;
+    }
+
+    const createResult = await SharedWorkspaceLocking.CreateWorkspace(workspace, buildParametersContext);
+    const lockResult = await SharedWorkspaceLocking.LockWorkspace(workspace, runId, buildParametersContext);
    CloudRunnerLogger.log(
-      `run agent ${runId} didn't find a free workspace so created: ${workspace} createWorkspaceSuccess: ${createResult}`,
+      `run agent ${runId} didn't find a free workspace so created: ${workspace} createWorkspaceSuccess: ${createResult} Lock:${lockResult}`,
    );

-    return createResult;
+    return createResult && lockResult;
  }

  public static async DoesWorkspaceExist(workspace: string, buildParametersContext: BuildParameters) {
-    return (await SharedWorkspaceLocking.GetAllWorkspaces(buildParametersContext)).includes(workspace);
+    return (
+      (await SharedWorkspaceLocking.GetAllWorkspaces(buildParametersContext)).filter((x) => x.includes(workspace))
+        .length > 0
+    );
  }
  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))
+    const locks = (await SharedWorkspaceLocking.GetAllLocksForWorkspace(workspace, buildParametersContext))
      .map((x) => {
        return {
          name: x,
@@ -115,14 +130,11 @@ export class SharedWorkspaceLocking {
    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);
+      CloudRunnerLogger.log(`workspace ${element} locked:${isLocked} below max:${isBelowMax}`);
      if (!isLocked && isBelowMax) {
        result.push(element);
-        CloudRunnerLogger.log(`workspace ${element} is free`);
-      } else {
-        CloudRunnerLogger.log(`workspace ${element} is NOT free ${!isLocked} ${isBelowMax}`);
      }
    }

@@ -171,60 +183,49 @@ export class SharedWorkspaceLocking {

    return (
      await SharedWorkspaceLocking.ReadLines(
-        `aws s3 ls ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${workspace}/`,
+        `aws s3 ls ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/`,
      )
    )
      .map((x) => x.replace(`/`, ``))
-      .filter((x) => x.includes(`_workspace`))
+      .filter((x) => x.includes(workspace) && x.endsWith(`_workspace`))
      .map((x) => Number(x))[0];
  }

  public static async IsWorkspaceLocked(workspace: string, buildParametersContext: BuildParameters): Promise<boolean> {
    if (!(await SharedWorkspaceLocking.DoesWorkspaceExist(workspace, buildParametersContext))) {
-      return false;
+      throw new Error(`workspace doesn't exist ${workspace}`);
    }
    const files = await SharedWorkspaceLocking.ReadLines(
-      `aws s3 ls ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${workspace}/`,
+      `aws s3 ls ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/`,
    );

-    const workspaceFileDoesNotExists =
-      files.filter((x) => {
-        return x.includes(`_workspace`);
-      }).length === 0;
-
    const lockFilesExist =
      files.filter((x) => {
-        return x.includes(`_lock`);
+        return x.includes(workspace) && x.endsWith(`_lock`);
      }).length > 0;

-    return workspaceFileDoesNotExists || lockFilesExist;
+    return lockFilesExist;
  }

-  public static async CreateWorkspace(
-    workspace: string,
-    buildParametersContext: BuildParameters,
-    lockId: string = ``,
-  ): Promise<boolean> {
-    if (lockId !== ``) {
-      await SharedWorkspaceLocking.LockWorkspace(workspace, lockId, buildParametersContext);
+  public static async CreateWorkspace(workspace: string, buildParametersContext: BuildParameters): Promise<boolean> {
+    if (await SharedWorkspaceLocking.DoesWorkspaceExist(workspace, buildParametersContext)) {
+      throw new Error(`${workspace} already exists`);
    }
    const timestamp = Date.now();
-    const file = `${timestamp}_workspace`;
+    const file = `${timestamp}_${workspace}_workspace`;
    fs.writeFileSync(file, '');
    await CloudRunnerSystem.Run(
-      `aws s3 cp ./${file} ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${workspace}/${file}`,
+      `aws s3 cp ./${file} ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${file}`,
      false,
      true,
    );
    fs.rmSync(file);

-    const workspaces = await SharedWorkspaceLocking.ReadLines(
-      `aws s3 ls ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/`,
-    );
+    const workspaces = await SharedWorkspaceLocking.GetAllWorkspaces(buildParametersContext);

    CloudRunnerLogger.log(`All workspaces ${workspaces}`);
    if (!(await SharedWorkspaceLocking.IsWorkspaceBelowMax(workspace, buildParametersContext))) {
-      CloudRunnerLogger.log(`Workspace is below max ${workspaces} ${buildParametersContext.maxRetainedWorkspaces}`);
+      CloudRunnerLogger.log(`Workspace is above max ${workspaces} ${buildParametersContext.maxRetainedWorkspaces}`);
      await SharedWorkspaceLocking.CleanupWorkspace(workspace, buildParametersContext);

      return false;
@@ -238,16 +239,30 @@ export class SharedWorkspaceLocking {
    runId: string,
    buildParametersContext: BuildParameters,
  ): Promise<boolean> {
-    const file = `${Date.now()}_${runId}_lock`;
+    const existingWorkspace = workspace.endsWith(`_workspace`);
+    const ending = existingWorkspace ? workspace : `${workspace}_workspace`;
+    const file = `${Date.now()}_${runId}_${ending}_lock`;
    fs.writeFileSync(file, '');
    await CloudRunnerSystem.Run(
-      `aws s3 cp ./${file} ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${workspace}/${file}`,
+      `aws s3 cp ./${file} ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${file}`,
      false,
      true,
    );
    fs.rmSync(file);

-    return SharedWorkspaceLocking.HasWorkspaceLock(workspace, runId, buildParametersContext);
+    const hasLock = await SharedWorkspaceLocking.HasWorkspaceLock(workspace, runId, buildParametersContext);
+
+    if (hasLock) {
+      CloudRunner.lockedWorkspace = workspace;
+    } else {
+      await CloudRunnerSystem.Run(
+        `aws s3 rm ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${file}`,
+        false,
+        true,
+      );
+    }
+
+    return hasLock;
  }

  public static async ReleaseWorkspace(
@@ -255,31 +270,29 @@ export class SharedWorkspaceLocking {
    runId: string,
    buildParametersContext: BuildParameters,
  ): Promise<boolean> {
-    const file = (await SharedWorkspaceLocking.GetAllLocks(workspace, buildParametersContext)).filter((x) =>
-      x.includes(`_${runId}_lock`),
-    );
+    const files = await SharedWorkspaceLocking.GetAllLocksForWorkspace(workspace, buildParametersContext);
+    const file = files.find((x) => x.includes(workspace) && x.endsWith(`_lock`) && x.includes(runId));
+    CloudRunnerLogger.log(`All Locks ${files} ${workspace} ${runId}`);
    CloudRunnerLogger.log(`Deleting lock ${workspace}/${file}`);
-    CloudRunnerLogger.log(
-      `aws s3 rm ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${workspace}/${file}`,
-    );
+    CloudRunnerLogger.log(`rm ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${file}`);
    await CloudRunnerSystem.Run(
-      `aws s3 rm ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${workspace}/${file}`,
+      `aws s3 rm ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey}/${file}`,
      false,
      true,
    );

-    return !SharedWorkspaceLocking.HasWorkspaceLock(workspace, runId, buildParametersContext);
+    return !(await 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`,
+      `aws s3 rm ${SharedWorkspaceLocking.workspaceRoot}${buildParametersContext.cacheKey} --exclude "*" --include "*_${workspace}_*"`,
      false,
      true,
    );
  }

-  private static async ReadLines(command: string): Promise<string[]> {
+  public static async ReadLines(command: string): Promise<string[]> {
    return CloudRunnerSystem.RunAndReadLines(command);
  }
 }
--- a/src/model/cloud-runner/services/core/task-parameter-serializer.ts
+++ b/src/model/cloud-runner/services/core/task-parameter-serializer.ts
@@ -1,53 +1,50 @@
-import { Input } from '../..';
-import CloudRunnerEnvironmentVariable from './cloud-runner-environment-variable';
-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';
+import BuildParameters from '../../../build-parameters';
+import Input from '../../../input';
+import CloudRunnerOptions from '../../options/cloud-runner-options';
+import CloudRunnerEnvironmentVariable from '../../options/cloud-runner-environment-variable';
+import CloudRunnerOptionsReader from '../../options/cloud-runner-options-reader';
+import CloudRunnerQueryOverride from '../../options/cloud-runner-query-override';
+import CloudRunnerSecret from '../../options/cloud-runner-secret';
+import { CommandHookService } from '../hooks/command-hook-service';

 export class TaskParameterSerializer {
-  static readonly blocked = new Set(['0', 'length', 'prototype', '', 'unityVersion']);
+  static readonly blockedParameterNames: Set<string> = new Set([
+    '0',
+    'length',
+    'prototype',
+    '',
+    'unityVersion',
+    'CACHE_UNITY_INSTALLATION_ON_MAC',
+    'RUNNER_TEMP_PATH',
+    'NAME',
+    'CUSTOM_JOB',
+  ]);
  public static createCloudRunnerEnvironmentVariables(
    buildParameters: BuildParameters,
  ): CloudRunnerEnvironmentVariable[] {
-    const result = this.uniqBy(
+    const result: CloudRunnerEnvironmentVariable[] = this.uniqBy(
      [
-        {
-          name: 'ContainerMemory',
-          value: buildParameters.cloudRunnerMemory,
-        },
-        {
-          name: 'ContainerCpu',
-          value: buildParameters.cloudRunnerCpu,
-        },
-        {
-          name: 'BUILD_TARGET',
-          value: buildParameters.targetPlatform,
-        },
+        ...[
+          { name: 'BUILD_TARGET', value: buildParameters.targetPlatform },
+          { name: 'UNITY_VERSION', value: buildParameters.editorVersion },
+          { name: 'GITHUB_TOKEN', value: process.env.GITHUB_TOKEN },
+        ],
        ...TaskParameterSerializer.serializeFromObject(buildParameters),
-        ...TaskParameterSerializer.readInput(),
-        ...CloudRunnerCustomHooks.getSecrets(CloudRunnerCustomHooks.getHooks(buildParameters.customJobHooks)),
+        ...TaskParameterSerializer.serializeInput(),
+        ...TaskParameterSerializer.serializeCloudRunnerOptions(),
+        ...CommandHookService.getSecrets(CommandHookService.getHooks(buildParameters.commandHooks)),
      ]
        .filter(
          (x) =>
-            !TaskParameterSerializer.blocked.has(x.name) &&
+            !TaskParameterSerializer.blockedParameterNames.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.name = `${TaskParameterSerializer.ToEnvVarFormat(x.name)}`;
          x.value = `${x.value}`;

-          if (buildParameters.cloudRunnerDebug && Number.isNaN(Number(x.name))) {
-            core.info(`[ERROR] found a number in task param serializer ${JSON.stringify(x)}`);
-          }
-
          return x;
        }),
      (item: CloudRunnerEnvironmentVariable) => item.name,
@@ -72,54 +69,58 @@ export class TaskParameterSerializer {
    const keys = [
      ...new Set(
        Object.getOwnPropertyNames(process.env)
-          .filter((x) => !this.blocked.has(x) && x.startsWith('GAMECI_'))
+          .filter((x) => !this.blockedParameterNames.has(x) && x.startsWith(''))
          .map((x) => TaskParameterSerializer.UndoEnvVarFormat(x)),
      ),
    ];

    for (const element of keys) {
      if (element !== `customJob`) {
-        buildParameters[element] = process.env[`GAMECI_${TaskParameterSerializer.ToEnvVarFormat(element)}`];
+        buildParameters[element] = process.env[`${TaskParameterSerializer.ToEnvVarFormat(element)}`];
      }
    }

    return buildParameters;
  }

-  private static readInput() {
+  private static serializeInput() {
    return TaskParameterSerializer.serializeFromType(Input);
  }

+  private static serializeCloudRunnerOptions() {
+    return TaskParameterSerializer.serializeFromType(CloudRunnerOptions);
+  }
+
  public static ToEnvVarFormat(input: string): string {
    return CloudRunnerOptions.ToEnvVarFormat(input);
  }

  public static UndoEnvVarFormat(element: string): string {
-    return this.camelize(element.replace('GAMECI_', '').toLowerCase().replace(/_+/g, ' '));
+    return this.camelize(element.toLowerCase().replace(/_+/g, ' '));
  }

  private static camelize(string: string) {
-    return string
-      .replace(/(^\w)|([A-Z])|(\b\w)/g, function (word: string, index: number) {
-        return index === 0 ? word.toLowerCase() : word.toUpperCase();
-      })
-      .replace(/\s+/g, '');
+    return TaskParameterSerializer.uncapitalizeFirstLetter(
+      string
+        .replace(/(^\w)|([A-Z])|(\b\w)/g, function (word: string, index: number) {
+          return index === 0 ? word.toLowerCase() : word.toUpperCase();
+        })
+        .replace(/\s+/g, ''),
+    );
+  }
+
+  private static uncapitalizeFirstLetter(string: string) {
+    return string.charAt(0).toLowerCase() + string.slice(1);
  }

  private static serializeFromObject(buildParameters: any) {
    const array: any[] = [];
-    const keys = Object.getOwnPropertyNames(buildParameters).filter((x) => !this.blocked.has(x));
+    const keys = Object.getOwnPropertyNames(buildParameters).filter((x) => !this.blockedParameterNames.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: TaskParameterSerializer.ToEnvVarFormat(element),
+        value: buildParameters[element],
+      });
    }

    return array;
--- a/src/model/cloud-runner/services/follow-log-stream-service.ts
+++ b/src/model/cloud-runner/services/follow-log-stream-service.ts
@@ -1,37 +0,0 @@
-import CloudRunnerLogger from './cloud-runner-logger';
-import * as core from '@actions/core';
-import CloudRunner from '../cloud-runner';
-import { CloudRunnerStatics } from '../cloud-runner-statics';
-import GitHub from '../../github';
-
-export class FollowLogStreamService {
-  public static handleIteration(message: string, shouldReadLogs: boolean, shouldCleanup: boolean, output: string) {
-    if (message.includes(`---${CloudRunner.buildParameters.logId}`)) {
-      CloudRunnerLogger.log('End of log transmission received');
-      shouldReadLogs = false;
-    } else if (message.includes('Rebuilding Library because the asset database could not be found!')) {
-      GitHub.updateGitHubCheck(`Library was not found, importing new Library`, ``);
-      core.warning('LIBRARY NOT FOUND!');
-      core.setOutput('library-found', 'false');
-    } else if (message.includes('Build succeeded')) {
-      GitHub.updateGitHubCheck(`Build succeeded`, `Build succeeded`);
-      core.setOutput('build-result', 'success');
-    } else if (message.includes('Build fail')) {
-      GitHub.updateGitHubCheck(`Build failed`, `Build failed`);
-      core.setOutput('build-result', 'failed');
-      core.setFailed('unity build failed');
-      core.error('BUILD FAILED!');
-    } 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');
-    }
-    if (CloudRunner.buildParameters.cloudRunnerDebug) {
-      output += `${message}\n`;
-    }
-    CloudRunnerLogger.log(`[${CloudRunnerStatics.logPrefix}] ${message}`);
-
-    return { shouldReadLogs, shouldCleanup, output };
-  }
-}
--- a/src/model/cloud-runner/services/hooks/command-hook-service.ts
+++ b/src/model/cloud-runner/services/hooks/command-hook-service.ts
@@ -0,0 +1,118 @@
+import { BuildParameters, Input } from '../../..';
+import YAML from 'yaml';
+import { RemoteClientLogger } from '../../remote-client/remote-client-logger';
+import path from 'node:path';
+import CloudRunnerOptions from '../../options/cloud-runner-options';
+import * as fs from 'node:fs';
+import CloudRunnerLogger from '../core/cloud-runner-logger';
+import { CommandHook } from './command-hook';
+
+// import CloudRunnerLogger from './cloud-runner-logger';
+
+export class CommandHookService {
+  public static ApplyHooksToCommands(commands: string, buildParameters: BuildParameters): string {
+    const hooks = CommandHookService.getHooks(buildParameters.commandHooks);
+    CloudRunnerLogger.log(`Applying hooks ${hooks.length}`);
+
+    return `echo "---"
+echo "start cloud runner init"
+${CloudRunnerOptions.cloudRunnerDebug ? `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(customCommandHooks: string): CommandHook[] {
+    const experimentHooks = customCommandHooks;
+    let output = new Array<CommandHook>();
+    if (experimentHooks && experimentHooks !== '') {
+      try {
+        output = YAML.parse(experimentHooks);
+      } catch (error) {
+        throw error;
+      }
+    }
+
+    return [
+      ...output.filter((x) => x.hook !== undefined && x.hook.length > 0),
+      ...CommandHookService.GetCustomHooksFromFiles(`before`),
+      ...CommandHookService.GetCustomHooksFromFiles(`after`),
+    ];
+  }
+
+  static GetCustomHooksFromFiles(hookLifecycle: string): CommandHook[] {
+    const results: CommandHook[] = [];
+
+    // RemoteClientLogger.log(`GetCustomHookFiles: ${hookLifecycle}`);
+    try {
+      const gameCiCustomHooksPath = path.join(process.cwd(), `game-ci`, `command-hooks`);
+      const files = fs.readdirSync(gameCiCustomHooksPath);
+      for (const file of files) {
+        if (!CloudRunnerOptions.commandHookFiles.includes(file.replace(`.yaml`, ``))) {
+          continue;
+        }
+        const fileContents = fs.readFileSync(path.join(gameCiCustomHooksPath, file), `utf8`);
+        const fileContentsObject = CommandHookService.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 Hooks: \n ${JSON.stringify(results, undefined, 4)}`);
+
+    return results;
+  }
+
+  private static ConvertYamlSecrets(object: CommandHook) {
+    if (object.secrets === undefined) {
+      object.secrets = [];
+
+      return;
+    }
+    object.secrets = object.secrets.map((x: any) => {
+      return {
+        ParameterKey: x.name,
+        EnvironmentVariable: Input.ToEnvVarFormat(x.name),
+        ParameterValue: x.value,
+      };
+    });
+  }
+
+  public static ParseHooks(hooks: string): CommandHook[] {
+    if (hooks === '') {
+      return [];
+    }
+
+    // if (CloudRunner.buildParameters?.cloudRunnerIntegrationTests) {
+
+    // CloudRunnerLogger.log(`Parsing build hooks: ${steps}`);
+
+    // }
+    const isArray = hooks.replace(/\s/g, ``)[0] === `-`;
+    const object: CommandHook[] = isArray ? YAML.parse(hooks) : [YAML.parse(hooks)];
+    for (const hook of object) {
+      CommandHookService.ConvertYamlSecrets(hook);
+      if (hook.secrets === undefined) {
+        hook.secrets = [];
+      }
+    }
+    if (object === undefined) {
+      throw new Error(`Failed to parse ${hooks}`);
+    }
+
+    return object;
+  }
+
+  public static getSecrets(hooks: any) {
+    const secrets = hooks.map((x: any) => x.secrets).filter((x: any) => x !== undefined && x.length > 0);
+
+    // eslint-disable-next-line unicorn/no-array-reduce
+    return secrets.length > 0 ? secrets.reduce((x: any, y: any) => [...x, ...y]) : [];
+  }
+}
--- a/src/model/cloud-runner/services/hooks/command-hook.ts
+++ b/src/model/cloud-runner/services/hooks/command-hook.ts
@@ -0,0 +1,9 @@
+import CloudRunnerSecret from '../../options/cloud-runner-secret';
+
+export class CommandHook {
+  public commands: string[] = new Array<string>();
+  public secrets: CloudRunnerSecret[] = new Array<CloudRunnerSecret>();
+  public name!: string;
+  public hook!: string[];
+  public step!: string[];
+}
--- a/src/model/cloud-runner/services/hooks/container-hook-service.ts
+++ b/src/model/cloud-runner/services/hooks/container-hook-service.ts
@@ -1,32 +1,28 @@
 import YAML from 'yaml';
-import CloudRunner from '../cloud-runner';
+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 { CustomWorkflow } from '../../workflows/custom-workflow';
+import { RemoteClientLogger } from '../../remote-client/remote-client-logger';
 import path from 'node:path';
 import fs from 'node:fs';
-import Input from '../../input';
-import CloudRunnerOptions from '../cloud-runner-options';
-import CloudRunnerLogger from './cloud-runner-logger';
-import { CustomStep } from './custom-step';
-import { CloudRunnerStepState } from '../cloud-runner-step-state';
+import Input from '../../../input';
+import CloudRunnerOptions from '../../options/cloud-runner-options';
+import { ContainerHook as ContainerHook } from './container-hook';
+import { CloudRunnerStepParameters } from '../../options/cloud-runner-step-parameters';

-export class CloudRunnerCustomSteps {
-  static GetCustomStepsFromFiles(hookLifecycle: string): CustomStep[] {
-    const results: CustomStep[] = [];
-    RemoteClientLogger.log(
-      `GetCustomStepFiles: ${hookLifecycle} CustomStepFiles: ${CloudRunnerOptions.customStepFiles}`,
-    );
+export class ContainerHookService {
+  static GetContainerHooksFromFiles(hookLifecycle: string): ContainerHook[] {
+    const results: ContainerHook[] = [];
    try {
-      const gameCiCustomStepsPath = path.join(process.cwd(), `game-ci`, `steps`);
+      const gameCiCustomStepsPath = path.join(process.cwd(), `game-ci`, `container-hooks`);
      const files = fs.readdirSync(gameCiCustomStepsPath);
      for (const file of files) {
-        if (!CloudRunnerOptions.customStepFiles.includes(file.replace(`.yaml`, ``))) {
-          RemoteClientLogger.log(`Skipping CustomStepFile: ${file}`);
+        if (!CloudRunnerOptions.containerHookFiles.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];
+        const fileContentsObject = ContainerHookService.ParseContainerHooks(fileContents)[0];
        if (fileContentsObject.hook === hookLifecycle) {
          results.push(fileContentsObject);
        }
@@ -34,9 +30,10 @@ export class CloudRunnerCustomSteps {
    } 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(
+    // RemoteClientLogger.log(`Active Steps From Files: \n ${JSON.stringify(results, undefined, 4)}`);
+
+    const builtInContainerHooks: ContainerHook[] = ContainerHookService.ParseContainerHooks(
      `- name: aws-s3-upload-build
  image: amazon/aws-cli
  hook: after
@@ -45,12 +42,12 @@ export class CloudRunnerCustomSteps {
    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-${CloudRunner.buildParameters.buildGuid}.tar${
-        CloudRunner.buildParameters.useLz4Compression ? '.lz4' : ''
-      } s3://${CloudRunner.buildParameters.awsBaseStackName}/cloud-runner-cache/$CACHE_KEY/build/build-$BUILD_GUID.tar${
-        CloudRunner.buildParameters.useLz4Compression ? '.lz4' : ''
+        CloudRunner.buildParameters.useCompressionStrategy ? '.lz4' : ''
+      } s3://${CloudRunner.buildParameters.awsStackName}/cloud-runner-cache/$CACHE_KEY/build/build-$BUILD_GUID.tar${
+        CloudRunner.buildParameters.useCompressionStrategy ? '.lz4' : ''
      }
    rm /data/cache/$CACHE_KEY/build/build-${CloudRunner.buildParameters.buildGuid}.tar${
-        CloudRunner.buildParameters.useLz4Compression ? '.lz4' : ''
+        CloudRunner.buildParameters.useCompressionStrategy ? '.lz4' : ''
      }
  secrets:
  - name: awsAccessKeyId
@@ -65,19 +62,20 @@ export class CloudRunnerCustomSteps {
    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 ${CloudRunner.buildParameters.awsBaseStackName}/cloud-runner-cache/ || true
-    aws s3 ls ${CloudRunner.buildParameters.awsBaseStackName}/cloud-runner-cache/$CACHE_KEY/build || true
+    aws s3 ls ${CloudRunner.buildParameters.awsStackName}/cloud-runner-cache/ || true
+    aws s3 ls ${CloudRunner.buildParameters.awsStackName}/cloud-runner-cache/$CACHE_KEY/build || true
+    mkdir -p /data/cache/$CACHE_KEY/build/
    aws s3 cp s3://${
-      CloudRunner.buildParameters.awsBaseStackName
+      CloudRunner.buildParameters.awsStackName
    }/cloud-runner-cache/$CACHE_KEY/build/build-$BUILD_GUID_TARGET.tar${
-        CloudRunner.buildParameters.useLz4Compression ? '.lz4' : ''
+        CloudRunner.buildParameters.useCompressionStrategy ? '.lz4' : ''
      } /data/cache/$CACHE_KEY/build/build-$BUILD_GUID_TARGET.tar${
-        CloudRunner.buildParameters.useLz4Compression ? '.lz4' : ''
+        CloudRunner.buildParameters.useCompressionStrategy ? '.lz4' : ''
      }
  secrets:
-    - name: awsAccessKeyId
-    - name: awsSecretAccessKey
-    - name: awsDefaultRegion
+    - name: AWS_ACCESS_KEY_ID
+    - name: AWS_SECRET_ACCESS_KEY
+    - name: AWS_DEFAULT_REGION
    - name: BUILD_GUID_TARGET
 - name: steam-deploy-client
  image: steamcmd/steamcmd
@@ -123,19 +121,19 @@ export class CloudRunnerCustomSteps {
    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://${
-      CloudRunner.buildParameters.awsBaseStackName
+      CloudRunner.buildParameters.awsStackName
    }/cloud-runner-cache/$CACHE_KEY/lfs
    rm -r /data/cache/$CACHE_KEY/lfs
    aws s3 cp --recursive /data/cache/$CACHE_KEY/Library s3://${
-      CloudRunner.buildParameters.awsBaseStackName
+      CloudRunner.buildParameters.awsStackName
    }/cloud-runner-cache/$CACHE_KEY/Library
    rm -r /data/cache/$CACHE_KEY/Library
  secrets:
-  - name: awsAccessKeyId
+  - name: AWS_ACCESS_KEY_ID
    value: ${process.env.AWS_ACCESS_KEY_ID || ``}
-  - name: awsSecretAccessKey
+  - name: AWS_SECRET_ACCESS_KEY
    value: ${process.env.AWS_SECRET_ACCESS_KEY || ``}
-  - name: awsDefaultRegion
+  - name: AWS_DEFAULT_REGION
    value: ${process.env.AWS_REGION || ``}
 - name: aws-s3-pull-cache
  image: amazon/aws-cli
@@ -144,30 +142,32 @@ export class CloudRunnerCustomSteps {
    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 ${CloudRunner.buildParameters.awsBaseStackName}/cloud-runner-cache/ || true
-    aws s3 ls ${CloudRunner.buildParameters.awsBaseStackName}/cloud-runner-cache/$CACHE_KEY/ || true
-    BUCKET1="${CloudRunner.buildParameters.awsBaseStackName}/cloud-runner-cache/$CACHE_KEY/Library/"
+    mkdir -p /data/cache/$CACHE_KEY/Library/
+    mkdir -p /data/cache/$CACHE_KEY/lfs/
+    aws s3 ls ${CloudRunner.buildParameters.awsStackName}/cloud-runner-cache/ || true
+    aws s3 ls ${CloudRunner.buildParameters.awsStackName}/cloud-runner-cache/$CACHE_KEY/ || true
+    BUCKET1="${CloudRunner.buildParameters.awsStackName}/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="${CloudRunner.buildParameters.awsBaseStackName}/cloud-runner-cache/$CACHE_KEY/lfs/"
+    BUCKET2="${CloudRunner.buildParameters.awsStackName}/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
+  - name: AWS_ACCESS_KEY_ID
    value: ${process.env.AWS_ACCESS_KEY_ID || ``}
-  - name: awsSecretAccessKey
+  - name: AWS_SECRET_ACCESS_KEY
    value: ${process.env.AWS_SECRET_ACCESS_KEY || ``}
-  - name: awsDefaultRegion
+  - name: AWS_DEFAULT_REGION
    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` : `#`}
+    ${CloudRunnerOptions.cloudRunnerDebug ? `apt-get install -y tree > /dev/null` : `#`}
+    ${CloudRunnerOptions.cloudRunnerDebug ? `tree -L 3 /data/cache` : `#`}
  secrets:
  - name: awsAccessKeyId
    value: ${process.env.AWS_ACCESS_KEY_ID || ``}
@@ -175,15 +175,15 @@ export class CloudRunnerCustomSteps {
    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);
+    ).filter((x) => CloudRunnerOptions.containerHookFiles.includes(x.name) && x.hook === hookLifecycle);
+    if (builtInContainerHooks.length > 0) {
+      results.push(...builtInContainerHooks);
    }

    return results;
  }

-  private static ConvertYamlSecrets(object: CustomStep) {
+  private static ConvertYamlSecrets(object: ContainerHook) {
    if (object.secrets === undefined) {
      object.secrets = [];

@@ -198,21 +198,21 @@ export class CloudRunnerCustomSteps {
    });
  }

-  public static ParseSteps(steps: string): CustomStep[] {
+  public static ParseContainerHooks(steps: string): ContainerHook[] {
    if (steps === '') {
      return [];
    }
    const isArray = steps.replace(/\s/g, ``)[0] === `-`;
-    const object: CustomStep[] = isArray ? YAML.parse(steps) : [YAML.parse(steps)];
+    const object: ContainerHook[] = isArray ? YAML.parse(steps) : [YAML.parse(steps)];
    for (const step of object) {
-      CloudRunnerCustomSteps.ConvertYamlSecrets(step);
+      ContainerHookService.ConvertYamlSecrets(step);
      if (step.secrets === undefined) {
        step.secrets = [];
      } else {
        for (const secret of step.secrets) {
          if (secret.ParameterValue === undefined && process.env[secret.EnvironmentVariable] !== undefined) {
            if (CloudRunner.buildParameters?.cloudRunnerDebug) {
-              CloudRunnerLogger.log(`Injecting custom step ${step.name} from env var ${secret.ParameterKey}`);
+              // CloudRunnerLogger.log(`Injecting custom step ${step.name} from env var ${secret.ParameterKey}`);
            }
            secret.ParameterValue = process.env[secret.ParameterKey] || ``;
          }
@@ -229,16 +229,16 @@ export class CloudRunnerCustomSteps {
    return object;
  }

-  static async RunPostBuildSteps(cloudRunnerStepState: CloudRunnerStepState) {
+  static async RunPostBuildSteps(cloudRunnerStepState: CloudRunnerStepParameters) {
    let output = ``;
-    const steps: CustomStep[] = [
-      ...CloudRunnerCustomSteps.ParseSteps(CloudRunner.buildParameters.postBuildSteps),
-      ...CloudRunnerCustomSteps.GetCustomStepsFromFiles(`after`),
+    const steps: ContainerHook[] = [
+      ...ContainerHookService.ParseContainerHooks(CloudRunner.buildParameters.postBuildContainerHooks),
+      ...ContainerHookService.GetContainerHooksFromFiles(`after`),
    ];

    if (steps.length > 0) {
      if (!CloudRunner.buildParameters.isCliMode) core.startGroup('post build steps');
-      output += await CustomWorkflow.runCustomJob(
+      output += await CustomWorkflow.runContainerJob(
        steps,
        cloudRunnerStepState.environment,
        cloudRunnerStepState.secrets,
@@ -248,16 +248,16 @@ export class CloudRunnerCustomSteps {

    return output;
  }
-  static async RunPreBuildSteps(cloudRunnerStepState: CloudRunnerStepState) {
+  static async RunPreBuildSteps(cloudRunnerStepState: CloudRunnerStepParameters) {
    let output = ``;
-    const steps: CustomStep[] = [
-      ...CloudRunnerCustomSteps.ParseSteps(CloudRunner.buildParameters.preBuildSteps),
-      ...CloudRunnerCustomSteps.GetCustomStepsFromFiles(`before`),
+    const steps: ContainerHook[] = [
+      ...ContainerHookService.ParseContainerHooks(CloudRunner.buildParameters.preBuildContainerHooks),
+      ...ContainerHookService.GetContainerHooksFromFiles(`before`),
    ];

    if (steps.length > 0) {
      if (!CloudRunner.buildParameters.isCliMode) core.startGroup('pre build steps');
-      output += await CustomWorkflow.runCustomJob(
+      output += await CustomWorkflow.runContainerJob(
        steps,
        cloudRunnerStepState.environment,
        cloudRunnerStepState.secrets,
--- a/src/model/cloud-runner/services/hooks/container-hook.ts
+++ b/src/model/cloud-runner/services/hooks/container-hook.ts
@@ -1,6 +1,6 @@
-import CloudRunnerSecret from './cloud-runner-secret';
+import CloudRunnerSecret from '../../options/cloud-runner-secret';

-export class CustomStep {
+export class ContainerHook {
  public commands!: string;
  public secrets: CloudRunnerSecret[] = new Array<CloudRunnerSecret>();
  public name!: string;
--- a/src/model/cloud-runner/services/lfs-hashing.ts
+++ b/src/model/cloud-runner/services/lfs-hashing.ts
@@ -1,47 +0,0 @@
-import path from 'node:path';
-import { CloudRunnerFolders } from './cloud-runner-folders';
-import { CloudRunnerSystem } from './cloud-runner-system';
-import fs from 'node:fs';
-import { assert } from 'node:console';
-import { Cli } from '../../cli/cli';
-import { CliFunction } from '../../cli/cli-functions-repository';
-
-export class LfsHashing {
-  public static async createLFSHashFiles() {
-    try {
-      await CloudRunnerSystem.Run(`git lfs ls-files -l | cut -d ' ' -f1 | sort > .lfs-assets-guid`);
-      await CloudRunnerSystem.Run(`md5sum .lfs-assets-guid > .lfs-assets-guid-sum`);
-      assert(fs.existsSync(`.lfs-assets-guid-sum`));
-      assert(fs.existsSync(`.lfs-assets-guid`));
-      const lfsHashes = {
-        lfsGuid: fs
-          .readFileSync(`${path.join(CloudRunnerFolders.repoPathAbsolute, `.lfs-assets-guid`)}`, 'utf8')
-          .replace(/\n/g, ``),
-        lfsGuidSum: fs
-          .readFileSync(`${path.join(CloudRunnerFolders.repoPathAbsolute, `.lfs-assets-guid-sum`)}`, 'utf8')
-          .replace('  .lfs-assets-guid', '')
-          .replace(/\n/g, ``),
-      };
-
-      return lfsHashes;
-    } catch (error) {
-      throw error;
-    }
-  }
-  public static async hashAllFiles(folder: string) {
-    const startPath = process.cwd();
-    process.chdir(folder);
-    const result = await (await CloudRunnerSystem.Run(`find -type f -exec md5sum "{}" + | sort | md5sum`))
-      .replace(/\n/g, '')
-      .split(` `)[0];
-    process.chdir(startPath);
-
-    return result;
-  }
-
-  @CliFunction(`hash`, `hash all folder contents`)
-  static async hash() {
-    const folder = Cli.options!['cachePushFrom'];
-    LfsHashing.hashAllFiles(folder);
-  }
-}
--- a/src/model/cloud-runner/services/utility/lfs-hashing.ts
+++ b/src/model/cloud-runner/services/utility/lfs-hashing.ts
@@ -0,0 +1,43 @@
+import path from 'node:path';
+import { CloudRunnerFolders } from '../../options/cloud-runner-folders';
+import { CloudRunnerSystem } from '../core/cloud-runner-system';
+import fs from 'node:fs';
+import { Cli } from '../../../cli/cli';
+import { CliFunction } from '../../../cli/cli-functions-repository';
+
+export class LfsHashing {
+  public static async createLFSHashFiles() {
+    await CloudRunnerSystem.Run(`git lfs ls-files -l | cut -d ' ' -f1 | sort > .lfs-assets-guid`);
+    await CloudRunnerSystem.Run(`md5sum .lfs-assets-guid > .lfs-assets-guid-sum`);
+    const lfsHashes = {
+      lfsGuid: fs
+        .readFileSync(`${path.join(CloudRunnerFolders.repoPathAbsolute, `.lfs-assets-guid`)}`, 'utf8')
+        .replace(/\n/g, ``),
+      lfsGuidSum: fs
+        .readFileSync(`${path.join(CloudRunnerFolders.repoPathAbsolute, `.lfs-assets-guid-sum`)}`, 'utf8')
+        .replace('  .lfs-assets-guid', '')
+        .replace(/\n/g, ``),
+    };
+
+    return lfsHashes;
+  }
+  public static async hashAllFiles(folder: string) {
+    const startPath = process.cwd();
+    process.chdir(folder);
+    const result = await (await CloudRunnerSystem.Run(`find -type f -exec md5sum "{}" + | sort | md5sum`))
+      .replace(/\n/g, '')
+      .split(` `)[0];
+    process.chdir(startPath);
+
+    return result;
+  }
+
+  @CliFunction(`hash`, `hash all folder contents`)
+  static async hash() {
+    if (!Cli.options) {
+      return;
+    }
+    const folder = Cli.options['cachePushFrom'];
+    LfsHashing.hashAllFiles(folder);
+  }
+}