@aws-cdk-testing/cli-integ 2.61.0

package/lib/with-sam.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shellWithAction = exports.randomInteger = exports.SamIntegrationTestFixture = exports.withSamIntegrationFixture = exports.withSamIntegrationCdkApp = void 0;
+const child_process = require("child_process");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const axios_1 = require("axios");
+const resources_1 = require("./resources");
+const shell_1 = require("./shell");
+const with_aws_1 = require("./with-aws");
+const with_cdk_app_1 = require("./with-cdk-app");
+/**
+ * Higher order function to execute a block with a SAM Integration CDK app fixture
+ */
+function withSamIntegrationCdkApp(block) {
+    return async (context) => {
+        const randy = context.randomString;
+        const stackNamePrefix = `cdktest-${randy}`;
+        const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`);
+        context.log(` Stack prefix:   ${stackNamePrefix}\n`);
+        context.log(` Test directory: ${integTestDir}\n`);
+        context.log(` Region:         ${context.aws.region}\n`);
+        await with_cdk_app_1.cloneDirectory(path.join(resources_1.RESOURCES_DIR, 'cdk-apps', 'sam_cdk_integ_app'), integTestDir, context.output);
+        const fixture = new SamIntegrationTestFixture(integTestDir, stackNamePrefix, context.output, context.aws, context.randomString);
+        let success = true;
+        try {
+            const installationVersion = fixture.packages.requestedFrameworkVersion();
+            if (fixture.packages.majorVersion() === '1') {
+                await with_cdk_app_1.installNpmPackages(fixture, {
+                    '@aws-cdk/aws-iam': installationVersion,
+                    '@aws-cdk/aws-apigateway': installationVersion,
+                    '@aws-cdk/aws-lambda': installationVersion,
+                    '@aws-cdk/aws-lambda-go': installationVersion,
+                    '@aws-cdk/aws-lambda-nodejs': installationVersion,
+                    '@aws-cdk/aws-lambda-python': installationVersion,
+                    '@aws-cdk/aws-logs': installationVersion,
+                    '@aws-cdk/core': installationVersion,
+                    'constructs': '^3',
+                });
+            }
+            else {
+                const alphaInstallationVersion = fixture.packages.requestedAlphaVersion();
+                await with_cdk_app_1.installNpmPackages(fixture, {
+                    'aws-cdk-lib': installationVersion,
+                    '@aws-cdk/aws-lambda-go-alpha': alphaInstallationVersion,
+                    '@aws-cdk/aws-lambda-python-alpha': alphaInstallationVersion,
+                    'constructs': '^10',
+                });
+            }
+            await block(fixture);
+        }
+        catch (e) {
+            // We survive certain cases involving gopkg.in
+            if (errorCausedByGoPkg(e.message)) {
+                return;
+            }
+            success = false;
+            throw e;
+        }
+        finally {
+            if (process.env.INTEG_NO_CLEAN) {
+                context.log(`Left test directory in '${integTestDir}' ($INTEG_NO_CLEAN)\n`);
+            }
+            else {
+                await fixture.dispose(success);
+            }
+        }
+    };
+}
+exports.withSamIntegrationCdkApp = withSamIntegrationCdkApp;
+/**
+ * Return whether or not the error is being caused by gopkg.in being down
+ *
+ * Our Go build depends on https://gopkg.in/, which has errors pretty often
+ * (every couple of days). It is run by a single volunteer.
+ */
+function errorCausedByGoPkg(error) {
+    // The error is different depending on what request fails. Messages recognized:
+    ////////////////////////////////////////////////////////////////////
+    //    go: github.com/aws/aws-lambda-go@v1.28.0 requires
+    //        gopkg.in/yaml.v3@v3.0.0-20200615113413-eeeca48fe776: invalid version: git ls-remote -q origin in /go/pkg/mod/cache/vcs/0901dc1ef67fcce1c9b3ae51078740de4a0e2dc673e720584ac302973af82f36: exit status 128:
+    //        remote: Cannot obtain refs from GitHub: cannot talk to GitHub: Get https://github.com/go-yaml/yaml.git/info/refs?service=git-upload-pack: net/http: request canceled (Client.Timeout exceeded while awaiting headers)
+    //        fatal: unable to access 'https://gopkg.in/yaml.v3/': The requested URL returned error: 502
+    ////////////////////////////////////////////////////////////////////
+    //    go: downloading github.com/aws/aws-lambda-go v1.28.0
+    //    go: github.com/aws/aws-lambda-go@v1.28.0 requires
+    //        gopkg.in/yaml.v3@v3.0.0-20200615113413-eeeca48fe776: unrecognized import path "gopkg.in/yaml.v3": reading https://gopkg.in/yaml.v3?go-get=1: 502 Bad Gateway
+    //        server response: Cannot obtain refs from GitHub: cannot talk to GitHub: Get https://github.com/go-yaml/yaml.git/info/refs?service=git-upload-pack: net/http: request canceled (Client.Timeout exceeded while awaiting headers)
+    ////////////////////////////////////////////////////////////////////
+    //    go: github.com/aws/aws-lambda-go@v1.28.0 requires
+    //        gopkg.in/yaml.v3@v3.0.0-20200615113413-eeeca48fe776: invalid version: git fetch -f origin refs/heads/*:refs/heads/* refs/tags/*:refs/tags/* in /go/pkg/mod/cache/vcs/0901dc1ef67fcce1c9b3ae51078740de4a0e2dc673e720584ac302973af82f36: exit status 128:
+    //        error: RPC failed; HTTP 502 curl 22 The requested URL returned error: 502
+    //        fatal: the remote end hung up unexpectedly
+    ////////////////////////////////////////////////////////////////////
+    return (error.includes('gopkg\.in.*invalid version.*exit status 128')
+        || error.match(/unrecognized import path[^\n]gopkg\.in/));
+}
+/**
+ * SAM Integration test fixture for CDK - SAM integration test cases
+ */
+function withSamIntegrationFixture(block) {
+    return with_aws_1.withAws(withSamIntegrationCdkApp(block));
+}
+exports.withSamIntegrationFixture = withSamIntegrationFixture;
+class SamIntegrationTestFixture extends with_cdk_app_1.TestFixture {
+    async samShell(command, filter, action, options = {}) {
+        return shellWithAction(command, filter, action, {
+            output: this.output,
+            cwd: path.join(this.integTestDir, 'cdk.out').toString(),
+            ...options,
+        });
+    }
+    async samBuild(stackName) {
+        const fullStackName = this.fullStackName(stackName);
+        const templatePath = path.join(this.integTestDir, 'cdk.out', `${fullStackName}.template.json`);
+        const args = ['--template', templatePath.toString()];
+        return this.samShell(['sam', 'build', ...args]);
+    }
+    async samLocalStartApi(stackName, isBuilt, port, apiPath) {
+        const fullStackName = this.fullStackName(stackName);
+        const templatePath = path.join(this.integTestDir, 'cdk.out', `${fullStackName}.template.json`);
+        const args = isBuilt ? [] : ['--template', templatePath.toString()];
+        args.push('--port');
+        args.push(port.toString());
+        return this.samShell(['sam', 'local', 'start-api', ...args], '(Press CTRL+C to quit)', () => {
+            return new Promise((resolve, reject) => {
+                axios_1.default.get(`http://127.0.0.1:${port}${apiPath}`).then(resp => {
+                    resolve(resp.data);
+                }).catch(error => {
+                    reject(new Error(`Failed to invoke api path ${apiPath} on port ${port} with error ${error}`));
+                });
+            });
+        });
+    }
+    /**
+     * Cleanup leftover stacks and buckets
+     */
+    async dispose(success) {
+        // If the tests completed successfully, happily delete the fixture
+        // (otherwise leave it for humans to inspect)
+        if (success) {
+            shell_1.rimraf(this.integTestDir);
+        }
+    }
+}
+exports.SamIntegrationTestFixture = SamIntegrationTestFixture;
+function randomInteger(min, max) {
+    return Math.floor(Math.random() * (max - min) + min);
+}
+exports.randomInteger = randomInteger;
+/**
+ * A shell command that does what you want
+ *
+ * Is platform-aware, handles errors nicely.
+ */
+async function shellWithAction(command, filter, action, options = {}) {
+    if (options.modEnv && options.env) {
+        throw new Error('Use either env or modEnv but not both');
+    }
+    options.output?.write(`💻 ${command.join(' ')}\n`);
+    const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : undefined);
+    const child = child_process.spawn(command[0], command.slice(1), {
+        ...options,
+        env,
+        // Need this for Windows where we want .cmd and .bat to be found as well.
+        shell: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return new Promise((resolve, reject) => {
+        const out = new Array();
+        const stdout = new Array();
+        const stderr = new Array();
+        let actionSucceeded = false;
+        let actionOutput;
+        let actionExecuted = false;
+        function executeAction(chunk) {
+            out.push(chunk);
+            if (!actionExecuted && typeof filter === 'string' && out.toString().includes(filter) && typeof action === 'function') {
+                actionExecuted = true;
+                options.output?.write('before executing action');
+                action().then((output) => {
+                    options.output?.write(`action output is ${output}`);
+                    actionOutput = output;
+                    actionSucceeded = true;
+                }).catch((error) => {
+                    options.output?.write(`action error is ${error}`);
+                    actionSucceeded = false;
+                    actionOutput = error;
+                }).finally(() => {
+                    options.output?.write('terminate sam sub process');
+                    killSubProcess(child, command.join(' '));
+                });
+            }
+        }
+        child.stdout.on('data', chunk => {
+            options.output?.write(chunk);
+            stdout.push(chunk);
+            executeAction(chunk);
+        });
+        child.stderr.on('data', chunk => {
+            options.output?.write(chunk);
+            if (options.captureStderr ?? true) {
+                stderr.push(chunk);
+            }
+            executeAction(chunk);
+        });
+        child.once('error', reject);
+        child.once('close', code => {
+            const output = (Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim();
+            if (code == null || code === 0 || options.allowErrExit) {
+                let result = new Array();
+                result.push(actionOutput);
+                result.push(output);
+                resolve({
+                    actionSucceeded: actionSucceeded,
+                    actionOutput: actionOutput,
+                    shellOutput: output,
+                });
+            }
+            else {
+                reject(new Error(`'${command.join(' ')}' exited with error code ${code}. Output: \n${output}`));
+            }
+        });
+    });
+}
+exports.shellWithAction = shellWithAction;
+function killSubProcess(child, command) {
+    /**
+     * Check if the sub process is running in container, so child_process.spawn will
+     * create multiple processes, and to kill all of them we need to run different logic
+     */
+    if (fs.existsSync('/.dockerenv')) {
+        child_process.exec(`for pid in $(ps -ef | grep "${command}" | awk '{print $2}'); do kill -2 $pid; done`);
+    }
+    else {
+        child.kill('SIGINT');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-sam.js","sourceRoot":"","sources":["with-sam.ts"],"names":[],"mappings":";;;AAAA,+CAA+C;AAC/C,yBAAyB;AACzB,yBAAyB;AACzB,6BAA6B;AAC7B,iCAA0B;AAE1B,2CAA4C;AAC5C,mCAA+C;AAC/C,yCAAiD;AACjD,iDAAiF;AASjF;;GAEG;AACH,SAAgB,wBAAwB,CAAqC,KAA4D;IACvI,OAAO,KAAK,EAAE,OAAU,EAAE,EAAE;QAC1B,MAAM,KAAK,GAAG,OAAO,CAAC,YAAY,CAAC;QACnC,MAAM,eAAe,GAAG,WAAW,KAAK,EAAE,CAAC;QAC3C,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,aAAa,KAAK,EAAE,CAAC,CAAC;QAElE,OAAO,CAAC,GAAG,CAAC,oBAAoB,eAAe,IAAI,CAAC,CAAC;QACrD,OAAO,CAAC,GAAG,CAAC,oBAAoB,YAAY,IAAI,CAAC,CAAC;QAClD,OAAO,CAAC,GAAG,CAAC,oBAAoB,OAAO,CAAC,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC;QAExD,MAAM,6BAAc,CAAC,IAAI,CAAC,IAAI,CAAC,yBAAa,EAAE,UAAU,EAAE,mBAAmB,CAAC,EAAE,YAAY,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;QAC9G,MAAM,OAAO,GAAG,IAAI,yBAAyB,CAC3C,YAAY,EACZ,eAAe,EACf,OAAO,CAAC,MAAM,EACd,OAAO,CAAC,GAAG,EACX,OAAO,CAAC,YAAY,CAAC,CAAC;QAExB,IAAI,OAAO,GAAG,IAAI,CAAC;QACnB,IAAI;YACF,MAAM,mBAAmB,GAAG,OAAO,CAAC,QAAQ,CAAC,yBAAyB,EAAE,CAAC;YAEzE,IAAI,OAAO,CAAC,QAAQ,CAAC,YAAY,EAAE,KAAK,GAAG,EAAE;gBAC3C,MAAM,iCAAkB,CAAC,OAAO,EAAE;oBAChC,kBAAkB,EAAE,mBAAmB;oBACvC,yBAAyB,EAAE,mBAAmB;oBAC9C,qBAAqB,EAAE,mBAAmB;oBAC1C,wBAAwB,EAAE,mBAAmB;oBAC7C,4BAA4B,EAAE,mBAAmB;oBACjD,4BAA4B,EAAE,mBAAmB;oBACjD,mBAAmB,EAAE,mBAAmB;oBACxC,eAAe,EAAE,mBAAmB;oBACpC,YAAY,EAAE,IAAI;iBACnB,CAAC,CAAC;aACJ;iBAAM;gBACL,MAAM,wBAAwB,GAAG,OAAO,CAAC,QAAQ,CAAC,qBAAqB,EAAE,CAAC;gBAC1E,MAAM,iCAAkB,CAAC,OAAO,EAAE;oBAChC,aAAa,EAAE,mBAAmB;oBAClC,8BAA8B,EAAE,wBAAwB;oBACxD,kCAAkC,EAAE,wBAAwB;oBAC5D,YAAY,EAAE,KAAK;iBACpB,CAAC,CAAC;aACJ;YACD,MAAM,KAAK,CAAC,OAAO,CAAC,CAAC;SACtB;QAAC,OAAO,CAAC,EAAE;YACV,8CAA8C;YAC9C,IAAI,kBAAkB,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE;gBACjC,OAAO;aACR;YACD,OAAO,GAAG,KAAK,CAAC;YAChB,MAAM,CAAC,CAAC;SACT;gBAAS;YACR,IAAI,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE;gBAC9B,OAAO,CAAC,GAAG,CAAC,2BAA2B,YAAY,uBAAuB,CAAC,CAAC;aAC7E;iBAAM;gBACL,MAAM,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;aAChC;SACF;IACH,CAAC,CAAC;AACJ,CAAC;AA3DD,4DA2DC;AAED;;;;;GAKG;AACH,SAAS,kBAAkB,CAAC,KAAa;IACvC,+EAA+E;IAC/E,oEAAoE;IACpE,uDAAuD;IACvD,mNAAmN;IACnN,+NAA+N;IAC/N,oGAAoG;IACpG,oEAAoE;IACpE,0DAA0D;IAC1D,uDAAuD;IACvD,sKAAsK;IACtK,wOAAwO;IACxO,oEAAoE;IACpE,uDAAuD;IACvD,iQAAiQ;IACjQ,mFAAmF;IACnF,oDAAoD;IACpD,oEAAoE;IAEpE,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,6CAA6C,CAAC;WAChE,KAAK,CAAC,KAAK,CAAC,wCAAwC,CAAC,CAAC,CAAC;AAC9D,CAAC;AAED;;GAEG;AACH,SAAgB,yBAAyB,CAAC,KAA4D;IACpG,OAAO,kBAAO,CAAc,wBAAwB,CAAC,KAAK,CAAC,CAAC,CAAC;AAC/D,CAAC;AAFD,8DAEC;AAED,MAAa,yBAA0B,SAAQ,0BAAW;IACjD,KAAK,CAAC,QAAQ,CAAC,OAAiB,EAAE,MAAe,EAAE,MAAkB,EAAE,UAAgD,EAAE;QAC9H,OAAO,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE;YAC9C,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC,QAAQ,EAAE;YACvD,GAAG,OAAO;SACX,CAAC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,QAAQ,CAAC,SAAiB;QACrC,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;QACpD,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,SAAS,EAAE,GAAG,aAAa,gBAAgB,CAAC,CAAC;QAC/F,MAAM,IAAI,GAAG,CAAC,YAAY,EAAE,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;QACrD,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC;IAClD,CAAC;IAEM,KAAK,CAAC,gBAAgB,CAAC,SAAiB,EAAE,OAAgB,EAAE,IAAY,EAAE,OAAe;QAC9F,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;QACpD,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,SAAS,EAAE,GAAG,aAAa,gBAAgB,CAAC,CAAC;QAC/F,MAAM,IAAI,GAAG,OAAO,CAAA,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;QACnE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACpB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QAE3B,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC,EAAE,wBAAwB,EAAE,GAAE,EAAE;YACzF,OAAO,IAAI,OAAO,CAAe,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACnD,eAAK,CAAC,GAAG,CAAC,oBAAoB,IAAI,GAAG,OAAO,EAAE,CAAC,CAAC,IAAI,CAAE,IAAI,CAAC,EAAE;oBAC3D,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACrB,CAAC,CAAC,CAAC,KAAK,CAAE,KAAK,CAAC,EAAE;oBAChB,MAAM,CAAC,IAAI,KAAK,CAAC,6BAA6B,OAAO,YAAY,IAAI,eAAe,KAAK,EAAE,CAAC,CAAC,CAAC;gBAChG,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,OAAO,CAAC,OAAgB;QACnC,kEAAkE;QAClE,6CAA6C;QAC7C,IAAI,OAAO,EAAE;YACX,cAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;SAC3B;IACH,CAAC;CACF;AA5CD,8DA4CC;AAED,SAAgB,aAAa,CAAC,GAAW,EAAE,GAAW;IACpD,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC;AACvD,CAAC;AAFD,sCAEC;AAED;;;;GAIG;AACI,KAAK,UAAU,eAAe,CACnC,OAAiB,EAAE,MAAe,EAAE,MAA2B,EAAE,UAAwB,EAAE;IAC3F,IAAI,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,GAAG,EAAE;QACjC,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;KAC1D;IAED,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAEnD,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAEhG,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;QAC9D,GAAG,OAAO;QACV,GAAG;QACH,yEAAyE;QACzE,KAAK,EAAE,IAAI;QACX,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC;KAClC,CAAC,CAAC;IAEH,OAAO,IAAI,OAAO,CAAe,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACnD,MAAM,GAAG,GAAG,IAAI,KAAK,EAAU,CAAC;QAChC,MAAM,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;QACnC,MAAM,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;QACnC,IAAI,eAAe,GAAG,KAAK,CAAC;QAC5B,IAAI,YAAiB,CAAC;QACtB,IAAI,cAAc,GAAG,KAAK,CAAC;QAE3B,SAAS,aAAa,CAAC,KAAU;YAC/B,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAChB,IAAI,CAAC,cAAc,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,GAAG,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE;gBACpH,cAAc,GAAG,IAAI,CAAC;gBACtB,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,yBAAyB,CAAC,CAAC;gBACjD,MAAM,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;oBACvB,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,oBAAoB,MAAM,EAAE,CAAC,CAAC;oBACpD,YAAY,GAAG,MAAM,CAAC;oBACtB,eAAe,GAAG,IAAI,CAAC;gBACzB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;oBACjB,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,mBAAmB,KAAK,EAAE,CAAC,CAAC;oBAClD,eAAe,GAAG,KAAK,CAAC;oBACxB,YAAY,GAAG,KAAK,CAAC;gBACvB,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;oBACd,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,2BAA2B,CAAC,CAAC;oBACnD,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;gBAC3C,CAAC,CAAC,CAAC;aACJ;QACH,CAAC;QAED,KAAK,CAAC,MAAO,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE;YAC/B,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;YAC7B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACnB,aAAa,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC,CAAC,CAAC;QAEH,KAAK,CAAC,MAAO,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE;YAC/B,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;YAC7B,IAAI,OAAO,CAAC,aAAa,IAAI,IAAI,EAAE;gBACjC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;aACpB;YACD,aAAa,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC,CAAC,CAAC;QAEH,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAE5B,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE;YACzB,MAAM,MAAM,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YAC1G,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,CAAC,IAAI,OAAO,CAAC,YAAY,EAAE;gBACtD,IAAI,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;gBACjC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;gBAC1B,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACpB,OAAO,CAAC;oBACN,eAAe,EAAE,eAAe;oBAChC,YAAY,EAAE,YAAY;oBAC1B,WAAW,EAAE,MAAM;iBACpB,CAAC,CAAC;aACJ;iBAAM;gBACL,MAAM,CAAC,IAAI,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,4BAA4B,IAAI,eAAe,MAAM,EAAE,CAAC,CAAC,CAAC;aACjG;QACH,CAAC,CAAC,CAAC;IAEL,CAAC,CAAC,CAAC;AACL,CAAC;AA/ED,0CA+EC;AAED,SAAS,cAAc,CAAC,KAAiC,EAAE,OAAe;IACxE;;;OAGG;IACH,IAAI,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE;QAChC,aAAa,CAAC,IAAI,CAAC,+BAA+B,OAAO,8CAA8C,CAAC,CAAC;KAC1G;SAAM;QACL,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;KACtB;AAEH,CAAC","sourcesContent":["import * as child_process from 'child_process';\nimport * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport axios from 'axios';\nimport { TestContext } from './integ-test';\nimport { RESOURCES_DIR } from './resources';\nimport { ShellOptions, rimraf } from './shell';\nimport { AwsContext, withAws } from './with-aws';\nimport { cloneDirectory, installNpmPackages, TestFixture } from './with-cdk-app';\n\n\nexport interface ActionOutput {\n  actionSucceeded?: boolean;\n  actionOutput?: any;\n  shellOutput?: string;\n}\n\n/**\n * Higher order function to execute a block with a SAM Integration CDK app fixture\n */\nexport function withSamIntegrationCdkApp<A extends TestContext & AwsContext>(block: (context: SamIntegrationTestFixture) => Promise<void>) {\n  return async (context: A) => {\n    const randy = context.randomString;\n    const stackNamePrefix = `cdktest-${randy}`;\n    const integTestDir = path.join(os.tmpdir(), `cdk-integ-${randy}`);\n\n    context.log(` Stack prefix:   ${stackNamePrefix}\\n`);\n    context.log(` Test directory: ${integTestDir}\\n`);\n    context.log(` Region:         ${context.aws.region}\\n`);\n\n    await cloneDirectory(path.join(RESOURCES_DIR, 'cdk-apps', 'sam_cdk_integ_app'), integTestDir, context.output);\n    const fixture = new SamIntegrationTestFixture(\n      integTestDir,\n      stackNamePrefix,\n      context.output,\n      context.aws,\n      context.randomString);\n\n    let success = true;\n    try {\n      const installationVersion = fixture.packages.requestedFrameworkVersion();\n\n      if (fixture.packages.majorVersion() === '1') {\n        await installNpmPackages(fixture, {\n          '@aws-cdk/aws-iam': installationVersion,\n          '@aws-cdk/aws-apigateway': installationVersion,\n          '@aws-cdk/aws-lambda': installationVersion,\n          '@aws-cdk/aws-lambda-go': installationVersion,\n          '@aws-cdk/aws-lambda-nodejs': installationVersion,\n          '@aws-cdk/aws-lambda-python': installationVersion,\n          '@aws-cdk/aws-logs': installationVersion,\n          '@aws-cdk/core': installationVersion,\n          'constructs': '^3',\n        });\n      } else {\n        const alphaInstallationVersion = fixture.packages.requestedAlphaVersion();\n        await installNpmPackages(fixture, {\n          'aws-cdk-lib': installationVersion,\n          '@aws-cdk/aws-lambda-go-alpha': alphaInstallationVersion,\n          '@aws-cdk/aws-lambda-python-alpha': alphaInstallationVersion,\n          'constructs': '^10',\n        });\n      }\n      await block(fixture);\n    } catch (e) {\n      // We survive certain cases involving gopkg.in\n      if (errorCausedByGoPkg(e.message)) {\n        return;\n      }\n      success = false;\n      throw e;\n    } finally {\n      if (process.env.INTEG_NO_CLEAN) {\n        context.log(`Left test directory in '${integTestDir}' ($INTEG_NO_CLEAN)\\n`);\n      } else {\n        await fixture.dispose(success);\n      }\n    }\n  };\n}\n\n/**\n * Return whether or not the error is being caused by gopkg.in being down\n *\n * Our Go build depends on https://gopkg.in/, which has errors pretty often\n * (every couple of days). It is run by a single volunteer.\n */\nfunction errorCausedByGoPkg(error: string) {\n  // The error is different depending on what request fails. Messages recognized:\n  ////////////////////////////////////////////////////////////////////\n  //    go: github.com/aws/aws-lambda-go@v1.28.0 requires\n  //        gopkg.in/yaml.v3@v3.0.0-20200615113413-eeeca48fe776: invalid version: git ls-remote -q origin in /go/pkg/mod/cache/vcs/0901dc1ef67fcce1c9b3ae51078740de4a0e2dc673e720584ac302973af82f36: exit status 128:\n  //        remote: Cannot obtain refs from GitHub: cannot talk to GitHub: Get https://github.com/go-yaml/yaml.git/info/refs?service=git-upload-pack: net/http: request canceled (Client.Timeout exceeded while awaiting headers)\n  //        fatal: unable to access 'https://gopkg.in/yaml.v3/': The requested URL returned error: 502\n  ////////////////////////////////////////////////////////////////////\n  //    go: downloading github.com/aws/aws-lambda-go v1.28.0\n  //    go: github.com/aws/aws-lambda-go@v1.28.0 requires\n  //        gopkg.in/yaml.v3@v3.0.0-20200615113413-eeeca48fe776: unrecognized import path \"gopkg.in/yaml.v3\": reading https://gopkg.in/yaml.v3?go-get=1: 502 Bad Gateway\n  //        server response: Cannot obtain refs from GitHub: cannot talk to GitHub: Get https://github.com/go-yaml/yaml.git/info/refs?service=git-upload-pack: net/http: request canceled (Client.Timeout exceeded while awaiting headers)\n  ////////////////////////////////////////////////////////////////////\n  //    go: github.com/aws/aws-lambda-go@v1.28.0 requires\n  //        gopkg.in/yaml.v3@v3.0.0-20200615113413-eeeca48fe776: invalid version: git fetch -f origin refs/heads/*:refs/heads/* refs/tags/*:refs/tags/* in /go/pkg/mod/cache/vcs/0901dc1ef67fcce1c9b3ae51078740de4a0e2dc673e720584ac302973af82f36: exit status 128:\n  //        error: RPC failed; HTTP 502 curl 22 The requested URL returned error: 502\n  //        fatal: the remote end hung up unexpectedly\n  ////////////////////////////////////////////////////////////////////\n\n  return (error.includes('gopkg\\.in.*invalid version.*exit status 128')\n    || error.match(/unrecognized import path[^\\n]gopkg\\.in/));\n}\n\n/**\n * SAM Integration test fixture for CDK - SAM integration test cases\n */\nexport function withSamIntegrationFixture(block: (context: SamIntegrationTestFixture) => Promise<void>) {\n  return withAws<TestContext>(withSamIntegrationCdkApp(block));\n}\n\nexport class SamIntegrationTestFixture extends TestFixture {\n  public async samShell(command: string[], filter?: string, action?: () => any, options: Omit<ShellOptions, 'cwd' | 'output'> = {}): Promise<ActionOutput> {\n    return shellWithAction(command, filter, action, {\n      output: this.output,\n      cwd: path.join(this.integTestDir, 'cdk.out').toString(),\n      ...options,\n    });\n  }\n\n  public async samBuild(stackName: string) {\n    const fullStackName = this.fullStackName(stackName);\n    const templatePath = path.join(this.integTestDir, 'cdk.out', `${fullStackName}.template.json`);\n    const args = ['--template', templatePath.toString()];\n    return this.samShell(['sam', 'build', ...args]);\n  }\n\n  public async samLocalStartApi(stackName: string, isBuilt: boolean, port: number, apiPath: string): Promise<ActionOutput> {\n    const fullStackName = this.fullStackName(stackName);\n    const templatePath = path.join(this.integTestDir, 'cdk.out', `${fullStackName}.template.json`);\n    const args = isBuilt? [] : ['--template', templatePath.toString()];\n    args.push('--port');\n    args.push(port.toString());\n\n    return this.samShell(['sam', 'local', 'start-api', ...args], '(Press CTRL+C to quit)', ()=>{\n      return new Promise<ActionOutput>((resolve, reject) => {\n        axios.get(`http://127.0.0.1:${port}${apiPath}`).then( resp => {\n          resolve(resp.data);\n        }).catch( error => {\n          reject(new Error(`Failed to invoke api path ${apiPath} on port ${port} with error ${error}`));\n        });\n      });\n    });\n  }\n\n  /**\n   * Cleanup leftover stacks and buckets\n   */\n  public async dispose(success: boolean) {\n    // If the tests completed successfully, happily delete the fixture\n    // (otherwise leave it for humans to inspect)\n    if (success) {\n      rimraf(this.integTestDir);\n    }\n  }\n}\n\nexport function randomInteger(min: number, max: number) {\n  return Math.floor(Math.random() * (max - min) + min);\n}\n\n/**\n * A shell command that does what you want\n *\n * Is platform-aware, handles errors nicely.\n */\nexport async function shellWithAction(\n  command: string[], filter?: string, action?: () => Promise<any>, options: ShellOptions = {}): Promise<ActionOutput> {\n  if (options.modEnv && options.env) {\n    throw new Error('Use either env or modEnv but not both');\n  }\n\n  options.output?.write(`💻 ${command.join(' ')}\\n`);\n\n  const env = options.env ?? (options.modEnv ? { ...process.env, ...options.modEnv } : undefined);\n\n  const child = child_process.spawn(command[0], command.slice(1), {\n    ...options,\n    env,\n    // Need this for Windows where we want .cmd and .bat to be found as well.\n    shell: true,\n    stdio: ['ignore', 'pipe', 'pipe'],\n  });\n\n  return new Promise<ActionOutput>((resolve, reject) => {\n    const out = new Array<Buffer>();\n    const stdout = new Array<Buffer>();\n    const stderr = new Array<Buffer>();\n    let actionSucceeded = false;\n    let actionOutput: any;\n    let actionExecuted = false;\n\n    function executeAction(chunk: any) {\n      out.push(chunk);\n      if (!actionExecuted && typeof filter === 'string' && out.toString().includes(filter) && typeof action === 'function') {\n        actionExecuted = true;\n        options.output?.write('before executing action');\n        action().then((output) => {\n          options.output?.write(`action output is ${output}`);\n          actionOutput = output;\n          actionSucceeded = true;\n        }).catch((error) => {\n          options.output?.write(`action error is ${error}`);\n          actionSucceeded = false;\n          actionOutput = error;\n        }).finally(() => {\n          options.output?.write('terminate sam sub process');\n          killSubProcess(child, command.join(' '));\n        });\n      }\n    }\n\n    child.stdout!.on('data', chunk => {\n      options.output?.write(chunk);\n      stdout.push(chunk);\n      executeAction(chunk);\n    });\n\n    child.stderr!.on('data', chunk => {\n      options.output?.write(chunk);\n      if (options.captureStderr ?? true) {\n        stderr.push(chunk);\n      }\n      executeAction(chunk);\n    });\n\n    child.once('error', reject);\n\n    child.once('close', code => {\n      const output = (Buffer.concat(stdout).toString('utf-8') + Buffer.concat(stderr).toString('utf-8')).trim();\n      if (code == null || code === 0 || options.allowErrExit) {\n        let result = new Array<string>();\n        result.push(actionOutput);\n        result.push(output);\n        resolve({\n          actionSucceeded: actionSucceeded,\n          actionOutput: actionOutput,\n          shellOutput: output,\n        });\n      } else {\n        reject(new Error(`'${command.join(' ')}' exited with error code ${code}. Output: \\n${output}`));\n      }\n    });\n\n  });\n}\n\nfunction killSubProcess(child: child_process.ChildProcess, command: string) {\n  /**\n   * Check if the sub process is running in container, so child_process.spawn will\n   * create multiple processes, and to kill all of them we need to run different logic\n   */\n  if (fs.existsSync('/.dockerenv')) {\n    child_process.exec(`for pid in $(ps -ef | grep \"${command}\" | awk '{print $2}'); do kill -2 $pid; done`);\n  } else {\n    child.kill('SIGINT');\n  }\n\n}"]}

package/lib/with-temporary-directory.d.ts

@@ -0,0 +1,5 @@
+import { TestContext } from './integ-test';
+export interface TemporaryDirectoryContext {
+    readonly integTestDir: string;
+}
+export declare function withTemporaryDirectory<A extends TestContext>(block: (context: A & TemporaryDirectoryContext) => Promise<void>): (context: A) => Promise<void>;

package/lib/with-temporary-directory.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTemporaryDirectory = void 0;
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const shell_1 = require("./shell");
+function withTemporaryDirectory(block) {
+    return async (context) => {
+        const integTestDir = path.join(os.tmpdir(), `cdk-integ-${context.randomString}`);
+        fs.mkdirSync(integTestDir, { recursive: true });
+        try {
+            await block({
+                ...context,
+                integTestDir,
+            });
+            // Clean up in case of success
+            if (process.env.SKIP_CLEANUP) {
+                context.log(`Left test directory in '${integTestDir}' ($SKIP_CLEANUP)\n`);
+            }
+            else {
+                shell_1.rimraf(integTestDir);
+            }
+        }
+        catch (e) {
+            context.log(`Left test directory in '${integTestDir}'\n`);
+            throw e;
+        }
+    };
+}
+exports.withTemporaryDirectory = withTemporaryDirectory;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/xpmutex.d.ts

@@ -0,0 +1,43 @@
+export declare class XpMutexPool {
+    readonly directory: string;
+    static fromDirectory(directory: string): XpMutexPool;
+    static fromName(name: string): XpMutexPool;
+    private readonly waitingResolvers;
+    private watcher;
+    private constructor();
+    mutex(name: string): XpMutex;
+    /**
+     * Await an unlock event
+     *
+     * (An unlock event is when a file in the directory gets deleted, with a tiny
+     * random sleep attached to it).
+     */
+    awaitUnlock(maxWaitMs?: number): Promise<void>;
+    private startWatch;
+    private notifyWaiters;
+}
+/**
+ * Cross-process mutex
+ *
+ * Uses the presence of a file on disk and `fs.watch` to represent the mutex
+ * and discover unlocks.
+ */
+export declare class XpMutex {
+    private readonly pool;
+    readonly mutexName: string;
+    private readonly fileName;
+    constructor(pool: XpMutexPool, mutexName: string);
+    /**
+     * Try to acquire the lock (may fail)
+     */
+    tryAcquire(): Promise<ILock | undefined>;
+    /**
+     * Acquire the lock, waiting until we can
+     */
+    acquire(): Promise<ILock>;
+    private readPidFile;
+    private writePidFile;
+}
+export interface ILock {
+    release(): Promise<void>;
+}

package/lib/xpmutex.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XpMutex = exports.XpMutexPool = void 0;
+const fs_1 = require("fs");
+const os = require("os");
+const path = require("path");
+class XpMutexPool {
+    constructor(directory) {
+        this.directory = directory;
+        this.waitingResolvers = new Set();
+        this.startWatch();
+    }
+    static fromDirectory(directory) {
+        fs_1.mkdirSync(directory, { recursive: true });
+        return new XpMutexPool(directory);
+    }
+    static fromName(name) {
+        return XpMutexPool.fromDirectory(path.join(os.tmpdir(), name));
+    }
+    mutex(name) {
+        return new XpMutex(this, name);
+    }
+    /**
+     * Await an unlock event
+     *
+     * (An unlock event is when a file in the directory gets deleted, with a tiny
+     * random sleep attached to it).
+     */
+    awaitUnlock(maxWaitMs) {
+        const wait = new Promise(ok => {
+            this.waitingResolvers.add(async () => {
+                await randomSleep(10);
+                ok();
+            });
+        });
+        if (maxWaitMs) {
+            return Promise.race([wait, sleep(maxWaitMs)]);
+        }
+        else {
+            return wait;
+        }
+    }
+    startWatch() {
+        this.watcher = fs_1.watch(this.directory);
+        this.watcher.unref(); // @types doesn't know about this but it exists
+        this.watcher.on('change', async (eventType, fname) => {
+            // Only trigger on 'deletes'.
+            // After receiving the event, we check if the file exists.
+            // - If no: the file was deleted! Huzzah, this counts as a wakeup.
+            // - If yes: either the file was just created (in which case we don't need to wakeup)
+            //   or the event was due to a delete but someone raced us to it and claimed the
+            //   file already (in which case we also don't need to wake up).
+            if (eventType === 'rename' && !await fileExists(path.join(this.directory, fname.toString()))) {
+                this.notifyWaiters();
+            }
+        });
+        this.watcher.on('error', async (e) => {
+            // eslint-disable-next-line no-console
+            console.error(e);
+            await randomSleep(100);
+            this.startWatch();
+        });
+    }
+    notifyWaiters() {
+        for (const promise of this.waitingResolvers) {
+            promise();
+        }
+        this.waitingResolvers.clear();
+    }
+}
+exports.XpMutexPool = XpMutexPool;
+/**
+ * Cross-process mutex
+ *
+ * Uses the presence of a file on disk and `fs.watch` to represent the mutex
+ * and discover unlocks.
+ */
+class XpMutex {
+    constructor(pool, mutexName) {
+        this.pool = pool;
+        this.mutexName = mutexName;
+        this.fileName = path.join(pool.directory, `${mutexName}.mutex`);
+    }
+    /**
+     * Try to acquire the lock (may fail)
+     */
+    async tryAcquire() {
+        while (true) {
+            // Acquire lock by being the one to create the file
+            try {
+                return await this.writePidFile('wx'); // Fails if the file already exists
+            }
+            catch (e) {
+                if (e.code !== 'EEXIST') {
+                    throw e;
+                }
+            }
+            // File already exists. Read the contents, see if it's an existent PID (if so, the lock is taken)
+            const ownerPid = await this.readPidFile();
+            if (ownerPid === undefined) {
+                // File got deleted just now, maybe we can acquire it again
+                continue;
+            }
+            if (processExists(ownerPid)) {
+                return undefined;
+            }
+            // If not, the lock is stale and will never be released anymore. We may
+            // delete it and acquire it anyway, but we may be racing someone else trying
+            // to do the same. Solve this as follows:
+            // - Try to acquire a lock that gives us permissions to declare the existing lock stale.
+            // - Sleep a small random period to reduce contention on this operation
+            await randomSleep(10);
+            const innerMux = new XpMutex(this.pool, `${this.mutexName}.${ownerPid}`);
+            const innerLock = await innerMux.tryAcquire();
+            if (!innerLock) {
+                return undefined;
+            }
+            // We may not release the 'inner lock' we used to acquire the rights to declare the other
+            // lock stale until we release the actual lock itself. If we did, other contenders might
+            // see it released while they're still in this fallback block and accidentally steal
+            // from a new legitimate owner.
+            return this.writePidFile('w', innerLock); // Force write lock file, attach inner lock as well
+        }
+    }
+    /**
+     * Acquire the lock, waiting until we can
+     */
+    async acquire() {
+        while (true) {
+            // Start the wait here, so we don't miss the signal if it comes after
+            // we try but before we sleep.
+            //
+            // We also periodically retry anyway since we may have missed the delete
+            // signal due to unfortunate timing.
+            const wait = this.pool.awaitUnlock(5000);
+            const lock = await this.acquire();
+            if (lock) {
+                // Ignore the wait (count as handled)
+                wait.then(() => { }, () => { });
+                return lock;
+            }
+            await wait;
+            await randomSleep(100);
+        }
+    }
+    async readPidFile() {
+        const deadLine = Date.now() + 1000;
+        while (Date.now() < deadLine) {
+            let contents;
+            try {
+                contents = await fs_1.promises.readFile(this.fileName, { encoding: 'utf-8' });
+            }
+            catch (e) {
+                if (e.code === 'ENOENT') {
+                    return undefined;
+                }
+                throw e;
+            }
+            // Retry until we've seen the full contents
+            if (contents.endsWith('.')) {
+                return parseInt(contents.substring(0, contents.length - 1), 10);
+            }
+            await sleep(10);
+        }
+        throw new Error(`${this.fileName} was never completely written`);
+    }
+    async writePidFile(mode, additionalLock) {
+        const fd = await fs_1.promises.open(this.fileName, mode); // May fail if the file already exists
+        await fd.write(`${process.pid}.`); // Period guards against partial reads
+        await fd.close();
+        return {
+            release: async () => {
+                await fs_1.promises.unlink(this.fileName);
+                await additionalLock?.release();
+            },
+        };
+    }
+}
+exports.XpMutex = XpMutex;
+async function fileExists(fileName) {
+    try {
+        await fs_1.promises.stat(fileName);
+        return true;
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return false;
+        }
+        throw e;
+    }
+}
+function processExists(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+function sleep(ms) {
+    return new Promise(ok => setTimeout(ok, ms).unref());
+}
+function randomSleep(ms) {
+    return sleep(Math.floor(Math.random() * ms));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xpmutex.js","sourceRoot":"","sources":["xpmutex.ts"],"names":[],"mappings":"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","sourcesContent":["import { watch, promises as fs, mkdirSync } from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\n\nexport class XpMutexPool {\n  public static fromDirectory(directory: string) {\n    mkdirSync(directory, { recursive: true });\n    return new XpMutexPool(directory);\n  }\n\n  public static fromName(name: string) {\n    return XpMutexPool.fromDirectory(path.join(os.tmpdir(), name));\n  }\n\n  private readonly waitingResolvers = new Set<() => void>();\n  private watcher: ReturnType<typeof watch> | undefined;\n\n  private constructor(public readonly directory: string) {\n    this.startWatch();\n  }\n\n  public mutex(name: string) {\n    return new XpMutex(this, name);\n  }\n\n  /**\n   * Await an unlock event\n   *\n   * (An unlock event is when a file in the directory gets deleted, with a tiny\n   * random sleep attached to it).\n   */\n  public awaitUnlock(maxWaitMs?: number): Promise<void> {\n    const wait = new Promise<void>(ok => {\n      this.waitingResolvers.add(async () => {\n        await randomSleep(10);\n        ok();\n      });\n    });\n\n    if (maxWaitMs) {\n      return Promise.race([wait, sleep(maxWaitMs)]);\n    } else {\n      return wait;\n    }\n  }\n\n  private startWatch() {\n    this.watcher = watch(this.directory);\n    (this.watcher as any).unref(); // @types doesn't know about this but it exists\n    this.watcher.on('change', async (eventType, fname) => {\n      // Only trigger on 'deletes'.\n      // After receiving the event, we check if the file exists.\n      // - If no: the file was deleted! Huzzah, this counts as a wakeup.\n      // - If yes: either the file was just created (in which case we don't need to wakeup)\n      //   or the event was due to a delete but someone raced us to it and claimed the\n      //   file already (in which case we also don't need to wake up).\n      if (eventType === 'rename' && !await fileExists(path.join(this.directory, fname.toString()))) {\n        this.notifyWaiters();\n      }\n    });\n    this.watcher.on('error', async (e) => {\n      // eslint-disable-next-line no-console\n      console.error(e);\n      await randomSleep(100);\n      this.startWatch();\n    });\n  }\n\n  private notifyWaiters() {\n    for (const promise of this.waitingResolvers) {\n      promise();\n    }\n    this.waitingResolvers.clear();\n  }\n}\n\n/**\n * Cross-process mutex\n *\n * Uses the presence of a file on disk and `fs.watch` to represent the mutex\n * and discover unlocks.\n */\nexport class XpMutex {\n  private readonly fileName: string;\n\n  constructor(private readonly pool: XpMutexPool, public readonly mutexName: string) {\n    this.fileName = path.join(pool.directory, `${mutexName}.mutex`);\n  }\n\n  /**\n   * Try to acquire the lock (may fail)\n   */\n  public async tryAcquire(): Promise<ILock | undefined> {\n    while (true) {\n      // Acquire lock by being the one to create the file\n      try {\n        return await this.writePidFile('wx'); // Fails if the file already exists\n      } catch (e) {\n        if (e.code !== 'EEXIST') { throw e; }\n      }\n\n      // File already exists. Read the contents, see if it's an existent PID (if so, the lock is taken)\n      const ownerPid = await this.readPidFile();\n      if (ownerPid === undefined) {\n        // File got deleted just now, maybe we can acquire it again\n        continue;\n      }\n      if (processExists(ownerPid)) {\n        return undefined;\n      }\n\n      // If not, the lock is stale and will never be released anymore. We may\n      // delete it and acquire it anyway, but we may be racing someone else trying\n      // to do the same. Solve this as follows:\n      // - Try to acquire a lock that gives us permissions to declare the existing lock stale.\n      // - Sleep a small random period to reduce contention on this operation\n      await randomSleep(10);\n      const innerMux = new XpMutex(this.pool, `${this.mutexName}.${ownerPid}`);\n      const innerLock = await innerMux.tryAcquire();\n      if (!innerLock) {\n        return undefined;\n      }\n\n      // We may not release the 'inner lock' we used to acquire the rights to declare the other\n      // lock stale until we release the actual lock itself. If we did, other contenders might\n      // see it released while they're still in this fallback block and accidentally steal\n      // from a new legitimate owner.\n      return this.writePidFile('w', innerLock); // Force write lock file, attach inner lock as well\n    }\n  }\n\n  /**\n   * Acquire the lock, waiting until we can\n   */\n  public async acquire(): Promise<ILock> {\n    while (true) {\n      // Start the wait here, so we don't miss the signal if it comes after\n      // we try but before we sleep.\n      //\n      // We also periodically retry anyway since we may have missed the delete\n      // signal due to unfortunate timing.\n      const wait = this.pool.awaitUnlock(5000);\n\n      const lock = await this.acquire();\n      if (lock) {\n        // Ignore the wait (count as handled)\n        wait.then(() => {}, () => {});\n        return lock;\n      }\n\n      await wait;\n      await randomSleep(100);\n    }\n  }\n\n  private async readPidFile(): Promise<number | undefined> {\n    const deadLine = Date.now() + 1000;\n    while (Date.now() < deadLine) {\n      let contents;\n      try {\n        contents = await fs.readFile(this.fileName, { encoding: 'utf-8' });\n      } catch (e) {\n        if (e.code === 'ENOENT') { return undefined; }\n        throw e;\n      }\n\n      // Retry until we've seen the full contents\n      if (contents.endsWith('.')) { return parseInt(contents.substring(0, contents.length - 1), 10); }\n      await sleep(10);\n    }\n\n    throw new Error(`${this.fileName} was never completely written`);\n  }\n\n  private async writePidFile(mode: string, additionalLock?: ILock): Promise<ILock> {\n    const fd = await fs.open(this.fileName, mode); // May fail if the file already exists\n    await fd.write(`${process.pid}.`); // Period guards against partial reads\n    await fd.close();\n\n    return {\n      release: async () => {\n        await fs.unlink(this.fileName);\n        await additionalLock?.release();\n      },\n    };\n  }\n}\n\nexport interface ILock {\n  release(): Promise<void>;\n}\n\nasync function fileExists(fileName: string) {\n  try {\n    await fs.stat(fileName);\n    return true;\n  } catch (e) {\n    if (e.code === 'ENOENT') { return false; }\n    throw e;\n  }\n}\n\nfunction processExists(pid: number) {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise(ok => (setTimeout(ok, ms) as any).unref());\n}\n\nfunction randomSleep(ms: number) {\n  return sleep(Math.floor(Math.random() * ms));\n}\n"]}