feat: add providerPackage input for CloudRunner configuration

action.yml

@@ -194,6 +194,10 @@ inputs:
     description:
       '[CloudRunner] Either local, k8s or aws can be used to run builds on a remote cluster. Additional parameters must
       be configured.'
+  providerPackage:
+    default: ''
+    required: false
+    description: '[CloudRunner] Override the provider package name used to load the provider'
   containerCpu:
     default: ''
     required: false

dist/index.js

@@ -327,6 +327,7 @@ class BuildParameters {
             containerRegistryRepository: input_1.default.containerRegistryRepository,
             containerRegistryImageVersion: input_1.default.containerRegistryImageVersion,
             providerStrategy: cloud_runner_options_1.default.providerStrategy,
+            providerPackage: cloud_runner_options_1.default.providerPackage,
             buildPlatform: cloud_runner_options_1.default.buildPlatform,
             kubeConfig: cloud_runner_options_1.default.kubeConfig,
             containerMemory: cloud_runner_options_1.default.containerMemory,
@@ -751,6 +752,7 @@ const core = __importStar(__nccwpck_require__(42186));
 const test_1 = __importDefault(__nccwpck_require__(63007));
 const local_1 = __importDefault(__nccwpck_require__(66575));
 const docker_1 = __importDefault(__nccwpck_require__(42802));
+const provider_loader_1 = __importDefault(__nccwpck_require__(45788));
 const github_1 = __importDefault(__nccwpck_require__(83654));
 const shared_workspace_locking_1 = __importDefault(__nccwpck_require__(71372));
 const follow_log_stream_service_1 = __nccwpck_require__(40266);
@@ -769,7 +771,7 @@ class CloudRunner {
         if (CloudRunner.buildParameters.githubCheckId === ``) {
             CloudRunner.buildParameters.githubCheckId = await github_1.default.createGitHubCheck(CloudRunner.buildParameters.buildGuid);
         }
-        CloudRunner.setupSelectedBuildPlatform();
+        await CloudRunner.setupSelectedBuildPlatform();
         CloudRunner.defaultSecrets = task_parameter_serializer_1.TaskParameterSerializer.readDefaultSecrets();
         CloudRunner.cloudRunnerEnvironmentVariables =
             task_parameter_serializer_1.TaskParameterSerializer.createCloudRunnerEnvironmentVariables(buildParameters);
@@ -787,7 +789,7 @@ class CloudRunner {
         }
         follow_log_stream_service_1.FollowLogStreamService.Reset();
     }
-    static setupSelectedBuildPlatform() {
+    static async setupSelectedBuildPlatform() {
         cloud_runner_logger_1.default.log(`Cloud Runner platform selected ${CloudRunner.buildParameters.providerStrategy}`);
         switch (CloudRunner.buildParameters.providerStrategy) {
             case 'k8s':
@@ -805,6 +807,10 @@ class CloudRunner {
             case 'local-system':
                 CloudRunner.Provider = new local_1.default();
                 break;
+            default:
+                if (CloudRunner.buildParameters.providerStrategy !== 'local') {
+                    CloudRunner.Provider = await (0, provider_loader_1.default)(CloudRunner.buildParameters.providerPackage, CloudRunner.buildParameters);
+                }
         }
     }
     static async run(buildParameters, baseImage) {
@@ -1214,6 +1220,9 @@ class CloudRunnerOptions {
         }
         return provider || 'local';
     }
+    static get providerPackage() {
+        return (CloudRunnerOptions.getInput('providerPackage') || `unity-builder-provider-${CloudRunnerOptions.providerStrategy}`);
+    }
     static get containerCpu() {
         return CloudRunnerOptions.getInput('containerCpu') || `1024`;
     }
@@ -4214,6 +4223,78 @@ class LocalCloudRunner {
 exports["default"] = LocalCloudRunner;
 
 
+/***/ }),
+
+/***/ 45788:
+/***/ (function(__unused_webpack_module, exports) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+/**
+ * Dynamically load a provider package by name.
+ * @param providerName Name of the provider package to load
+ * @param buildParameters Build parameters passed to the provider constructor
+ * @throws Error when the provider cannot be loaded or does not implement ProviderInterface
+ */
+async function loadProvider(providerName, buildParameters) {
+    let importedModule;
+    try {
+        importedModule = await Promise.resolve().then(() => __importStar(require(providerName)));
+    }
+    catch (error) {
+        throw new Error(`Failed to load provider package '${providerName}': ${error.message}`);
+    }
+    const Provider = importedModule.default || importedModule;
+    let instance;
+    try {
+        instance = new Provider(buildParameters);
+    }
+    catch (error) {
+        throw new Error(`Failed to instantiate provider '${providerName}': ${error.message}`);
+    }
+    const requiredMethods = [
+        'cleanupWorkflow',
+        'setupWorkflow',
+        'runTaskInWorkflow',
+        'garbageCollect',
+        'listResources',
+        'listWorkflow',
+        'watchWorkflow',
+    ];
+    for (const method of requiredMethods) {
+        if (typeof instance[method] !== 'function') {
+            throw new Error(`Provider package '${providerName}' does not implement ProviderInterface. Missing method '${method}'.`);
+        }
+    }
+    return instance;
+}
+exports["default"] = loadProvider;
+
+
 /***/ }),
 
 /***/ 63007:

src/model/build-parameters.ts

@@ -54,6 +54,7 @@ class BuildParameters {
   public sshAgent!: string;
   public sshPublicKeysDirectoryPath!: string;
   public providerStrategy!: string;
+  public providerPackage!: string;
   public gitPrivateToken!: string;
   public awsStackName!: string;
   public kubeConfig!: string;
@@ -183,6 +184,7 @@ class BuildParameters {
       containerRegistryRepository: Input.containerRegistryRepository,
       containerRegistryImageVersion: Input.containerRegistryImageVersion,
       providerStrategy: CloudRunnerOptions.providerStrategy,
+      providerPackage: CloudRunnerOptions.providerPackage,
       buildPlatform: CloudRunnerOptions.buildPlatform,
       kubeConfig: CloudRunnerOptions.kubeConfig,
       containerMemory: CloudRunnerOptions.containerMemory,

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

@@ -13,6 +13,7 @@ import CloudRunnerEnvironmentVariable from './options/cloud-runner-environment-v
 import TestCloudRunner from './providers/test';
 import LocalCloudRunner from './providers/local';
 import LocalDockerCloudRunner from './providers/docker';
+import loadProvider from './providers/provider-loader';
 import GitHub from '../github';
 import SharedWorkspaceLocking from './services/core/shared-workspace-locking';
 import { FollowLogStreamService } from './services/core/follow-log-stream-service';
@@ -38,7 +39,7 @@ class CloudRunner {
     if (CloudRunner.buildParameters.githubCheckId === ``) {
       CloudRunner.buildParameters.githubCheckId = await GitHub.createGitHubCheck(CloudRunner.buildParameters.buildGuid);
     }
-    CloudRunner.setupSelectedBuildPlatform();
+    await CloudRunner.setupSelectedBuildPlatform();
     CloudRunner.defaultSecrets = TaskParameterSerializer.readDefaultSecrets();
     CloudRunner.cloudRunnerEnvironmentVariables =
       TaskParameterSerializer.createCloudRunnerEnvironmentVariables(buildParameters);
@@ -62,7 +63,7 @@ class CloudRunner {
     FollowLogStreamService.Reset();
   }
 
-  private static setupSelectedBuildPlatform() {
+  private static async setupSelectedBuildPlatform() {
     CloudRunnerLogger.log(`Cloud Runner platform selected ${CloudRunner.buildParameters.providerStrategy}`);
     switch (CloudRunner.buildParameters.providerStrategy) {
       case 'k8s':
@@ -80,6 +81,13 @@ class CloudRunner {
       case 'local-system':
         CloudRunner.Provider = new LocalCloudRunner();
         break;
+      default:
+        if (CloudRunner.buildParameters.providerStrategy !== 'local') {
+          CloudRunner.Provider = await loadProvider(
+            CloudRunner.buildParameters.providerPackage,
+            CloudRunner.buildParameters,
+          );
+        }
     }
   }
 

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

@@ -127,6 +127,12 @@ class CloudRunnerOptions {
     return provider || 'local';
   }
 
+  static get providerPackage(): string {
+    return (
+      CloudRunnerOptions.getInput('providerPackage') || `unity-builder-provider-${CloudRunnerOptions.providerStrategy}`
+    );
+  }
+
   static get containerCpu(): string {
     return CloudRunnerOptions.getInput('containerCpu') || `1024`;
   }

src/model/cloud-runner/providers/fixtures/invalid-provider.ts

@@ -0,0 +1 @@
+export default class InvalidProvider {}

src/model/cloud-runner/providers/provider-loader.test.ts

@@ -0,0 +1,19 @@
+import loadProvider from './provider-loader';
+import { ProviderInterface } from './provider-interface';
+
+describe('provider-loader', () => {
+  it('loads a provider dynamically', async () => {
+    const provider: ProviderInterface = await loadProvider('./test', {} as any);
+    expect(typeof provider.runTaskInWorkflow).toBe('function');
+  });
+
+  it('throws when provider package is missing', async () => {
+    await expect(loadProvider('non-existent-package', {} as any)).rejects.toThrow('non-existent-package');
+  });
+
+  it('throws when provider does not implement ProviderInterface', async () => {
+    await expect(loadProvider('./fixtures/invalid-provider', {} as any)).rejects.toThrow(
+      'does not implement ProviderInterface',
+    );
+  });
+});

src/model/cloud-runner/providers/provider-loader.ts

@@ -0,0 +1,48 @@
+import { ProviderInterface } from './provider-interface';
+import BuildParameters from '../../build-parameters';
+
+/**
+ * Dynamically load a provider package by name.
+ * @param providerName Name of the provider package to load
+ * @param buildParameters Build parameters passed to the provider constructor
+ * @throws Error when the provider cannot be loaded or does not implement ProviderInterface
+ */
+export default async function loadProvider(
+  providerName: string,
+  buildParameters: BuildParameters,
+): Promise<ProviderInterface> {
+  let importedModule: any;
+  try {
+    importedModule = await import(providerName);
+  } catch (error) {
+    throw new Error(`Failed to load provider package '${providerName}': ${(error as Error).message}`);
+  }
+
+  const Provider = importedModule.default || importedModule;
+  let instance: any;
+  try {
+    instance = new Provider(buildParameters);
+  } catch (error) {
+    throw new Error(`Failed to instantiate provider '${providerName}': ${(error as Error).message}`);
+  }
+
+  const requiredMethods = [
+    'cleanupWorkflow',
+    'setupWorkflow',
+    'runTaskInWorkflow',
+    'garbageCollect',
+    'listResources',
+    'listWorkflow',
+    'watchWorkflow',
+  ];
+
+  for (const method of requiredMethods) {
+    if (typeof instance[method] !== 'function') {
+      throw new Error(
+        `Provider package '${providerName}' does not implement ProviderInterface. Missing method '${method}'.`,
+      );
+    }
+  }
+
+  return instance as ProviderInterface;
+}