@aws-cdk-testing/cli-integ 0.0.0

package/lib/aws.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsClients = void 0;
+exports.isStackMissingError = isStackMissingError;
+exports.isBucketMissingError = isBucketMissingError;
+exports.retry = retry;
+exports.outputFromStack = outputFromStack;
+exports.sleep = sleep;
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+const client_ecr_1 = require("@aws-sdk/client-ecr");
+const client_ecs_1 = require("@aws-sdk/client-ecs");
+const client_iam_1 = require("@aws-sdk/client-iam");
+const client_lambda_1 = require("@aws-sdk/client-lambda");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const client_sns_1 = require("@aws-sdk/client-sns");
+const client_sso_1 = require("@aws-sdk/client-sso");
+const client_sts_1 = require("@aws-sdk/client-sts");
+const credential_providers_1 = require("@aws-sdk/credential-providers");
+const util_retry_1 = require("@smithy/util-retry");
+class AwsClients {
+    static async default(output) {
+        var _a, _b;
+        const region = (_b = (_a = process.env.AWS_REGION) !== null && _a !== void 0 ? _a : process.env.AWS_DEFAULT_REGION) !== null && _b !== void 0 ? _b : 'us-east-1';
+        return AwsClients.forRegion(region, output);
+    }
+    static async forRegion(region, output) {
+        return new AwsClients(region, output);
+    }
+    constructor(region, output) {
+        this.region = region;
+        this.output = output;
+        this.config = {
+            credentials: chainableCredentials(this.region),
+            region: this.region,
+            retryStrategy: new util_retry_1.ConfiguredRetryStrategy(9, (attempt) => attempt ** 500),
+        };
+        this.cloudFormation = new client_cloudformation_1.CloudFormationClient(this.config);
+        this.s3 = new client_s3_1.S3Client(this.config);
+        this.ecr = new client_ecr_1.ECRClient(this.config);
+        this.ecs = new client_ecs_1.ECSClient(this.config);
+        this.sso = new client_sso_1.SSOClient(this.config);
+        this.sns = new client_sns_1.SNSClient(this.config);
+        this.iam = new client_iam_1.IAMClient(this.config);
+        this.lambda = new client_lambda_1.LambdaClient(this.config);
+        this.sts = new client_sts_1.STSClient(this.config);
+    }
+    async account() {
+        // Reduce # of retries, we use this as a circuit breaker for detecting no-config
+        const stsClient = new client_sts_1.STSClient({
+            credentials: this.config.credentials,
+            region: this.config.region,
+            maxAttempts: 2,
+        });
+        return (await stsClient.send(new client_sts_1.GetCallerIdentityCommand({}))).Account;
+    }
+    async deleteStacks(...stackNames) {
+        if (stackNames.length === 0) {
+            return;
+        }
+        // We purposely do all stacks serially, because they've been ordered
+        // to do the bootstrap stack last.
+        for (const stackName of stackNames) {
+            await this.cloudFormation.send(new client_cloudformation_1.UpdateTerminationProtectionCommand({
+                EnableTerminationProtection: false,
+                StackName: stackName,
+            }));
+            await this.cloudFormation.send(new client_cloudformation_1.DeleteStackCommand({
+                StackName: stackName,
+            }));
+            await retry(this.output, `Deleting ${stackName}`, retry.forSeconds(600), async () => {
+                const status = await this.stackStatus(stackName);
+                if (status !== undefined && status.endsWith('_FAILED')) {
+                    throw retry.abort(new Error(`'${stackName}' is in state '${status}'`));
+                }
+                if (status !== undefined) {
+                    throw new Error(`Delete of '${stackName}' not complete yet, status: '${status}'`);
+                }
+            });
+        }
+    }
+    async stackStatus(stackName) {
+        var _a;
+        try {
+            return (_a = (await this.cloudFormation.send(new client_cloudformation_1.DescribeStacksCommand({
+                StackName: stackName,
+            }))).Stacks) === null || _a === void 0 ? void 0 : _a[0].StackStatus;
+        }
+        catch (e) {
+            if (isStackMissingError(e)) {
+                return undefined;
+            }
+            throw e;
+        }
+    }
+    async emptyBucket(bucketName, options) {
+        const objects = await this.s3.send(new client_s3_1.ListObjectVersionsCommand({
+            Bucket: bucketName,
+        }));
+        const deletes = [...(objects.Versions || []), ...(objects.DeleteMarkers || [])].reduce((acc, obj) => {
+            if (typeof obj.VersionId !== 'undefined' && typeof obj.Key !== 'undefined') {
+                acc.push({ Key: obj.Key, VersionId: obj.VersionId });
+            }
+            else if (typeof obj.Key !== 'undefined') {
+                acc.push({ Key: obj.Key });
+            }
+            return acc;
+        }, []);
+        if (deletes.length === 0) {
+            return Promise.resolve();
+        }
+        return this.s3.send(new client_s3_1.DeleteObjectsCommand({
+            Bucket: bucketName,
+            Delete: {
+                Objects: deletes,
+                Quiet: false,
+            },
+            BypassGovernanceRetention: (options === null || options === void 0 ? void 0 : options.bypassGovernance) ? true : undefined,
+        }));
+    }
+    async deleteImageRepository(repositoryName) {
+        await this.ecr.send(new client_ecr_1.DeleteRepositoryCommand({
+            repositoryName: repositoryName,
+            force: true,
+        }));
+    }
+    async deleteBucket(bucketName) {
+        try {
+            await this.emptyBucket(bucketName);
+            await this.s3.send(new client_s3_1.DeleteBucketCommand({
+                Bucket: bucketName,
+            }));
+        }
+        catch (e) {
+            if (isBucketMissingError(e)) {
+                return;
+            }
+            throw e;
+        }
+    }
+}
+exports.AwsClients = AwsClients;
+function isStackMissingError(e) {
+    return e.message.indexOf('does not exist') > -1;
+}
+function isBucketMissingError(e) {
+    return e.message.indexOf('does not exist') > -1;
+}
+/**
+ * Retry an async operation until a deadline is hit.
+ *
+ * Use `retry.forSeconds()` to construct a deadline relative to right now.
+ *
+ * Exceptions will cause the operation to retry. Use `retry.abort` to annotate an exception
+ * to stop the retry and end in a failure.
+ */
+async function retry(output, operation, deadline, block) {
+    let i = 0;
+    output.write(`💈 ${operation}\n`);
+    while (true) {
+        try {
+            i++;
+            const ret = await block();
+            output.write(`💈 ${operation}: succeeded after ${i} attempts\n`);
+            return ret;
+        }
+        catch (e) {
+            if (e.abort || Date.now() > deadline.getTime()) {
+                throw new Error(`${operation}: did not succeed after ${i} attempts: ${e}`);
+            }
+            output.write(`⏳ ${operation} (${e.message})\n`);
+            await sleep(5000);
+        }
+    }
+}
+/**
+ * Make a deadline for the `retry` function relative to the current time.
+ */
+retry.forSeconds = (seconds) => {
+    return new Date(Date.now() + seconds * 1000);
+};
+/**
+ * Annotate an error to stop the retrying
+ */
+retry.abort = (e) => {
+    e.abort = true;
+    return e;
+};
+function outputFromStack(key, stack) {
+    var _a, _b;
+    return (_b = ((_a = stack.Outputs) !== null && _a !== void 0 ? _a : []).find((o) => o.OutputKey === key)) === null || _b === void 0 ? void 0 : _b.OutputValue;
+}
+async function sleep(ms) {
+    return new Promise((ok) => setTimeout(ok, ms));
+}
+function chainableCredentials(region) {
+    if (process.env.CODEBUILD_BUILD_ARN && process.env.AWS_PROFILE) {
+        // in codebuild we must assume the role that the cdk uses
+        // otherwise credentials will just be picked up by the normal sdk
+        // heuristics and expire after an hour.
+        return (0, credential_providers_1.fromIni)({
+            clientConfig: { region },
+        });
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws.js","sourceRoot":"","sources":["aws.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CloudFormationClient,\n  DeleteStackCommand,\n  DescribeStacksCommand,\n  UpdateTerminationProtectionCommand,\n  type Stack,\n} from '@aws-sdk/client-cloudformation';\nimport { DeleteRepositoryCommand, ECRClient } from '@aws-sdk/client-ecr';\nimport { ECSClient } from '@aws-sdk/client-ecs';\nimport { IAMClient } from '@aws-sdk/client-iam';\nimport { LambdaClient } from '@aws-sdk/client-lambda';\nimport {\n  S3Client,\n  DeleteObjectsCommand,\n  ListObjectVersionsCommand,\n  type ObjectIdentifier,\n  DeleteBucketCommand,\n} from '@aws-sdk/client-s3';\nimport { SNSClient } from '@aws-sdk/client-sns';\nimport { SSOClient } from '@aws-sdk/client-sso';\nimport { STSClient, GetCallerIdentityCommand } from '@aws-sdk/client-sts';\nimport { fromIni } from '@aws-sdk/credential-providers';\nimport type { AwsCredentialIdentityProvider } from '@smithy/types';\nimport { ConfiguredRetryStrategy } from '@smithy/util-retry';\ninterface ClientConfig {\n  readonly credentials?: AwsCredentialIdentityProvider;\n  readonly region: string;\n  readonly retryStrategy: ConfiguredRetryStrategy;\n}\n\nexport class AwsClients {\n  public static async default(output: NodeJS.WritableStream) {\n    const region = process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1';\n    return AwsClients.forRegion(region, output);\n  }\n\n  public static async forRegion(region: string, output: NodeJS.WritableStream) {\n    return new AwsClients(region, output);\n  }\n\n  private readonly config: ClientConfig;\n\n  public readonly cloudFormation: CloudFormationClient;\n  public readonly s3: S3Client;\n  public readonly ecr: ECRClient;\n  public readonly ecs: ECSClient;\n  public readonly sso: SSOClient;\n  public readonly sns: SNSClient;\n  public readonly iam: IAMClient;\n  public readonly lambda: LambdaClient;\n  public readonly sts: STSClient;\n\n  constructor(public readonly region: string, private readonly output: NodeJS.WritableStream) {\n    this.config = {\n      credentials: chainableCredentials(this.region),\n      region: this.region,\n      retryStrategy: new ConfiguredRetryStrategy(9, (attempt: number) => attempt ** 500),\n    };\n    this.cloudFormation = new CloudFormationClient(this.config);\n    this.s3 = new S3Client(this.config);\n    this.ecr = new ECRClient(this.config);\n    this.ecs = new ECSClient(this.config);\n    this.sso = new SSOClient(this.config);\n    this.sns = new SNSClient(this.config);\n    this.iam = new IAMClient(this.config);\n    this.lambda = new LambdaClient(this.config);\n    this.sts = new STSClient(this.config);\n  }\n\n  public async account(): Promise<string> {\n    // Reduce # of retries, we use this as a circuit breaker for detecting no-config\n    const stsClient = new STSClient({\n      credentials: this.config.credentials,\n      region: this.config.region,\n      maxAttempts: 2,\n    });\n\n    return (await stsClient.send(new GetCallerIdentityCommand({}))).Account!;\n  }\n\n  public async deleteStacks(...stackNames: string[]) {\n    if (stackNames.length === 0) {\n      return;\n    }\n\n    // We purposely do all stacks serially, because they've been ordered\n    // to do the bootstrap stack last.\n    for (const stackName of stackNames) {\n      await this.cloudFormation.send(\n        new UpdateTerminationProtectionCommand({\n          EnableTerminationProtection: false,\n          StackName: stackName,\n        }),\n      );\n      await this.cloudFormation.send(\n        new DeleteStackCommand({\n          StackName: stackName,\n        }),\n      );\n\n      await retry(this.output, `Deleting ${stackName}`, retry.forSeconds(600), async () => {\n        const status = await this.stackStatus(stackName);\n        if (status !== undefined && status.endsWith('_FAILED')) {\n          throw retry.abort(new Error(`'${stackName}' is in state '${status}'`));\n        }\n        if (status !== undefined) {\n          throw new Error(`Delete of '${stackName}' not complete yet, status: '${status}'`);\n        }\n      });\n    }\n  }\n\n  public async stackStatus(stackName: string): Promise<string | undefined> {\n    try {\n      return (\n        await this.cloudFormation.send(\n          new DescribeStacksCommand({\n            StackName: stackName,\n          }),\n        )\n      ).Stacks?.[0].StackStatus;\n    } catch (e: any) {\n      if (isStackMissingError(e)) {\n        return undefined;\n      }\n      throw e;\n    }\n  }\n\n  public async emptyBucket(bucketName: string, options?: { bypassGovernance?: boolean }) {\n    const objects = await this.s3.send(\n      new ListObjectVersionsCommand({\n        Bucket: bucketName,\n      }),\n    );\n\n    const deletes = [...(objects.Versions || []), ...(objects.DeleteMarkers || [])].reduce((acc, obj) => {\n      if (typeof obj.VersionId !== 'undefined' && typeof obj.Key !== 'undefined') {\n        acc.push({ Key: obj.Key, VersionId: obj.VersionId });\n      } else if (typeof obj.Key !== 'undefined') {\n        acc.push({ Key: obj.Key });\n      }\n      return acc;\n    }, [] as ObjectIdentifier[]);\n\n    if (deletes.length === 0) {\n      return Promise.resolve();\n    }\n\n    return this.s3.send(\n      new DeleteObjectsCommand({\n        Bucket: bucketName,\n        Delete: {\n          Objects: deletes,\n          Quiet: false,\n        },\n        BypassGovernanceRetention: options?.bypassGovernance ? true : undefined,\n      }),\n    );\n  }\n\n  public async deleteImageRepository(repositoryName: string) {\n    await this.ecr.send(\n      new DeleteRepositoryCommand({\n        repositoryName: repositoryName,\n        force: true,\n      }),\n    );\n  }\n\n  public async deleteBucket(bucketName: string) {\n    try {\n      await this.emptyBucket(bucketName);\n\n      await this.s3.send(\n        new DeleteBucketCommand({\n          Bucket: bucketName,\n        }),\n      );\n    } catch (e: any) {\n      if (isBucketMissingError(e)) {\n        return;\n      }\n      throw e;\n    }\n  }\n}\n\nexport function isStackMissingError(e: Error) {\n  return e.message.indexOf('does not exist') > -1;\n}\n\nexport function isBucketMissingError(e: Error) {\n  return e.message.indexOf('does not exist') > -1;\n}\n\n/**\n * Retry an async operation until a deadline is hit.\n *\n * Use `retry.forSeconds()` to construct a deadline relative to right now.\n *\n * Exceptions will cause the operation to retry. Use `retry.abort` to annotate an exception\n * to stop the retry and end in a failure.\n */\nexport async function retry<A>(\n  output: NodeJS.WritableStream,\n  operation: string,\n  deadline: Date,\n  block: () => Promise<A>,\n): Promise<A> {\n  let i = 0;\n  output.write(`💈 ${operation}\\n`);\n  while (true) {\n    try {\n      i++;\n      const ret = await block();\n      output.write(`💈 ${operation}: succeeded after ${i} attempts\\n`);\n      return ret;\n    } catch (e: any) {\n      if (e.abort || Date.now() > deadline.getTime()) {\n        throw new Error(`${operation}: did not succeed after ${i} attempts: ${e}`);\n      }\n      output.write(`⏳ ${operation} (${e.message})\\n`);\n      await sleep(5000);\n    }\n  }\n}\n\n/**\n * Make a deadline for the `retry` function relative to the current time.\n */\nretry.forSeconds = (seconds: number): Date => {\n  return new Date(Date.now() + seconds * 1000);\n};\n\n/**\n * Annotate an error to stop the retrying\n */\nretry.abort = (e: Error): Error => {\n  (e as any).abort = true;\n  return e;\n};\n\nexport function outputFromStack(key: string, stack: Stack): string | undefined {\n  return (stack.Outputs ?? []).find((o) => o.OutputKey === key)?.OutputValue;\n}\n\nexport async function sleep(ms: number) {\n  return new Promise((ok) => setTimeout(ok, ms));\n}\n\nfunction chainableCredentials(region: string): AwsCredentialIdentityProvider | undefined {\n  if (process.env.CODEBUILD_BUILD_ARN && process.env.AWS_PROFILE) {\n    // in codebuild we must assume the role that the cdk uses\n    // otherwise credentials will just be picked up by the normal sdk\n    // heuristics and expire after an hour.\n    return fromIni({\n      clientConfig: { region },\n    });\n  }\n\n  return undefined;\n}\n"]}

package/lib/aws.ts

@@ -0,0 +1,263 @@
+import {
+  CloudFormationClient,
+  DeleteStackCommand,
+  DescribeStacksCommand,
+  UpdateTerminationProtectionCommand,
+  type Stack,
+} from '@aws-sdk/client-cloudformation';
+import { DeleteRepositoryCommand, ECRClient } from '@aws-sdk/client-ecr';
+import { ECSClient } from '@aws-sdk/client-ecs';
+import { IAMClient } from '@aws-sdk/client-iam';
+import { LambdaClient } from '@aws-sdk/client-lambda';
+import {
+  S3Client,
+  DeleteObjectsCommand,
+  ListObjectVersionsCommand,
+  type ObjectIdentifier,
+  DeleteBucketCommand,
+} from '@aws-sdk/client-s3';
+import { SNSClient } from '@aws-sdk/client-sns';
+import { SSOClient } from '@aws-sdk/client-sso';
+import { STSClient, GetCallerIdentityCommand } from '@aws-sdk/client-sts';
+import { fromIni } from '@aws-sdk/credential-providers';
+import type { AwsCredentialIdentityProvider } from '@smithy/types';
+import { ConfiguredRetryStrategy } from '@smithy/util-retry';
+interface ClientConfig {
+  readonly credentials?: AwsCredentialIdentityProvider;
+  readonly region: string;
+  readonly retryStrategy: ConfiguredRetryStrategy;
+}
+
+export class AwsClients {
+  public static async default(output: NodeJS.WritableStream) {
+    const region = process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1';
+    return AwsClients.forRegion(region, output);
+  }
+
+  public static async forRegion(region: string, output: NodeJS.WritableStream) {
+    return new AwsClients(region, output);
+  }
+
+  private readonly config: ClientConfig;
+
+  public readonly cloudFormation: CloudFormationClient;
+  public readonly s3: S3Client;
+  public readonly ecr: ECRClient;
+  public readonly ecs: ECSClient;
+  public readonly sso: SSOClient;
+  public readonly sns: SNSClient;
+  public readonly iam: IAMClient;
+  public readonly lambda: LambdaClient;
+  public readonly sts: STSClient;
+
+  constructor(public readonly region: string, private readonly output: NodeJS.WritableStream) {
+    this.config = {
+      credentials: chainableCredentials(this.region),
+      region: this.region,
+      retryStrategy: new ConfiguredRetryStrategy(9, (attempt: number) => attempt ** 500),
+    };
+    this.cloudFormation = new CloudFormationClient(this.config);
+    this.s3 = new S3Client(this.config);
+    this.ecr = new ECRClient(this.config);
+    this.ecs = new ECSClient(this.config);
+    this.sso = new SSOClient(this.config);
+    this.sns = new SNSClient(this.config);
+    this.iam = new IAMClient(this.config);
+    this.lambda = new LambdaClient(this.config);
+    this.sts = new STSClient(this.config);
+  }
+
+  public async account(): Promise<string> {
+    // Reduce # of retries, we use this as a circuit breaker for detecting no-config
+    const stsClient = new STSClient({
+      credentials: this.config.credentials,
+      region: this.config.region,
+      maxAttempts: 2,
+    });
+
+    return (await stsClient.send(new GetCallerIdentityCommand({}))).Account!;
+  }
+
+  public async deleteStacks(...stackNames: string[]) {
+    if (stackNames.length === 0) {
+      return;
+    }
+
+    // We purposely do all stacks serially, because they've been ordered
+    // to do the bootstrap stack last.
+    for (const stackName of stackNames) {
+      await this.cloudFormation.send(
+        new UpdateTerminationProtectionCommand({
+          EnableTerminationProtection: false,
+          StackName: stackName,
+        }),
+      );
+      await this.cloudFormation.send(
+        new DeleteStackCommand({
+          StackName: stackName,
+        }),
+      );
+
+      await retry(this.output, `Deleting ${stackName}`, retry.forSeconds(600), async () => {
+        const status = await this.stackStatus(stackName);
+        if (status !== undefined && status.endsWith('_FAILED')) {
+          throw retry.abort(new Error(`'${stackName}' is in state '${status}'`));
+        }
+        if (status !== undefined) {
+          throw new Error(`Delete of '${stackName}' not complete yet, status: '${status}'`);
+        }
+      });
+    }
+  }
+
+  public async stackStatus(stackName: string): Promise<string | undefined> {
+    try {
+      return (
+        await this.cloudFormation.send(
+          new DescribeStacksCommand({
+            StackName: stackName,
+          }),
+        )
+      ).Stacks?.[0].StackStatus;
+    } catch (e: any) {
+      if (isStackMissingError(e)) {
+        return undefined;
+      }
+      throw e;
+    }
+  }
+
+  public async emptyBucket(bucketName: string, options?: { bypassGovernance?: boolean }) {
+    const objects = await this.s3.send(
+      new ListObjectVersionsCommand({
+        Bucket: bucketName,
+      }),
+    );
+
+    const deletes = [...(objects.Versions || []), ...(objects.DeleteMarkers || [])].reduce((acc, obj) => {
+      if (typeof obj.VersionId !== 'undefined' && typeof obj.Key !== 'undefined') {
+        acc.push({ Key: obj.Key, VersionId: obj.VersionId });
+      } else if (typeof obj.Key !== 'undefined') {
+        acc.push({ Key: obj.Key });
+      }
+      return acc;
+    }, [] as ObjectIdentifier[]);
+
+    if (deletes.length === 0) {
+      return Promise.resolve();
+    }
+
+    return this.s3.send(
+      new DeleteObjectsCommand({
+        Bucket: bucketName,
+        Delete: {
+          Objects: deletes,
+          Quiet: false,
+        },
+        BypassGovernanceRetention: options?.bypassGovernance ? true : undefined,
+      }),
+    );
+  }
+
+  public async deleteImageRepository(repositoryName: string) {
+    await this.ecr.send(
+      new DeleteRepositoryCommand({
+        repositoryName: repositoryName,
+        force: true,
+      }),
+    );
+  }
+
+  public async deleteBucket(bucketName: string) {
+    try {
+      await this.emptyBucket(bucketName);
+
+      await this.s3.send(
+        new DeleteBucketCommand({
+          Bucket: bucketName,
+        }),
+      );
+    } catch (e: any) {
+      if (isBucketMissingError(e)) {
+        return;
+      }
+      throw e;
+    }
+  }
+}
+
+export function isStackMissingError(e: Error) {
+  return e.message.indexOf('does not exist') > -1;
+}
+
+export function isBucketMissingError(e: Error) {
+  return e.message.indexOf('does not exist') > -1;
+}
+
+/**
+ * Retry an async operation until a deadline is hit.
+ *
+ * Use `retry.forSeconds()` to construct a deadline relative to right now.
+ *
+ * Exceptions will cause the operation to retry. Use `retry.abort` to annotate an exception
+ * to stop the retry and end in a failure.
+ */
+export async function retry<A>(
+  output: NodeJS.WritableStream,
+  operation: string,
+  deadline: Date,
+  block: () => Promise<A>,
+): Promise<A> {
+  let i = 0;
+  output.write(`💈 ${operation}\n`);
+  while (true) {
+    try {
+      i++;
+      const ret = await block();
+      output.write(`💈 ${operation}: succeeded after ${i} attempts\n`);
+      return ret;
+    } catch (e: any) {
+      if (e.abort || Date.now() > deadline.getTime()) {
+        throw new Error(`${operation}: did not succeed after ${i} attempts: ${e}`);
+      }
+      output.write(`⏳ ${operation} (${e.message})\n`);
+      await sleep(5000);
+    }
+  }
+}
+
+/**
+ * Make a deadline for the `retry` function relative to the current time.
+ */
+retry.forSeconds = (seconds: number): Date => {
+  return new Date(Date.now() + seconds * 1000);
+};
+
+/**
+ * Annotate an error to stop the retrying
+ */
+retry.abort = (e: Error): Error => {
+  (e as any).abort = true;
+  return e;
+};
+
+export function outputFromStack(key: string, stack: Stack): string | undefined {
+  return (stack.Outputs ?? []).find((o) => o.OutputKey === key)?.OutputValue;
+}
+
+export async function sleep(ms: number) {
+  return new Promise((ok) => setTimeout(ok, ms));
+}
+
+function chainableCredentials(region: string): AwsCredentialIdentityProvider | undefined {
+  if (process.env.CODEBUILD_BUILD_ARN && process.env.AWS_PROFILE) {
+    // in codebuild we must assume the role that the cdk uses
+    // otherwise credentials will just be picked up by the normal sdk
+    // heuristics and expire after an hour.
+    return fromIni({
+      clientConfig: { region },
+    });
+  }
+
+  return undefined;
+}

package/lib/corking.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Routines for corking stdout and stderr
+ */
+import * as stream from 'stream';
+export declare class MemoryStream extends stream.Writable {
+    private parts;
+    _write(chunk: Buffer, _encoding: string, callback: (error?: Error | null) => void): void;
+    buffer(): Buffer;
+    clear(): void;
+    flushTo(strm: NodeJS.WritableStream): Promise<void>;
+    toString(): string;
+}

package/lib/corking.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStream = void 0;
+/**
+ * Routines for corking stdout and stderr
+ */
+const stream = require("stream");
+class MemoryStream extends stream.Writable {
+    constructor() {
+        super(...arguments);
+        this.parts = new Array();
+    }
+    _write(chunk, _encoding, callback) {
+        this.parts.push(chunk);
+        callback();
+    }
+    buffer() {
+        return Buffer.concat(this.parts);
+    }
+    clear() {
+        this.parts.splice(0, this.parts.length);
+    }
+    async flushTo(strm) {
+        const flushed = strm.write(this.buffer());
+        if (!flushed) {
+            return new Promise(ok => strm.once('drain', ok));
+        }
+        return;
+    }
+    toString() {
+        return this.buffer().toString();
+    }
+}
+exports.MemoryStream = MemoryStream;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/corking.ts

@@ -0,0 +1,33 @@
+/**
+ * Routines for corking stdout and stderr
+ */
+import * as stream from 'stream';
+
+export class MemoryStream extends stream.Writable {
+  private parts = new Array<Buffer>();
+
+  public _write(chunk: Buffer, _encoding: string, callback: (error?: Error | null) => void): void {
+    this.parts.push(chunk);
+    callback();
+  }
+
+  public buffer() {
+    return Buffer.concat(this.parts);
+  }
+
+  public clear() {
+    this.parts.splice(0, this.parts.length);
+  }
+
+  public async flushTo(strm: NodeJS.WritableStream): Promise<void> {
+    const flushed = strm.write(this.buffer());
+    if (!flushed) {
+      return new Promise(ok => strm.once('drain', ok));
+    }
+    return;
+  }
+
+  public toString() {
+    return this.buffer().toString();
+  }
+}

package/lib/eventually.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @param maxAttempts the maximum number of attempts
+ * @param interval interval in milliseconds to observe between attempts
+ */
+export type EventuallyOptions = {
+    maxAttempts?: number;
+    interval?: number;
+};
+/**
+ * Runs a function on an interval until the maximum number of attempts has
+ * been reached.
+ *
+ * Default interval = 1000 milliseconds
+ * Default maxAttempts = 10
+ *
+ * @param fn function to run
+ * @param options EventuallyOptions
+ */
+declare const eventually: <T>(call: () => Promise<T>, options?: EventuallyOptions) => Promise<T>;
+export default eventually;

package/lib/eventually.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const DEFAULT_INTERVAL = 1000;
+const DEFAULT_MAX_ATTEMPTS = 10;
+/**
+ * Runs a function on an interval until the maximum number of attempts has
+ * been reached.
+ *
+ * Default interval = 1000 milliseconds
+ * Default maxAttempts = 10
+ *
+ * @param fn function to run
+ * @param options EventuallyOptions
+ */
+const eventually = async (call, options) => {
+    const opts = {
+        interval: (options === null || options === void 0 ? void 0 : options.interval) ? options.interval : DEFAULT_INTERVAL,
+        maxAttempts: (options === null || options === void 0 ? void 0 : options.maxAttempts) ? options.maxAttempts : DEFAULT_MAX_ATTEMPTS,
+    };
+    while (opts.maxAttempts-- >= 0) {
+        try {
+            return await call();
+        }
+        catch (err) {
+            if (opts.maxAttempts <= 0)
+                throw err;
+        }
+        await wait(opts.interval);
+    }
+    throw new Error('An unexpected error has occurred.');
+};
+exports.default = eventually;
+//# sourceMappingURL=data:application/json;base64,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