@dontirun/state-machine-semaphore 0.0.0

package/lib/index.d.ts

@@ -0,0 +1,47 @@
+import { StateMachineFragment, State, IChainable, INextable } from 'aws-cdk-lib/aws-stepfunctions';
+import { Construct } from 'constructs';
+/**
+ * Interface for creating a SemaphoreGenerator
+ */
+export interface SemaphoreGeneratorProps {
+    /**
+     * Optionally set the DynamoDB table to have a specific read/write capacity with PROVISIONED billing.
+     * @default PAY_PER_REQUEST
+     */
+    readonly tableReadWriteCapacity?: TableReadWriteCapacity;
+}
+/**
+ * Read and write capacity for a PROVISIONED billing DynamoDB table.
+ */
+export interface TableReadWriteCapacity {
+    readonly readCapacity: number;
+    readonly writeCapacity: number;
+}
+export interface IChainNextable extends IChainable, INextable {
+}
+/**
+ * Sets up up the DynamoDB table that stores the State Machine semaphores.
+ * Call `generateSemaphoredJob` to generate semaphored jobs.
+ */
+export declare class SemaphoreGenerator extends Construct {
+    /**
+     * The DynamoDB table used to store semaphores.
+     */
+    private semaphoreTable;
+    /**
+     * The names and associated concurrency limits and number of uses of the sempahores.
+     */
+    private semaphoreTracker;
+    constructor(scope: Construct, id: string, props?: SemaphoreGeneratorProps);
+    /**
+     * Generates a semaphore for a StepFunction job (or chained set of jobs) to limit parallelism across executions.
+     * @param lockName The name of the semaphore.
+     * @param limit The maximum number of concurrent executions for the given lock.
+     * @param job The job (or chained jobs) to be semaphored.
+     * @param nextState The State to go to after the semaphored job completes.
+     * @param reuseLock Explicility allow the reuse of a named lock from a previously generated job. Throws an error if a different `limit` is specified. Default: false.
+     * @param comments Adds detailed comments to lock related states. Significantly increases CloudFormation template size. Default: false.
+     * @returns A StateMachineFragment that can chained to other states in the State Machine.
+     */
+    generateSemaphoredJob(lockName: string, limit: number, job: IChainNextable, nextState: State, reuseLock?: boolean, comments?: boolean): StateMachineFragment;
+}

package/lib/index.js

