@aws-cdk/integ-tests-alpha/lib/assertions/waiter-state-machine.js

CDK Integration Testing Constructs

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.WaiterStateMachine = void 0;
const jsiiDeprecationWarnings = require("../../.warnings.jsii.js");
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const core_1 = require("aws-cdk-lib/core");
const constructs_1 = require("constructs");
const providers_1 = require("./providers");
/**
 * A very simple StateMachine construct highly customized to the provider framework.
 * This is so that this package does not need to depend on aws-stepfunctions module.
 *
 * The state machine continuously calls the isCompleteHandler, until it succeeds or times out.
 * The handler is called `maxAttempts` times with an `interval` duration and a `backoffRate` rate.
 *
 * For example with:
 * - maxAttempts = 360 (30 minutes)
 * - interval = 5
 * - backoffRate = 1 (no backoff)
 *
 * it will make the API Call every 5 seconds and fail after 360 failures.
 *
 * If the backoff rate is changed to 2 (for example), it will
 * - make the first call
 * - wait 5 seconds
 * - make the second call
 * - wait 15 seconds
 * - etc.
 */
class WaiterStateMachine extends constructs_1.Construct {
    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/integ-tests-alpha.WaiterStateMachine", version: "2.231.0-alpha.0" };
    /**
     * The ARN of the statemachine
     */
    stateMachineArn;
    /**
     * The IAM Role ARN of the role used by the state machine
     */
    roleArn;
    /**
     * The AssertionsProvide that handles async requests
     */
    isCompleteProvider;
    constructor(scope, id, props = {}) {
        super(scope, id);
        try {
            jsiiDeprecationWarnings._aws_cdk_integ_tests_alpha_WaiterStateMachineProps(props);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, WaiterStateMachine);
            }
            throw error;
        }
        const interval = props.interval || core_1.Duration.seconds(5);
        const totalTimeout = props.totalTimeout || core_1.Duration.minutes(30);
        const maxAttempts = calculateMaxRetries(totalTimeout.toSeconds(), interval.toSeconds(), props.backoffRate ?? 1);
        if (Math.round(maxAttempts) !== maxAttempts) {
            throw new Error(`Cannot determine retry count since totalTimeout=${totalTimeout.toSeconds()}s is not integrally dividable by queryInterval=${interval.toSeconds()}s`);
        }
        this.isCompleteProvider = new providers_1.AssertionsProvider(this, 'IsCompleteProvider', {
            handler: 'index.isComplete',
            uuid: '76b3e830-a873-425f-8453-eddd85c86925',
        });
        const timeoutProvider = new providers_1.AssertionsProvider(this, 'TimeoutProvider', {
            handler: 'index.onTimeout',
            uuid: '5c1898e0-96fb-4e3e-95d5-f6c67f3ce41a',
        });
        const role = new core_1.CfnResource(this, 'Role', {
            type: 'AWS::IAM::Role',
            properties: {
                AssumeRolePolicyDocument: {
                    Version: '2012-10-17',
                    Statement: [{ Action: 'sts:AssumeRole', Effect: 'Allow', Principal: { Service: 'states.amazonaws.com' } }],
                },
                Policies: [
                    {
                        PolicyName: 'InlineInvokeFunctions',
                        PolicyDocument: {
                            Version: '2012-10-17',
                            Statement: [{
                                    Action: 'lambda:InvokeFunction',
                                    Effect: 'Allow',
                                    Resource: [
                                        this.isCompleteProvider.serviceToken,
                                        timeoutProvider.serviceToken,
                                    ],
                                }],
                        },
                    },
                ],
            },
        });
        const definition = core_1.Stack.of(this).toJsonString({
            StartAt: 'framework-isComplete-task',
            States: {
                'framework-isComplete-task': {
                    End: true,
                    Retry: [{
                            ErrorEquals: ['States.ALL'],
                            IntervalSeconds: interval.toSeconds(),
                            MaxAttempts: maxAttempts,
                            BackoffRate: props.backoffRate ?? 1,
                        }],
                    Catch: [{
                            ErrorEquals: ['States.ALL'],
                            Next: 'framework-onTimeout-task',
                        }],
                    Type: 'Task',
                    Resource: this.isCompleteProvider.serviceToken,
                },
                'framework-onTimeout-task': {
                    End: true,
                    Type: 'Task',
                    Resource: timeoutProvider.serviceToken,
                },
            },
        });
        const resource = new core_1.CfnResource(this, 'Resource', {
            type: 'AWS::StepFunctions::StateMachine',
            properties: {
                DefinitionString: definition,
                RoleArn: role.getAtt('Arn'),
            },
        });
        resource.node.addDependency(role);
        this.stateMachineArn = resource.ref;
        this.roleArn = role.getAtt('Arn').toString();
        this.isCompleteProvider.grantInvoke(this.roleArn);
        timeoutProvider.grantInvoke(this.roleArn);
    }
}
exports.WaiterStateMachine = WaiterStateMachine;
/**
 * Calculate the max number of retries
 */
