@cloudsnorkel/cdk-github-runners
Version:
CDK construct to create GitHub Actions self-hosted runners. Creates ephemeral runners on demand. Easy to deploy and highly customizable.
219 lines • 30.1 kB
JavaScript
;
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.CompositeProvider = void 0;
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const aws_cdk_lib_1 = require("aws-cdk-lib");
const constructs_1 = require("constructs");
const common_1 = require("./common");
/**
* A composite runner provider that implements fallback and distribution strategies.
*/
class CompositeProvider {
/**
* Creates a fallback runner provider that tries each provider in order until one succeeds.
*
* For example, given providers A, B, C:
* - Try A first
* - If A fails, try B
* - If B fails, try C
*
* You can use this to try spot instance first, and switch to on-demand instances if spot is unavailable.
*
* Or you can use this to try different instance types in order of preference.
*
* @param scope The scope in which to define this construct
* @param id The scoped construct ID
* @param providers List of runner providers to try in order
*/
static fallback(scope, id, providers) {
if (providers.length < 2) {
throw new Error('At least two providers must be specified for fallback');
}
this.validateLabels(providers);
return new FallbackRunnerProvider(scope, id, providers);
}
/**
* Creates a weighted distribution runner provider that randomly selects a provider based on weights.
*
* For example, given providers A (weight 10), B (weight 20), C (weight 30):
* - Total weight = 60
* - Probability of selecting A = 10/60 = 16.67%
* - Probability of selecting B = 20/60 = 33.33%
* - Probability of selecting C = 30/60 = 50%
*
* You can use this to distribute load across multiple instance types or availability zones.
*
* @param scope The scope in which to define this construct
* @param id The scoped construct ID
* @param weightedProviders List of weighted runner providers
*/
static distribute(scope, id, weightedProviders) {
if (weightedProviders.length < 2) {
throw new Error('At least two providers must be specified for distribution');
}
// Validate labels
this.validateLabels(weightedProviders.map(wp => wp.provider));
// Validate weights
for (const wp of weightedProviders) {
if (wp.weight <= 0) {
throw new Error('All weights must be positive numbers');
}
}
return new DistributedRunnerProvider(scope, id, weightedProviders);
}
/**
* Validates that all providers have the exact same labels.
* This is required so that any provisioned runner can match the labels requested by the GitHub workflow job.
*
* @param providers Providers to validate
*/
static validateLabels(providers) {
const firstLabels = new Set(providers[0].labels);
for (const provider of providers.slice(1)) {
const providerLabels = new Set(provider.labels);
if (firstLabels.size !== providerLabels.size || ![...firstLabels].every(label => providerLabels.has(label))) {
throw new Error(`All providers must have the exact same labels (${[...firstLabels].join(', ')} != ${[...providerLabels].join(', ')})`);
}
}
}
}
exports.CompositeProvider = CompositeProvider;
_a = JSII_RTTI_SYMBOL_1;
CompositeProvider[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.CompositeProvider", version: "0.14.21" };
/**
* Internal implementation of fallback runner provider.
*
* @internal
*/
class FallbackRunnerProvider extends constructs_1.Construct {
constructor(scope, id, providers) {
super(scope, id);
this.labels = providers[0].labels;
this.providers = providers;
}
/**
* Builds a Step Functions state machine that implements a fallback strategy.
*
* This method constructs a chain where each provider catches errors and falls back
* to the next provider in sequence. We iterate forward through providers, attaching
* catch handlers to each one (except the last) that route to the next provider.
*
* Example with providers [A, B, C]:
* - Save firstProvider = A (this will be returned)
* - Iteration 1 (i=0, provider A): A catches errors → falls back to B
* - Iteration 2 (i=1, provider B): B catches errors → falls back to C
* - Result: A → (on error) → B → (on error) → C
*
* Some providers generate one state while others (like EC2) may generate more complex chains.
* We try to avoid creating a complicated state machine, but complex chains may require wrapping in Parallel.
*
* @param parameters Runtime parameters for the step function task
* @returns A Step Functions chainable that implements the fallback logic
*/
getStepFunctionTask(parameters) {
// Get all provider chainables upfront
const providerChainables = this.providers.map(p => p.getStepFunctionTask(parameters));
// Wrap providers with multiple end states in a Parallel state
const wrappedProviderChainables = providerChainables.map((p, i) => {
if (this.canAddCatchDirectly(p)) {
return p;
}
return new aws_cdk_lib_1.aws_stepfunctions.Parallel(this, `Attempt #${i + 1}`, {
stateName: (0, common_1.generateStateName)(this, `attempt #${i + 1}`),
}).branch(p);
});
// Attach catch handlers to each provider (except the last) to fall back to the next provider
for (let i = 0; i < this.providers.length - 1; i++) {
const currentProvider = wrappedProviderChainables[i];
const nextProvider = wrappedProviderChainables[i + 1];
const endState = currentProvider.endStates[0];
endState.addCatch(nextProvider, {
errors: ['States.ALL'],
resultPath: `$.fallbackError${i + 1}`,
});
}
return wrappedProviderChainables[0];
}
/**
* Checks if we can add a catch handler directly to the provider's end state.
* This avoids wrapping in a Parallel state when possible.
*/
canAddCatchDirectly(provider) {
if (!(provider instanceof aws_cdk_lib_1.aws_stepfunctions.State)) {
return false;
}
const endStates = provider.endStates;
if (endStates.length !== 1 || !(endStates[0] instanceof aws_cdk_lib_1.aws_stepfunctions.State)) {
return false;
}
// Use 'any' type assertion because not all State types have addCatch in their type definition,
// but Task states and other executable states do support it at runtime
const endState = endStates[0];
return typeof endState.addCatch === 'function';
}
grantStateMachine(stateMachineRole) {
for (const provider of this.providers) {
provider.grantStateMachine(stateMachineRole);
}
}
status(statusFunctionRole) {
// Return statuses from all sub-providers
return this.providers.map(provider => provider.status(statusFunctionRole));
}
}
/**
* Internal implementation of distributed runner provider.
*
* @internal
*/
class DistributedRunnerProvider extends constructs_1.Construct {
constructor(scope, id, weightedProviders) {
super(scope, id);
this.weightedProviders = weightedProviders;
this.labels = weightedProviders[0].provider.labels;
this.providers = weightedProviders.map(wp => wp.provider);
}
/**
* Weighted random selection algorithm:
* 1. Generate a random number in [1, totalWeight+1)
* 2. Build cumulative weight ranges for each provider (e.g., weights [10,20,30] -> ranges [1-10, 11-30, 31-60])
* 3. Use Step Functions Choice state to route to the provider whose range contains the random number
* The first matching condition wins, so we check if rand <= cumulativeWeight for each provider in order
*
* Note: States.MathRandom returns a value in [start, end) where end is exclusive. We use [1, totalWeight+1)
* to ensure the random value can be up to totalWeight (inclusive), which allows the last provider to be selected
* when rand equals totalWeight.
*/
getStepFunctionTask(parameters) {
const totalWeight = this.weightedProviders.reduce((sum, wp) => sum + wp.weight, 0);
const rand = new aws_cdk_lib_1.aws_stepfunctions.Pass(this, 'Rand', {
stateName: (0, common_1.generateStateName)(this, 'rand'),
parameters: {
rand: aws_cdk_lib_1.aws_stepfunctions.JsonPath.mathRandom(1, totalWeight + 1),
},
resultPath: '$.composite',
});
const choice = new aws_cdk_lib_1.aws_stepfunctions.Choice(this, 'Choice', {
stateName: (0, common_1.generateStateName)(this, 'choice'),
});
rand.next(choice);
// Find provider with the highest weight
let rollingWeight = 0;
for (const wp of this.weightedProviders) {
rollingWeight += wp.weight;
choice.when(aws_cdk_lib_1.aws_stepfunctions.Condition.numberLessThanEquals('$.composite.rand', rollingWeight), wp.provider.getStepFunctionTask(parameters));
}
return rand;
}
grantStateMachine(stateMachineRole) {
for (const wp of this.weightedProviders) {
wp.provider.grantStateMachine(stateMachineRole);
}
}
status(statusFunctionRole) {
// Return statuses from all sub-providers
return this.providers.map(provider => provider.status(statusFunctionRole));
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"composite.js","sourceRoot":"","sources":["../../src/providers/composite.ts"],"names":[],"mappings":"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","sourcesContent":["import { aws_iam as iam, aws_stepfunctions as stepfunctions } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { ICompositeProvider, IRunnerProvider, IRunnerProviderStatus, RunnerRuntimeParameters, generateStateName } from './common';\n\n/**\n * Configuration for weighted distribution of runners.\n */\nexport interface WeightedRunnerProvider {\n  /**\n   * The runner provider to use.\n   */\n  readonly provider: IRunnerProvider;\n\n  /**\n   * Weight for this provider. Higher weights mean higher probability of selection.\n   * Must be a positive number.\n   */\n  readonly weight: number;\n}\n\n/**\n * A composite runner provider that implements fallback and distribution strategies.\n */\nexport class CompositeProvider {\n  /**\n   * Creates a fallback runner provider that tries each provider in order until one succeeds.\n   *\n   * For example, given providers A, B, C:\n   * - Try A first\n   * - If A fails, try B\n   * - If B fails, try C\n   *\n   * You can use this to try spot instance first, and switch to on-demand instances if spot is unavailable.\n   *\n   * Or you can use this to try different instance types in order of preference.\n   *\n   * @param scope The scope in which to define this construct\n   * @param id The scoped construct ID\n   * @param providers List of runner providers to try in order\n   */\n  public static fallback(scope: Construct, id: string, providers: IRunnerProvider[]): ICompositeProvider {\n    if (providers.length < 2) {\n      throw new Error('At least two providers must be specified for fallback');\n    }\n\n    this.validateLabels(providers);\n\n    return new FallbackRunnerProvider(scope, id, providers);\n  }\n\n  /**\n   * Creates a weighted distribution runner provider that randomly selects a provider based on weights.\n   *\n   * For example, given providers A (weight 10), B (weight 20), C (weight 30):\n   * - Total weight = 60\n   * - Probability of selecting A = 10/60 = 16.67%\n   * - Probability of selecting B = 20/60 = 33.33%\n   * - Probability of selecting C = 30/60 = 50%\n   *\n   * You can use this to distribute load across multiple instance types or availability zones.\n   *\n   * @param scope The scope in which to define this construct\n   * @param id The scoped construct ID\n   * @param weightedProviders List of weighted runner providers\n   */\n  public static distribute(scope: Construct, id: string, weightedProviders: WeightedRunnerProvider[]): ICompositeProvider {\n    if (weightedProviders.length < 2) {\n      throw new Error('At least two providers must be specified for distribution');\n    }\n\n    // Validate labels\n    this.validateLabels(weightedProviders.map(wp => wp.provider));\n\n    // Validate weights\n    for (const wp of weightedProviders) {\n      if (wp.weight <= 0) {\n        throw new Error('All weights must be positive numbers');\n      }\n    }\n\n    return new DistributedRunnerProvider(scope, id, weightedProviders);\n  }\n\n  /**\n   * Validates that all providers have the exact same labels.\n   * This is required so that any provisioned runner can match the labels requested by the GitHub workflow job.\n   *\n   * @param providers Providers to validate\n   */\n  private static validateLabels(providers: IRunnerProvider[]): void {\n    const firstLabels = new Set(providers[0].labels);\n    for (const provider of providers.slice(1)) {\n      const providerLabels = new Set(provider.labels);\n      if (firstLabels.size !== providerLabels.size || ![...firstLabels].every(label => providerLabels.has(label))) {\n        throw new Error(`All providers must have the exact same labels (${[...firstLabels].join(', ')} != ${[...providerLabels].join(', ')})`);\n      }\n    }\n  }\n}\n\n/**\n * Internal implementation of fallback runner provider.\n *\n * @internal\n */\nclass FallbackRunnerProvider extends Construct implements ICompositeProvider {\n  public readonly labels: string[];\n  public readonly providers: IRunnerProvider[];\n\n  constructor(scope: Construct, id: string, providers: IRunnerProvider[]) {\n    super(scope, id);\n    this.labels = providers[0].labels;\n    this.providers = providers;\n  }\n\n  /**\n   * Builds a Step Functions state machine that implements a fallback strategy.\n   *\n   * This method constructs a chain where each provider catches errors and falls back\n   * to the next provider in sequence. We iterate forward through providers, attaching\n   * catch handlers to each one (except the last) that route to the next provider.\n   *\n   * Example with providers [A, B, C]:\n   * - Save firstProvider = A (this will be returned)\n   * - Iteration 1 (i=0, provider A): A catches errors → falls back to B\n   * - Iteration 2 (i=1, provider B): B catches errors → falls back to C\n   * - Result: A → (on error) → B → (on error) → C\n   *\n   * Some providers generate one state while others (like EC2) may generate more complex chains.\n   * We try to avoid creating a complicated state machine, but complex chains may require wrapping in Parallel.\n   *\n   * @param parameters Runtime parameters for the step function task\n   * @returns A Step Functions chainable that implements the fallback logic\n   */\n  getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable {\n    // Get all provider chainables upfront\n    const providerChainables = this.providers.map(p => p.getStepFunctionTask(parameters));\n\n    // Wrap providers with multiple end states in a Parallel state\n    const wrappedProviderChainables = providerChainables.map((p, i) => {\n      if (this.canAddCatchDirectly(p)) {\n        return p;\n      }\n      return new stepfunctions.Parallel(this, `Attempt #${i + 1}`, {\n        stateName: generateStateName(this, `attempt #${i + 1}`),\n      }).branch(p);\n    });\n\n    // Attach catch handlers to each provider (except the last) to fall back to the next provider\n    for (let i = 0; i < this.providers.length - 1; i++) {\n      const currentProvider = wrappedProviderChainables[i];\n      const nextProvider = wrappedProviderChainables[i + 1];\n\n      const endState = (currentProvider as stepfunctions.State).endStates[0] as any;\n      endState.addCatch(nextProvider, {\n        errors: ['States.ALL'],\n        resultPath: `$.fallbackError${i + 1}`,\n      });\n    }\n\n    return wrappedProviderChainables[0];\n  }\n\n  /**\n   * Checks if we can add a catch handler directly to the provider's end state.\n   * This avoids wrapping in a Parallel state when possible.\n   */\n  private canAddCatchDirectly(provider: stepfunctions.IChainable): boolean {\n    if (!(provider instanceof stepfunctions.State)) {\n      return false;\n    }\n    const endStates = provider.endStates;\n    if (endStates.length !== 1 || !(endStates[0] instanceof stepfunctions.State)) {\n      return false;\n    }\n    // Use 'any' type assertion because not all State types have addCatch in their type definition,\n    // but Task states and other executable states do support it at runtime\n    const endState = endStates[0] as any;\n    return typeof endState.addCatch === 'function';\n  }\n\n  grantStateMachine(stateMachineRole: iam.IGrantable): void {\n    for (const provider of this.providers) {\n      provider.grantStateMachine(stateMachineRole);\n    }\n  }\n\n  status(statusFunctionRole: iam.IGrantable): IRunnerProviderStatus[] {\n    // Return statuses from all sub-providers\n    return this.providers.map(provider => provider.status(statusFunctionRole));\n  }\n}\n\n/**\n * Internal implementation of distributed runner provider.\n *\n * @internal\n */\nclass DistributedRunnerProvider extends Construct implements ICompositeProvider {\n  public readonly labels: string[];\n  public readonly providers: IRunnerProvider[];\n\n  constructor(scope: Construct, id: string, private readonly weightedProviders: WeightedRunnerProvider[]) {\n    super(scope, id);\n    this.labels = weightedProviders[0].provider.labels;\n    this.providers = weightedProviders.map(wp => wp.provider);\n  }\n\n  /**\n   * Weighted random selection algorithm:\n   * 1. Generate a random number in [1, totalWeight+1)\n   * 2. Build cumulative weight ranges for each provider (e.g., weights [10,20,30] -> ranges [1-10, 11-30, 31-60])\n   * 3. Use Step Functions Choice state to route to the provider whose range contains the random number\n   *    The first matching condition wins, so we check if rand <= cumulativeWeight for each provider in order\n   *\n   * Note: States.MathRandom returns a value in [start, end) where end is exclusive. We use [1, totalWeight+1)\n   * to ensure the random value can be up to totalWeight (inclusive), which allows the last provider to be selected\n   * when rand equals totalWeight.\n   */\n  getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable {\n    const totalWeight = this.weightedProviders.reduce((sum, wp) => sum + wp.weight, 0);\n    const rand = new stepfunctions.Pass(this, 'Rand', {\n      stateName: generateStateName(this, 'rand'),\n      parameters: {\n        rand: stepfunctions.JsonPath.mathRandom(1, totalWeight + 1),\n      },\n      resultPath: '$.composite',\n    });\n    const choice = new stepfunctions.Choice(this, 'Choice', {\n      stateName: generateStateName(this, 'choice'),\n    });\n    rand.next(choice);\n\n    // Find provider with the highest weight\n    let rollingWeight = 0;\n    for (const wp of this.weightedProviders) {\n      rollingWeight += wp.weight;\n      choice.when(\n        stepfunctions.Condition.numberLessThanEquals('$.composite.rand', rollingWeight),\n        wp.provider.getStepFunctionTask(parameters),\n      );\n    }\n\n    return rand;\n  }\n\n  grantStateMachine(stateMachineRole: iam.IGrantable): void {\n    for (const wp of this.weightedProviders) {\n      wp.provider.grantStateMachine(stateMachineRole);\n    }\n  }\n\n  status(statusFunctionRole: iam.IGrantable): IRunnerProviderStatus[] {\n    // Return statuses from all sub-providers\n    return this.providers.map(provider => provider.status(statusFunctionRole));\n  }\n}\n"]}