@@ -0,0 +1,171 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemaphoreGenerator = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_dynamodb_1 = require("aws-cdk-lib/aws-dynamodb");
+const aws_stepfunctions_1 = require("aws-cdk-lib/aws-stepfunctions");
+const aws_stepfunctions_tasks_1 = require("aws-cdk-lib/aws-stepfunctions-tasks");
+const constructs_1 = require("constructs");
+/**
+ * Sets up up the DynamoDB table that stores the State Machine semaphores.
+ * Call `generateSemaphoredJob` to generate semaphored jobs.
+ */
+class SemaphoreGenerator extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.semaphoreTracker = new Map();
+        this.semaphoreTable = new aws_dynamodb_1.Table(this, 'StateMachineSempahoreTable', {
+            partitionKey: {
+                name: 'LockName',
+                type: aws_dynamodb_1.AttributeType.STRING,
+            },
+            readCapacity: props?.tableReadWriteCapacity?.readCapacity,
+            writeCapacity: props?.tableReadWriteCapacity?.writeCapacity,
+            billingMode: props?.tableReadWriteCapacity ? aws_dynamodb_1.BillingMode.PROVISIONED : aws_dynamodb_1.BillingMode.PAY_PER_REQUEST,
+        });
+    }
+    /**
+     * Generates a semaphore for a StepFunction job (or chained set of jobs) to limit parallelism across executions.
+     * @param lockName The name of the semaphore.
+     * @param limit The maximum number of concurrent executions for the given lock.
+     * @param job The job (or chained jobs) to be semaphored.
+     * @param nextState The State to go to after the semaphored job completes.
+     * @param reuseLock Explicility allow the reuse of a named lock from a previously generated job. Throws an error if a different `limit` is specified. Default: false.
+     * @param comments Adds detailed comments to lock related states. Significantly increases CloudFormation template size. Default: false.
+     * @returns A StateMachineFragment that can chained to other states in the State Machine.
+     */
+    generateSemaphoredJob(lockName, limit, job, nextState, reuseLock, comments) {
+        let lockInfo = this.semaphoreTracker.get(lockName);
+        if (lockInfo) {
+            if (reuseLock) {
+                if (lockInfo.limit != limit) {
+                    throw new Error(`The reused \`lockName\` "${lockName}" was given a different \`limit\` than previously defined. Given: ${limit}, Previous: ${lockInfo.limit}.`);
+                }
+                else {
+                    lockInfo = { limit: lockInfo.limit, timesUsed: lockInfo.timesUsed + 1 };
+                    this.semaphoreTracker.set(lockName, lockInfo);
+                }
+            }
+            else {
+                throw new Error(`The \`lockName\` "${lockName}" was reused without explicitly allowing reuse. Set \`reuseLock\` to \`true\` if you want to reuse the lock.`);
+            }
+        }
+        else {
+            lockInfo = { limit: limit, timesUsed: 1 };
+            this.semaphoreTracker.set(lockName, lockInfo);
+        }
+        const getLock = new aws_stepfunctions_1.Parallel(this, `Get ${lockName} Lock: ${lockInfo.timesUsed}`, { resultPath: aws_stepfunctions_1.JsonPath.DISCARD });
+        const acquireLock = new aws_stepfunctions_tasks_1.DynamoUpdateItem(this, `Acquire ${lockName} Lock: ${lockInfo.timesUsed}`, {
+            comment: comments ? `Acquire a lock using a conditional update to DynamoDB. This update will do two things:
+          1) increment a counter for the number of held locks
+          2) add an attribute to the DynamoDB Item with a unique key for this execution and with a value of the time when the lock was Acquired
+          The Update includes a conditional expression that will fail under two circumstances:
+          1) if the maximum number of locks have already been distributed
+          2) if the current execution already owns a lock. The latter check is important to ensure the same execution doesn't increase the counter more than once
+          If either of these conditions are not met, then the task will fail with a DynamoDB.ConditionalCheckFailedException error, retry a few times, then if it is still not successful \
+          it will move off to another branch of the workflow. If this is the first time that a given lockname has been used, there will not be a row in DynamoDB \
+          so the update will fail with DynamoDB.AmazonDynamoDBException. In that case, this state sends the workflow to state that will create that row to initialize.
+          ` : undefined,
+            table: this.semaphoreTable,
+            key: { LockName: aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(lockName) },
+            expressionAttributeNames: {
+                '#currentlockcount': 'currentlockcount',
+                '#lockownerid.$': '$$.Execution.Id',
+            },
+            expressionAttributeValues: {
+                ':increase': aws_stepfunctions_tasks_1.DynamoAttributeValue.fromNumber(1),
+                ':limit': aws_stepfunctions_tasks_1.DynamoAttributeValue.fromNumber(limit),
+                ':lockacquiredtime': aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(aws_stepfunctions_1.JsonPath.stringAt('$$.State.EnteredTime')),
+            },
+            updateExpression: 'SET #currentlockcount = #currentlockcount + :increase, #lockownerid = :lockacquiredtime',
+            conditionExpression: 'currentlockcount <> :limit and attribute_not_exists(#lockownerid)',
+            returnValues: aws_stepfunctions_tasks_1.DynamoReturnValues.UPDATED_NEW,
+            resultPath: '$.lockinfo.acquirelock',
+        });
+        const initializeLockItem = new aws_stepfunctions_tasks_1.DynamoPutItem(this, `Initialize ${lockName} Lock Item: ${lockInfo.timesUsed}`, {
+            comment: comments ? `This state handles the case where an item hasn't been created for this lock yet. \
+      In that case, it will insert an initial item that includes the lock name as the key and currentlockcount of 0. \ 
+      The Put to DynamoDB includes a conditonal expression to fail if the an item with that key already exists, which avoids a race condition if multiple executions start at the same time. \ 
+      There are other reasons that the previous state could fail and end up here, so this is safe in those cases too.` : undefined,
+            table: this.semaphoreTable,
+            item: {
+                LockName: aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(lockName),
+                currentlockcount: aws_stepfunctions_tasks_1.DynamoAttributeValue.fromNumber(0),
+            },
+            conditionExpression: 'LockName <> :lockname',
+            expressionAttributeValues: {
+                ':lockname': aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(lockName),
+            },
+            resultPath: aws_stepfunctions_1.JsonPath.DISCARD,
+        });
+        const getCurrentLockRecord = new aws_stepfunctions_tasks_1.DynamoGetItem(this, `Get Current ${lockName} Lock Record: ${lockInfo.timesUsed}`, {
+            comment: comments ? 'This state is called when the execution is unable to acquire a lock because there limit has either been exceeded or because this execution already holds a lock. \
+      In that case, this task loads info from DDB for the current lock item so that the right decision can be made in subsequent states.' : undefined,
+            table: this.semaphoreTable,
+            key: { LockName: aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(lockName) },
+            expressionAttributeNames: { '#lockownerid.$': '$$.Execution.Id' },
+            projectionExpression: [new aws_stepfunctions_tasks_1.DynamoProjectionExpression().withAttribute('#lockownerid')],
+            resultSelector: {
+                'Item.$': '$.Item',
+                'ItemString.$': 'States.JsonToString($.Item)',
+            },
+            resultPath: '$.lockinfo.currentlockitem',
+        });
+        const checkIfLockAcquired = new aws_stepfunctions_1.Choice(this, `Check if ${lockName} Lock Already Acquired: ${lockInfo.timesUsed}`, {
+            comment: comments ? `This state checks to see if the current execution already holds a lock. It can tell that by looking for Z, which will be indicative of the timestamp value. \ 
+      That will only be there in the stringified version of the data returned from DDB if this execution holds a lock.` : undefined,
+        });
+        const continueBecauseLockWasAlreadyAcquired = new aws_stepfunctions_1.Pass(this, `Continue Because ${lockName} Lock Was Already Acquired: ${lockInfo.timesUsed}`, {
+            comment: comments ? 'In this state, we have confimed that lock is already held, so we pass the original execution input into the the function that does the work.' : undefined,
+        });
+        const waitToGetLock = new aws_stepfunctions_1.Wait(this, `Wait to Get ${lockName} Lock: ${lockInfo.timesUsed}`, {
+            comment: comments ? 'If the lock indeed not been succesfully Acquired, then wait for a bit before trying again.' : undefined,
+            time: aws_stepfunctions_1.WaitTime.duration(aws_cdk_lib_1.Duration.seconds(3)),
+        });
+        acquireLock.addRetry({ errors: ['DynamoDB.AmazonDynamoDBException'], maxAttempts: 0 })
+            .addRetry({ maxAttempts: 6, backoffRate: 2 })
+            .addCatch(initializeLockItem, { errors: ['DynamoDB.AmazonDynamoDBException'], resultPath: '$.lockinfo.acquisitionerror' })
+            .addCatch(getCurrentLockRecord, { errors: ['DynamoDB.ConditionalCheckFailedException'], resultPath: '$.lockinfo.acquisitionerror' });
+        initializeLockItem.addCatch(acquireLock, { resultPath: aws_stepfunctions_1.JsonPath.DISCARD });
+        getCurrentLockRecord.next(checkIfLockAcquired);
+        checkIfLockAcquired.when(aws_stepfunctions_1.Condition.and(aws_stepfunctions_1.Condition.isPresent('$.lockinfo.currentlockitem.ItemString'), aws_stepfunctions_1.Condition.stringMatches('$.lockinfo.currentlockitem.ItemString', '*Z')), continueBecauseLockWasAlreadyAcquired);
+        checkIfLockAcquired.otherwise(waitToGetLock);
+        waitToGetLock.next(acquireLock);
+        const releaseLock = new aws_stepfunctions_tasks_1.DynamoUpdateItem(this, `Release ${lockName} Lock: ${lockInfo.timesUsed}`, {
+            table: this.semaphoreTable,
+            key: { LockName: aws_stepfunctions_tasks_1.DynamoAttributeValue.fromString(lockName) },
+            expressionAttributeNames: {
+                '#currentlockcount': 'currentlockcount',
+                '#lockownerid.$': '$$.Execution.Id',
+            },
+            expressionAttributeValues: {
+                ':decrease': aws_stepfunctions_tasks_1.DynamoAttributeValue.fromNumber(1),
+            },
+            updateExpression: 'SET #currentlockcount = #currentlockcount - :decrease REMOVE #lockownerid',
+            conditionExpression: 'attribute_exists(#lockownerid)',
+            returnValues: aws_stepfunctions_tasks_1.DynamoReturnValues.UPDATED_NEW,
+            resultPath: aws_stepfunctions_1.JsonPath.DISCARD,
+        });
+        releaseLock.addRetry({ errors: ['DynamoDB.ConditionalCheckFailedException'], maxAttempts: 0 })
+            .addRetry({ maxAttempts: 5, backoffRate: 1.5 })
+            .addCatch(nextState, { errors: ['DynamoDB.ConditionalCheckFailedException'], resultPath: '$.lockinfo.acquisitionerror' })
+            .next(nextState);
+        getLock.branch(acquireLock);
+        getLock.endStates.forEach(j => j.next(job));
+        job.next(releaseLock);
+        class SemaphoredJob extends aws_stepfunctions_1.StateMachineFragment {
+            constructor() {
+                super(...arguments);
+                this.startState = getLock;
+                this.endStates = nextState.endStates;
+            }
+        }
+        return new SemaphoredJob(this, `${lockName}${lockInfo.timesUsed}`);
+    }
+}
+exports.SemaphoreGenerator = SemaphoreGenerator;
+_a = JSII_RTTI_SYMBOL_1;
+SemaphoreGenerator[_a] = { fqn: "@dontirun/state-machine-semaphore.SemaphoreGenerator", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;AAAA,6CAAuC;AACvC,2DAA6E;AAC7E,qEAAgK;AAChK,iFAA2K;AAC3K,2CAAuC;AA4BvC;;;GAGG;AACH,MAAa,kBAAmB,SAAQ,sBAAS;IAY/C,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA+B;QACvE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,gBAAgB,GAAG,IAAI,GAAG,EAAwB,CAAC;QACxD,IAAI,CAAC,cAAc,GAAG,IAAI,oBAAK,CAAC,IAAI,EAAE,4BAA4B,EAAE;YAClE,YAAY,EAAE;gBACZ,IAAI,EAAE,UAAU;gBAChB,IAAI,EAAE,4BAAa,CAAC,MAAM;aAC3B;YACD,YAAY,EAAE,KAAK,EAAE,sBAAsB,EAAE,YAAY;YACzD,aAAa,EAAE,KAAK,EAAE,sBAAsB,EAAE,aAAa;YAC3D,WAAW,EAAE,KAAK,EAAE,sBAAsB,CAAC,CAAC,CAAC,0BAAW,CAAC,WAAW,CAAC,CAAC,CAAC,0BAAW,CAAC,eAAe;SACnG,CAAC,CAAC;IAEL,CAAC;IACD;;;;;;;;;OASG;IACI,qBAAqB,CAC1B,QAAgB,EAAE,KAAa,EAAE,GAAmB,EAAE,SAAgB,EAAE,SAAmB,EAAE,QAAkB;QAE/G,IAAI,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACnD,IAAI,QAAQ,EAAE;YACZ,IAAI,SAAS,EAAE;gBACb,IAAI,QAAQ,CAAC,KAAK,IAAI,KAAK,EAAE;oBAC3B,MAAM,IAAI,KAAK,CAAC,4BAA4B,QAAQ,qEAAqE,KAAK,eAAe,QAAQ,CAAC,KAAK,GAAG,CAAC,CAAC;iBACjK;qBAAM;oBACL,QAAQ,GAAG,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,CAAC,SAAS,GAAG,CAAC,EAAE,CAAC;oBACxE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;iBAC/C;aACF;iBAAM;gBACL,MAAM,IAAI,KAAK,CAAC,qBAAqB,QAAQ,8GAA8G,CAAC,CAAC;aAC9J;SACF;aAAM;YACL,QAAQ,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC;YAC1C,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;SAC/C;QAED,MAAM,OAAO,GAAG,IAAI,4BAAQ,CAAC,IAAI,EAAE,OAAO,QAAQ,UAAU,QAAQ,CAAC,SAAS,EAAE,EAAE,EAAE,UAAU,EAAE,4BAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;QACpH,MAAM,WAAW,GAAG,IAAI,0CAAgB,CAAC,IAAI,EAAE,WAAW,QAAQ,UAAU,QAAQ,CAAC,SAAS,EAAE,EAC9F;YACE,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;;;;;;;;;WASjB,CAAC,CAAC,CAAC,SAAS;YACf,KAAK,EAAE,IAAI,CAAC,cAAc;YAC1B,GAAG,EAAE,EAAE,QAAQ,EAAE,8CAAoB,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE;YAC5D,wBAAwB,EAAE;gBACxB,mBAAmB,EAAE,kBAAkB;gBACvC,gBAAgB,EAAE,iBAAiB;aACpC;YACD,yBAAyB,EAAE;gBACzB,WAAW,EAAE,8CAAoB,CAAC,UAAU,CAAC,CAAC,CAAC;gBAC/C,QAAQ,EAAE,8CAAoB,CAAC,UAAU,CAAC,KAAK,CAAC;gBAChD,mBAAmB,EAAE,8CAAoB,CAAC,UAAU,CAAC,4BAAQ,CAAC,QAAQ,CAAC,sBAAsB,CAAC,CAAC;aAChG;YACD,gBAAgB,EAAE,yFAAyF;YAC3G,mBAAmB,EAAE,mEAAmE;YACxF,YAAY,EAAE,4CAAkB,CAAC,WAAW;YAC5C,UAAU,EAAE,wBAAwB;SACrC,CACF,CAAC;QACF,MAAM,kBAAkB,GAAG,IAAI,uCAAa,CAAC,IAAI,EAAE,cAAc,QAAQ,eAAe,QAAQ,CAAC,SAAS,EAAE,EAAE;YAC5G,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;;;sHAG4F,CAAC,CAAC,CAAC,SAAS;YAC5H,KAAK,EAAE,IAAI,CAAC,cAAc;YAC1B,IAAI,EAAE;gBACJ,QAAQ,EAAE,8CAAoB,CAAC,UAAU,CAAC,QAAQ,CAAC;gBACnD,gBAAgB,EAAE,8CAAoB,CAAC,UAAU,CAAC,CAAC,CAAC;aACrD;YACD,mBAAmB,EAAE,uBAAuB;YAC5C,yBAAyB,EAAE;gBACzB,WAAW,EAAE,8CAAoB,CAAC,UAAU,CAAC,QAAQ,CAAC;aACvD;YACD,UAAU,EAAE,4BAAQ,CAAC,OAAO;SAC7B,CAAC,CAAC;QAEH,MAAM,oBAAoB,GAAG,IAAI,uCAAa,CAAC,IAAI,EAAE,eAAe,QAAQ,iBAAiB,QAAQ,CAAC,SAAS,EAAE,EAAE;YACjH,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;yIAC+G,CAAA,CAAC,CAAC,SAAS;YAC9I,KAAK,EAAE,IAAI,CAAC,cAAc;YAC1B,GAAG,EAAE,EAAE,QAAQ,EAAE,8CAAoB,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE;YAC5D,wBAAwB,EAAE,EAAE,gBAAgB,EAAE,iBAAiB,EAAE;YACjE,oBAAoB,EAAE,CAAC,IAAI,oDAA0B,EAAE,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;YACtF,cAAc,EAAE;gBACd,QAAQ,EAAE,QAAQ;gBAClB,cAAc,EAAE,6BAA6B;aAC9C;YACD,UAAU,EAAE,4BAA4B;SACzC,CAAC,CAAC;QACH,MAAM,mBAAmB,GAAG,IAAI,0BAAM,CAAC,IAAI,EAAE,YAAY,QAAQ,2BAA2B,QAAQ,CAAC,SAAS,EAAE,EAAE;YAChH,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;uHAC6F,CAAA,CAAC,CAAC,SAAS;SAC7H,CAAC,CAAC;QACH,MAAM,qCAAqC,GAAG,IAAI,wBAAI,CAAC,IAAI,EAAE,oBAAoB,QAAQ,+BAA+B,QAAQ,CAAC,SAAS,EAAE,EAAE;YAC5I,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,8IAA8I,CAAC,CAAC,CAAC,SAAS;SAC/K,CAAC,CAAC;QACH,MAAM,aAAa,GAAG,IAAI,wBAAI,CAAC,IAAI,EAAE,eAAe,QAAQ,UAAU,QAAQ,CAAC,SAAS,EAAE,EAAE;YAC1F,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,4FAA4F,CAAC,CAAC,CAAC,SAAS;YAC5H,IAAI,EAAE,4BAAQ,CAAC,QAAQ,CAAC,sBAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;SAC7C,CAAC,CAAC;QACH,WAAW,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC,kCAAkC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC;aACnF,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC;aAC5C,QAAQ,CAAC,kBAAkB,EAAE,EAAE,MAAM,EAAE,CAAC,kCAAkC,CAAC,EAAE,UAAU,EAAE,6BAA6B,EAAE,CAAC;aACzH,QAAQ,CAAC,oBAAoB,EAAE,EAAE,MAAM,EAAE,CAAC,0CAA0C,CAAC,EAAE,UAAU,EAAE,6BAA6B,EAAE,CAAC,CAAC;QACvI,kBAAkB,CAAC,QAAQ,CAAC,WAAW,EAAE,EAAE,UAAU,EAAE,4BAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;QAC3E,oBAAoB,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QAC/C,mBAAmB,CAAC,IAAI,CAAC,6BAAS,CAAC,GAAG,CACpC,6BAAS,CAAC,SAAS,CAAC,uCAAuC,CAAC,EAC5D,6BAAS,CAAC,aAAa,CAAC,uCAAuC,EAAE,IAAI,CAAC,CAAC,EAAE,qCAAqC,CAC/G,CAAC;QACF,mBAAmB,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QAC7C,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAEhC,MAAM,WAAW,GAAG,IAAI,0CAAgB,CAAC,IAAI,EAAE,WAAW,QAAQ,UAAU,QAAQ,CAAC,SAAS,EAAE,EAAE;YAChG,KAAK,EAAE,IAAI,CAAC,cAAc;YAC1B,GAAG,EAAE,EAAE,QAAQ,EAAE,8CAAoB,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE;YAC5D,wBAAwB,EAAE;gBACxB,mBAAmB,EAAE,kBAAkB;gBACvC,gBAAgB,EAAE,iBAAiB;aACpC;YACD,yBAAyB,EAAE;gBACzB,WAAW,EAAE,8CAAoB,CAAC,UAAU,CAAC,CAAC,CAAC;aAChD;YACD,gBAAgB,EAAE,2EAA2E;YAC7F,mBAAmB,EAAE,gCAAgC;YACrD,YAAY,EAAE,4CAAkB,CAAC,WAAW;YAC5C,UAAU,EAAE,4BAAQ,CAAC,OAAO;SAC7B,CAAC,CAAC;QAEH,WAAW,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC,0CAA0C,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC;aAC3F,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,EAAE,GAAG,EAAE,CAAC;aAC9C,QAAQ,CAAC,SAAS,EAAE,EAAE,MAAM,EAAE,CAAC,0CAA0C,CAAC,EAAE,UAAU,EAAE,6BAA6B,EAAE,CAAC;aACxH,IAAI,CAAC,SAAS,CAAC,CAAC;QACnB,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAC5B,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QAC5C,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACtB,MAAM,aAAc,SAAQ,wCAAoB;YAAhD;;gBACkB,eAAU,GAAG,OAAO,CAAC;gBACrB,cAAS,GAAG,SAAS,CAAC,SAAS,CAAC;YAClD,CAAC;SAAA;QACD,OAAO,IAAI,aAAa,CAAC,IAAI,EAAE,GAAG,QAAQ,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC;IACrE,CAAC;;AAxKH,gDAyKC","sourcesContent":["import { Duration } from 'aws-cdk-lib';\nimport { Table, BillingMode, AttributeType } from 'aws-cdk-lib/aws-dynamodb';\nimport { Parallel, StateMachineFragment, JsonPath, Choice, Pass, Wait, WaitTime, Condition, State, IChainable, INextable } from 'aws-cdk-lib/aws-stepfunctions';\nimport { DynamoAttributeValue, DynamoGetItem, DynamoProjectionExpression, DynamoPutItem, DynamoReturnValues, DynamoUpdateItem } from 'aws-cdk-lib/aws-stepfunctions-tasks';\nimport { Construct } from 'constructs';\n\n/**\n * Interface for creating a SemaphoreGenerator\n */\nexport interface SemaphoreGeneratorProps {\n  /**\n   * Optionally set the DynamoDB table to have a specific read/write capacity with PROVISIONED billing.\n   * @default PAY_PER_REQUEST\n   */\n  readonly tableReadWriteCapacity?: TableReadWriteCapacity;\n}\n\n/**\n * Read and write capacity for a PROVISIONED billing DynamoDB table.\n */\nexport interface TableReadWriteCapacity {\n  readonly readCapacity: number;\n  readonly writeCapacity: number;\n}\n\ninterface UsageTracker {\n  readonly limit: number;\n  readonly timesUsed: number;\n}\n\nexport interface IChainNextable extends IChainable, INextable { }\n\n/**\n * Sets up up the DynamoDB table that stores the State Machine semaphores.\n * Call `generateSemaphoredJob` to generate semaphored jobs.\n */\nexport class SemaphoreGenerator extends Construct {\n\n  /**\n   * The DynamoDB table used to store semaphores.\n   */\n  private semaphoreTable: Table;\n\n  /**\n   * The names and associated concurrency limits and number of uses of the sempahores.\n   */\n  private semaphoreTracker: Map<string, UsageTracker>;\n\n  constructor(scope: Construct, id: string, props?: SemaphoreGeneratorProps) {\n    super(scope, id);\n    this.semaphoreTracker = new Map<string, UsageTracker>();\n    this.semaphoreTable = new Table(this, 'StateMachineSempahoreTable', {\n      partitionKey: {\n        name: 'LockName',\n        type: AttributeType.STRING,\n      },\n      readCapacity: props?.tableReadWriteCapacity?.readCapacity,\n      writeCapacity: props?.tableReadWriteCapacity?.writeCapacity,\n      billingMode: props?.tableReadWriteCapacity ? BillingMode.PROVISIONED : BillingMode.PAY_PER_REQUEST,\n    });\n\n  }\n  /**\n   * Generates a semaphore for a StepFunction job (or chained set of jobs) to limit parallelism across executions.\n   * @param lockName The name of the semaphore.\n   * @param limit The maximum number of concurrent executions for the given lock.\n   * @param job The job (or chained jobs) to be semaphored.\n   * @param nextState The State to go to after the semaphored job completes.\n   * @param reuseLock Explicility allow the reuse of a named lock from a previously generated job. Throws an error if a different `limit` is specified. Default: false.\n   * @param comments Adds detailed comments to lock related states. Significantly increases CloudFormation template size. Default: false.\n   * @returns A StateMachineFragment that can chained to other states in the State Machine.\n   */\n  public generateSemaphoredJob(\n    lockName: string, limit: number, job: IChainNextable, nextState: State, reuseLock?: boolean, comments?: boolean,\n  ): StateMachineFragment {\n    let lockInfo = this.semaphoreTracker.get(lockName);\n    if (lockInfo) {\n      if (reuseLock) {\n        if (lockInfo.limit != limit) {\n          throw new Error(`The reused \\`lockName\\` \"${lockName}\" was given a different \\`limit\\` than previously defined. Given: ${limit}, Previous: ${lockInfo.limit}.`);\n        } else {\n          lockInfo = { limit: lockInfo.limit, timesUsed: lockInfo.timesUsed + 1 };\n          this.semaphoreTracker.set(lockName, lockInfo);\n        }\n      } else {\n        throw new Error(`The \\`lockName\\` \"${lockName}\" was reused without explicitly allowing reuse. Set \\`reuseLock\\` to \\`true\\` if you want to reuse the lock.`);\n      }\n    } else {\n      lockInfo = { limit: limit, timesUsed: 1 };\n      this.semaphoreTracker.set(lockName, lockInfo);\n    }\n\n    const getLock = new Parallel(this, `Get ${lockName} Lock: ${lockInfo.timesUsed}`, { resultPath: JsonPath.DISCARD });\n    const acquireLock = new DynamoUpdateItem(this, `Acquire ${lockName} Lock: ${lockInfo.timesUsed}`,\n      {\n        comment: comments ? `Acquire a lock using a conditional update to DynamoDB. This update will do two things:\n          1) increment a counter for the number of held locks\n          2) add an attribute to the DynamoDB Item with a unique key for this execution and with a value of the time when the lock was Acquired\n          The Update includes a conditional expression that will fail under two circumstances:\n          1) if the maximum number of locks have already been distributed\n          2) if the current execution already owns a lock. The latter check is important to ensure the same execution doesn't increase the counter more than once\n          If either of these conditions are not met, then the task will fail with a DynamoDB.ConditionalCheckFailedException error, retry a few times, then if it is still not successful \\\n          it will move off to another branch of the workflow. If this is the first time that a given lockname has been used, there will not be a row in DynamoDB \\\n          so the update will fail with DynamoDB.AmazonDynamoDBException. In that case, this state sends the workflow to state that will create that row to initialize.\n          ` : undefined,\n        table: this.semaphoreTable,\n        key: { LockName: DynamoAttributeValue.fromString(lockName) },\n        expressionAttributeNames: {\n          '#currentlockcount': 'currentlockcount',\n          '#lockownerid.$': '$$.Execution.Id',\n        },\n        expressionAttributeValues: {\n          ':increase': DynamoAttributeValue.fromNumber(1),\n          ':limit': DynamoAttributeValue.fromNumber(limit),\n          ':lockacquiredtime': DynamoAttributeValue.fromString(JsonPath.stringAt('$$.State.EnteredTime')),\n        },\n        updateExpression: 'SET #currentlockcount = #currentlockcount + :increase, #lockownerid = :lockacquiredtime',\n        conditionExpression: 'currentlockcount <> :limit and attribute_not_exists(#lockownerid)',\n        returnValues: DynamoReturnValues.UPDATED_NEW,\n        resultPath: '$.lockinfo.acquirelock',\n      },\n    );\n    const initializeLockItem = new DynamoPutItem(this, `Initialize ${lockName} Lock Item: ${lockInfo.timesUsed}`, {\n      comment: comments ? `This state handles the case where an item hasn't been created for this lock yet. \\\n      In that case, it will insert an initial item that includes the lock name as the key and currentlockcount of 0. \\ \n      The Put to DynamoDB includes a conditonal expression to fail if the an item with that key already exists, which avoids a race condition if multiple executions start at the same time. \\ \n      There are other reasons that the previous state could fail and end up here, so this is safe in those cases too.` : undefined,\n      table: this.semaphoreTable,\n      item: {\n        LockName: DynamoAttributeValue.fromString(lockName),\n        currentlockcount: DynamoAttributeValue.fromNumber(0),\n      },\n      conditionExpression: 'LockName <> :lockname',\n      expressionAttributeValues: {\n        ':lockname': DynamoAttributeValue.fromString(lockName),\n      },\n      resultPath: JsonPath.DISCARD,\n    });\n\n    const getCurrentLockRecord = new DynamoGetItem(this, `Get Current ${lockName} Lock Record: ${lockInfo.timesUsed}`, {\n      comment: comments ? 'This state is called when the execution is unable to acquire a lock because there limit has either been exceeded or because this execution already holds a lock. \\\n      In that case, this task loads info from DDB for the current lock item so that the right decision can be made in subsequent states.': undefined,\n      table: this.semaphoreTable,\n      key: { LockName: DynamoAttributeValue.fromString(lockName) },\n      expressionAttributeNames: { '#lockownerid.$': '$$.Execution.Id' },\n      projectionExpression: [new DynamoProjectionExpression().withAttribute('#lockownerid')],\n      resultSelector: {\n        'Item.$': '$.Item',\n        'ItemString.$': 'States.JsonToString($.Item)',\n      },\n      resultPath: '$.lockinfo.currentlockitem',\n    });\n    const checkIfLockAcquired = new Choice(this, `Check if ${lockName} Lock Already Acquired: ${lockInfo.timesUsed}`, {\n      comment: comments ? `This state checks to see if the current execution already holds a lock. It can tell that by looking for Z, which will be indicative of the timestamp value. \\ \n      That will only be there in the stringified version of the data returned from DDB if this execution holds a lock.`: undefined,\n    });\n    const continueBecauseLockWasAlreadyAcquired = new Pass(this, `Continue Because ${lockName} Lock Was Already Acquired: ${lockInfo.timesUsed}`, {\n      comment: comments ? 'In this state, we have confimed that lock is already held, so we pass the original execution input into the the function that does the work.' : undefined,\n    });\n    const waitToGetLock = new Wait(this, `Wait to Get ${lockName} Lock: ${lockInfo.timesUsed}`, {\n      comment: comments ? 'If the lock indeed not been succesfully Acquired, then wait for a bit before trying again.' : undefined,\n      time: WaitTime.duration(Duration.seconds(3)),\n    });\n    acquireLock.addRetry({ errors: ['DynamoDB.AmazonDynamoDBException'], maxAttempts: 0 })\n      .addRetry({ maxAttempts: 6, backoffRate: 2 })\n      .addCatch(initializeLockItem, { errors: ['DynamoDB.AmazonDynamoDBException'], resultPath: '$.lockinfo.acquisitionerror' })\n      .addCatch(getCurrentLockRecord, { errors: ['DynamoDB.ConditionalCheckFailedException'], resultPath: '$.lockinfo.acquisitionerror' });\n    initializeLockItem.addCatch(acquireLock, { resultPath: JsonPath.DISCARD });\n    getCurrentLockRecord.next(checkIfLockAcquired);\n    checkIfLockAcquired.when(Condition.and(\n      Condition.isPresent('$.lockinfo.currentlockitem.ItemString'),\n      Condition.stringMatches('$.lockinfo.currentlockitem.ItemString', '*Z')), continueBecauseLockWasAlreadyAcquired,\n    );\n    checkIfLockAcquired.otherwise(waitToGetLock);\n    waitToGetLock.next(acquireLock);\n\n    const releaseLock = new DynamoUpdateItem(this, `Release ${lockName} Lock: ${lockInfo.timesUsed}`, {\n      table: this.semaphoreTable,\n      key: { LockName: DynamoAttributeValue.fromString(lockName) },\n      expressionAttributeNames: {\n        '#currentlockcount': 'currentlockcount',\n        '#lockownerid.$': '$$.Execution.Id',\n      },\n      expressionAttributeValues: {\n        ':decrease': DynamoAttributeValue.fromNumber(1),\n      },\n      updateExpression: 'SET #currentlockcount = #currentlockcount - :decrease REMOVE #lockownerid',\n      conditionExpression: 'attribute_exists(#lockownerid)',\n      returnValues: DynamoReturnValues.UPDATED_NEW,\n      resultPath: JsonPath.DISCARD,\n    });\n\n    releaseLock.addRetry({ errors: ['DynamoDB.ConditionalCheckFailedException'], maxAttempts: 0 })\n      .addRetry({ maxAttempts: 5, backoffRate: 1.5 })\n      .addCatch(nextState, { errors: ['DynamoDB.ConditionalCheckFailedException'], resultPath: '$.lockinfo.acquisitionerror' })\n      .next(nextState);\n    getLock.branch(acquireLock);\n    getLock.endStates.forEach(j => j.next(job));\n    job.next(releaseLock);\n    class SemaphoredJob extends StateMachineFragment {\n      public readonly startState = getLock;\n      public readonly endStates = nextState.endStates;\n    }\n    return new SemaphoredJob(this, `${lockName}${lockInfo.timesUsed}`);\n  }\n}\n"]}

package/package.json

@@ -0,0 +1,141 @@
+{
+  "name": "@dontirun/state-machine-semaphore",
+  "description": "Create distributed semaphores using AWS Step Functions and Amazon DynamoDB to control concurrent invocations of contentious work.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dontirun/state-machine-semaphore.git"
+  },
+  "scripts": {
+    "build": "npx projen build",
+    "bump": "npx projen bump",
+    "clobber": "npx projen clobber",
+    "compat": "npx projen compat",
+    "compile": "npx projen compile",
+    "default": "npx projen default",
+    "docgen": "npx projen docgen",
+    "eject": "npx projen eject",
+    "eslint": "npx projen eslint",
+    "package": "npx projen package",
+    "package-all": "npx projen package-all",
+    "package:dotnet": "npx projen package:dotnet",
+    "package:js": "npx projen package:js",
+    "package:python": "npx projen package:python",
+    "post-compile": "npx projen post-compile",
+    "post-upgrade": "npx projen post-upgrade",
+    "pre-compile": "npx projen pre-compile",
+    "release": "npx projen release",
+    "test": "npx projen test",
+    "test:update": "npx projen test:update",
+    "test:watch": "npx projen test:watch",
+    "unbump": "npx projen unbump",
+    "upgrade": "npx projen upgrade",
+    "watch": "npx projen watch",
+    "projen": "npx projen"
+  },
+  "author": {
+    "name": "Arun Donti",
+    "email": "dontirun@gmail.com",
+    "organization": false
+  },
+  "devDependencies": {
+    "@types/jest": "^27",
+    "@types/node": "^14",
+    "@typescript-eslint/eslint-plugin": "^5",
+    "@typescript-eslint/parser": "^5",
+    "aws-cdk-lib": "2.22.0",
+    "cdk-nag": "^2.15.32",
+    "constructs": "10.0.5",
+    "eslint": "^8",
+    "eslint-import-resolver-node": "^0.3.6",
+    "eslint-import-resolver-typescript": "^3.4.0",
+    "eslint-plugin-import": "^2.26.0",
+    "jest": "^27",
+    "jest-junit": "^13",
+    "jsii": "^1.63.2",
+    "jsii-diff": "^1.63.2",
+    "jsii-docgen": "^7.0.61",
+    "jsii-pacmak": "^1.63.2",
+    "json-schema": "^0.4.0",
+    "npm-check-updates": "^15",
+    "projen": "^0.60.10",
+    "standard-version": "^9",
+    "ts-jest": "^27",
+    "typescript": "^4.7.4"
+  },
+  "peerDependencies": {
+    "aws-cdk-lib": "^2.22.0",
+    "constructs": "^10.0.5"
+  },
+  "keywords": [
+    "cdk",
+    "dynamodb",
+    "state machine",
+    "step functions"
+  ],
+  "main": "lib/index.js",
+  "license": "Apache-2.0",
+  "version": "0.0.0",
+  "jest": {
+    "testMatch": [
+      "<rootDir>/src/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/(test|src)/**/*(*.)@(spec|test).ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "preset": "ts-jest",
+    "globals": {
+      "ts-jest": {
+        "tsconfig": "tsconfig.dev.json"
+      }
+    }
+  },
+  "types": "lib/index.d.ts",
+  "stability": "stable",
+  "jsii": {
+    "outdir": "dist",
+    "targets": {
+      "python": {
+        "distName": "state-machine-semaphore",
+        "module": "state_machine_semaphore"
+      },
+      "dotnet": {
+        "namespace": "Dontirun.StateMachineSemaphore",
+        "packageId": "Dontirun.StateMachineSemaphore"
+      }
+    },
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "src"
+    }
+  },
+  "resolutions": {
+    "@types/prettier": "2.6.0"
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"npx projen\"."
+}