function calculateMaxRetries(maxSeconds, intervalSeconds, backoff) {
    // if backoff === 1 then we aren't really using backoff
    if (backoff === 1) {
        return Math.floor(maxSeconds / intervalSeconds);
    }
    let retries = 1;
    let nextInterval = intervalSeconds;
    let i = 0;
    while (i < maxSeconds) {
        nextInterval = nextInterval + nextInterval * backoff;
        i += nextInterval;
        if (i >= maxSeconds)
            break;
        retries++;
    }
    return retries;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"waiter-state-machine.js","sourceRoot":"","sources":["waiter-state-machine.ts"],"names":[],"mappings":"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","sourcesContent":["import { CfnResource, Duration, Stack } from 'aws-cdk-lib/core';\nimport { Construct } from 'constructs';\nimport { AssertionsProvider } from './providers';\n\n/**\n * Options for creating a WaiterStateMachine\n */\nexport interface WaiterStateMachineOptions {\n  /**\n   * The total time that the state machine will wait\n   * for a successful response\n   *\n   * @default Duration.minutes(30)\n   */\n  readonly totalTimeout?: Duration;\n\n  /**\n   * The interval (number of seconds) to wait between attempts.\n   *\n   * @default Duration.seconds(5)\n   */\n  readonly interval?: Duration;\n\n  /**\n   * Backoff between attempts.\n   *\n   * This is the multiplier by which the retry interval increases\n   * after each retry attempt.\n   *\n   * By default there is no backoff. Each retry will wait the amount of time\n   * specified by `interval`.\n   *\n   * @default 1 (no backoff)\n   */\n  readonly backoffRate?: number;\n}\n\n/**\n * Props for creating a WaiterStateMachine\n */\nexport interface WaiterStateMachineProps extends WaiterStateMachineOptions {}\n\n/**\n * A very simple StateMachine construct highly customized to the provider framework.\n * This is so that this package does not need to depend on aws-stepfunctions module.\n *\n * The state machine continuously calls the isCompleteHandler, until it succeeds or times out.\n * The handler is called `maxAttempts` times with an `interval` duration and a `backoffRate` rate.\n *\n * For example with:\n * - maxAttempts = 360 (30 minutes)\n * - interval = 5\n * - backoffRate = 1 (no backoff)\n *\n * it will make the API Call every 5 seconds and fail after 360 failures.\n *\n * If the backoff rate is changed to 2 (for example), it will\n * - make the first call\n * - wait 5 seconds\n * - make the second call\n * - wait 15 seconds\n * - etc.\n */\nexport class WaiterStateMachine extends Construct {\n  /**\n   * The ARN of the statemachine\n   */\n  public readonly stateMachineArn: string;\n\n  /**\n   * The IAM Role ARN of the role used by the state machine\n   */\n  public readonly roleArn: string;\n\n  /**\n   * The AssertionsProvide that handles async requests\n   */\n  public readonly isCompleteProvider: AssertionsProvider;\n\n  constructor(scope: Construct, id: string, props: WaiterStateMachineProps = {}) {\n    super(scope, id);\n    const interval = props.interval || Duration.seconds(5);\n    const totalTimeout = props.totalTimeout || Duration.minutes(30);\n    const maxAttempts = calculateMaxRetries(totalTimeout.toSeconds(), interval.toSeconds(), props.backoffRate ?? 1);\n\n    if (Math.round(maxAttempts) !== maxAttempts) {\n      throw new Error(`Cannot determine retry count since totalTimeout=${totalTimeout.toSeconds()}s is not integrally dividable by queryInterval=${interval.toSeconds()}s`);\n    }\n\n    this.isCompleteProvider = new AssertionsProvider(this, 'IsCompleteProvider', {\n      handler: 'index.isComplete',\n      uuid: '76b3e830-a873-425f-8453-eddd85c86925',\n    });\n\n    const timeoutProvider = new AssertionsProvider(this, 'TimeoutProvider', {\n      handler: 'index.onTimeout',\n      uuid: '5c1898e0-96fb-4e3e-95d5-f6c67f3ce41a',\n    });\n\n    const role = new CfnResource(this, 'Role', {\n      type: 'AWS::IAM::Role',\n      properties: {\n        AssumeRolePolicyDocument: {\n          Version: '2012-10-17',\n          Statement: [{ Action: 'sts:AssumeRole', Effect: 'Allow', Principal: { Service: 'states.amazonaws.com' } }],\n        },\n        Policies: [\n          {\n            PolicyName: 'InlineInvokeFunctions',\n            PolicyDocument: {\n              Version: '2012-10-17',\n              Statement: [{\n                Action: 'lambda:InvokeFunction',\n                Effect: 'Allow',\n                Resource: [\n                  this.isCompleteProvider.serviceToken,\n                  timeoutProvider.serviceToken,\n                ],\n              }],\n            },\n          },\n        ],\n      },\n    });\n\n    const definition = Stack.of(this).toJsonString({\n      StartAt: 'framework-isComplete-task',\n      States: {\n        'framework-isComplete-task': {\n          End: true,\n          Retry: [{\n            ErrorEquals: ['States.ALL'],\n            IntervalSeconds: interval.toSeconds(),\n            MaxAttempts: maxAttempts,\n            BackoffRate: props.backoffRate ?? 1,\n          }],\n          Catch: [{\n            ErrorEquals: ['States.ALL'],\n            Next: 'framework-onTimeout-task',\n          }],\n          Type: 'Task',\n          Resource: this.isCompleteProvider.serviceToken,\n        },\n        'framework-onTimeout-task': {\n          End: true,\n          Type: 'Task',\n          Resource: timeoutProvider.serviceToken,\n        },\n      },\n    });\n\n    const resource = new CfnResource(this, 'Resource', {\n      type: 'AWS::StepFunctions::StateMachine',\n      properties: {\n        DefinitionString: definition,\n        RoleArn: role.getAtt('Arn'),\n      },\n    });\n    resource.node.addDependency(role);\n\n    this.stateMachineArn = resource.ref;\n    this.roleArn = role.getAtt('Arn').toString();\n    this.isCompleteProvider.grantInvoke(this.roleArn);\n    timeoutProvider.grantInvoke(this.roleArn);\n  }\n}\n\n/**\n * Calculate the max number of retries\n */\nfunction calculateMaxRetries(maxSeconds: number, intervalSeconds: number, backoff: number): number {\n  // if backoff === 1 then we aren't really using backoff\n  if (backoff === 1) {\n    return Math.floor(maxSeconds / intervalSeconds);\n  }\n  let retries = 1;\n  let nextInterval = intervalSeconds;\n  let i = 0;\n  while (i < maxSeconds) {\n    nextInterval = nextInterval+nextInterval*backoff;\n    i+=nextInterval;\n    if (i >= maxSeconds) break;\n    retries++;\n  }\n  return retries;\n}\n"]}