@aws-cdk/toolkit-lib 0.3.2 → 0.3.4

package/lib/api/garbage-collection/garbage-collector.js

@@ -0,0 +1,614 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GarbageCollector = exports.ObjectAsset = exports.ImageAsset = exports.ECR_ISOLATED_TAG = exports.S3_ISOLATED_TAG = void 0;
+const chalk = require("chalk");
+const promptly = require("promptly");
+const toolkit_info_1 = require("../toolkit-info");
+const progress_printer_1 = require("./progress-printer");
+const stack_refresh_1 = require("./stack-refresh");
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+const private_1 = require("../io/private");
+const plugin_1 = require("../plugin");
+// Must use a require() otherwise esbuild complains
+// eslint-disable-next-line @typescript-eslint/no-require-imports,@typescript-eslint/consistent-type-imports
+const pLimit = require('p-limit');
+exports.S3_ISOLATED_TAG = 'aws-cdk:isolated';
+exports.ECR_ISOLATED_TAG = 'aws-cdk.isolated'; // ':' is not valid in ECR tags
+const P_LIMIT = 50;
+const DAY = 24 * 60 * 60 * 1000; // Number of milliseconds in a day
+/**
+ * An image asset that lives in the bootstrapped ECR Repository
+ */
+class ImageAsset {
+    digest;
+    size;
+    tags;
+    manifest;
+    constructor(digest, size, tags, manifest) {
+        this.digest = digest;
+        this.size = size;
+        this.tags = tags;
+        this.manifest = manifest;
+    }
+    getTag(tag) {
+        return this.tags.find(t => t.includes(tag));
+    }
+    hasTag(tag) {
+        return this.tags.some(t => t.includes(tag));
+    }
+    hasIsolatedTag() {
+        return this.hasTag(exports.ECR_ISOLATED_TAG);
+    }
+    getIsolatedTag() {
+        return this.getTag(exports.ECR_ISOLATED_TAG);
+    }
+    isolatedTagBefore(date) {
+        const dateIsolated = this.dateIsolated();
+        if (!dateIsolated || dateIsolated == '') {
+            return false;
+        }
+        return new Date(dateIsolated) < date;
+    }
+    buildImageTag(inc) {
+        // isolatedTag will look like "X-aws-cdk.isolated-YYYYY"
+        return `${inc}-${exports.ECR_ISOLATED_TAG}-${String(Date.now())}`;
+    }
+    dateIsolated() {
+        // isolatedTag will look like "X-aws-cdk.isolated-YYYYY"
+        return this.getIsolatedTag()?.split('-')[3];
+    }
+}
+exports.ImageAsset = ImageAsset;
+/**
+ * An object asset that lives in the bootstrapped S3 Bucket
+ */
+class ObjectAsset {
+    bucket;
+    key;
+    size;
+    cached_tags = undefined;
+    constructor(bucket, key, size) {
+        this.bucket = bucket;
+        this.key = key;
+        this.size = size;
+    }
+    fileName() {
+        return this.key.split('.')[0];
+    }
+    async allTags(s3) {
+        if (this.cached_tags) {
+            return this.cached_tags;
+        }
+        const response = await s3.getObjectTagging({ Bucket: this.bucket, Key: this.key });
+        this.cached_tags = response.TagSet;
+        return this.cached_tags;
+    }
+    getTag(tag) {
+        if (!this.cached_tags) {
+            throw new toolkit_error_1.ToolkitError('Cannot call getTag before allTags');
+        }
+        return this.cached_tags.find((t) => t.Key === tag)?.Value;
+    }
+    hasTag(tag) {
+        if (!this.cached_tags) {
+            throw new toolkit_error_1.ToolkitError('Cannot call hasTag before allTags');
+        }
+        return this.cached_tags.some((t) => t.Key === tag);
+    }
+    hasIsolatedTag() {
+        return this.hasTag(exports.S3_ISOLATED_TAG);
+    }
+    isolatedTagBefore(date) {
+        const tagValue = this.getTag(exports.S3_ISOLATED_TAG);
+        if (!tagValue || tagValue == '') {
+            return false;
+        }
+        return new Date(tagValue) < date;
+    }
+}
+exports.ObjectAsset = ObjectAsset;
+/**
+ * A class to facilitate Garbage Collection of S3 and ECR assets
+ */
+class GarbageCollector {
+    props;
+    garbageCollectS3Assets;
+    garbageCollectEcrAssets;
+    permissionToDelete;
+    permissionToTag;
+    bootstrapStackName;
+    confirm;
+    ioHelper;
+    constructor(props) {
+        this.props = props;
+        this.ioHelper = props.ioHelper;
+        this.garbageCollectS3Assets = ['s3', 'all'].includes(props.type);
+        this.garbageCollectEcrAssets = ['ecr', 'all'].includes(props.type);
+        this.permissionToDelete = ['delete-tagged', 'full'].includes(props.action);
+        this.permissionToTag = ['tag', 'full'].includes(props.action);
+        this.confirm = props.confirm ?? true;
+        this.bootstrapStackName = props.bootstrapStackName ?? toolkit_info_1.DEFAULT_TOOLKIT_STACK_NAME;
+    }
+    /**
+     * Perform garbage collection on the resolved environment.
+     */
+    async garbageCollect() {
+        await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${this.garbageCollectS3Assets} ${this.garbageCollectEcrAssets}`));
+        // SDKs
+        const sdk = (await this.props.sdkProvider.forEnvironment(this.props.resolvedEnvironment, plugin_1.Mode.ForWriting)).sdk;
+        const cfn = sdk.cloudFormation();
+        const qualifier = await this.bootstrapQualifier(sdk, this.bootstrapStackName);
+        const activeAssets = new stack_refresh_1.ActiveAssetCache();
+        // Grab stack templates first
+        await (0, stack_refresh_1.refreshStacks)(cfn, this.ioHelper, activeAssets, qualifier);
+        // Start the background refresh
+        const backgroundStackRefresh = new stack_refresh_1.BackgroundStackRefresh({
+            cfn,
+            ioHelper: this.ioHelper,
+            activeAssets,
+            qualifier,
+        });
+        backgroundStackRefresh.start();
+        try {
+            if (this.garbageCollectS3Assets) {
+                await this.garbageCollectS3(sdk, activeAssets, backgroundStackRefresh);
+            }
+            if (this.garbageCollectEcrAssets) {
+                await this.garbageCollectEcr(sdk, activeAssets, backgroundStackRefresh);
+            }
+        }
+        catch (err) {
+            throw new toolkit_error_1.ToolkitError(err);
+        }
+        finally {
+            backgroundStackRefresh.stop();
+        }
+    }
+    /**
+     * Perform garbage collection on ECR assets
+     */
+    async garbageCollectEcr(sdk, activeAssets, backgroundStackRefresh) {
+        const ecr = sdk.ecr();
+        const repo = await this.bootstrapRepositoryName(sdk, this.bootstrapStackName);
+        const numImages = await this.numImagesInRepo(ecr, repo);
+        const printer = new progress_printer_1.ProgressPrinter(this.ioHelper, numImages, 1000);
+        await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Found bootstrap repo ${repo} with ${numImages} images`));
+        try {
+            // const batches = 1;
+            const batchSize = 1000;
+            const currentTime = Date.now();
+            const graceDays = this.props.rollbackBufferDays;
+            await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Parsing through ${numImages} images in batches`));
+            printer.start();
+            for await (const batch of this.readRepoInBatches(ecr, repo, batchSize, currentTime)) {
+                await backgroundStackRefresh.noOlderThan(600_000); // 10 mins
+                const { included: isolated, excluded: notIsolated } = partition(batch, asset => !asset.tags.some(t => activeAssets.contains(t)));
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${isolated.length} isolated images`));
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${notIsolated.length} not isolated images`));
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${batch.length} images total`));
+                let deletables = isolated;
+                let taggables = [];
+                let untaggables = [];
+                if (graceDays > 0) {
+                    await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg('Filtering out images that are not old enough to delete'));
+                    // We delete images that are not referenced in ActiveAssets and have the Isolated Tag with a date
+                    // earlier than the current time - grace period.
+                    deletables = isolated.filter(img => img.isolatedTagBefore(new Date(currentTime - (graceDays * DAY))));
+                    // We tag images that are not referenced in ActiveAssets and do not have the Isolated Tag.
+                    taggables = isolated.filter(img => !img.hasIsolatedTag());
+                    // We untag images that are referenced in ActiveAssets and currently have the Isolated Tag.
+                    untaggables = notIsolated.filter(img => img.hasIsolatedTag());
+                }
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${deletables.length} deletable assets`));
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${taggables.length} taggable assets`));
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${untaggables.length} assets to untag`));
+                if (this.permissionToDelete && deletables.length > 0) {
+                    await this.confirmationPrompt(printer, deletables, 'image');
+                    await this.parallelDeleteEcr(ecr, repo, deletables, printer);
+                }
+                if (this.permissionToTag && taggables.length > 0) {
+                    await this.parallelTagEcr(ecr, repo, taggables, printer);
+                }
+                if (this.permissionToTag && untaggables.length > 0) {
+                    await this.parallelUntagEcr(ecr, repo, untaggables);
+                }
+                printer.reportScannedAsset(batch.length);
+            }
+        }
+        catch (err) {
+            throw new toolkit_error_1.ToolkitError(err);
+        }
+        finally {
+            printer.stop();
+        }
+    }
+    /**
+     * Perform garbage collection on S3 assets
+     */
+    async garbageCollectS3(sdk, activeAssets, backgroundStackRefresh) {
+        const s3 = sdk.s3();
+        const bucket = await this.bootstrapBucketName(sdk, this.bootstrapStackName);
+        const numObjects = await this.numObjectsInBucket(s3, bucket);
+        const printer = new progress_printer_1.ProgressPrinter(this.ioHelper, numObjects, 1000);
+        await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Found bootstrap bucket ${bucket} with ${numObjects} objects`));
+        try {
+            const batchSize = 1000;
+            const currentTime = Date.now();
+            const graceDays = this.props.rollbackBufferDays;
+            await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Parsing through ${numObjects} objects in batches`));
+            printer.start();
+            // Process objects in batches of 1000
+            // This is the batch limit of s3.DeleteObject and we intend to optimize for the "worst case" scenario
+            // where gc is run for the first time on a long-standing bucket where ~100% of objects are isolated.
+            for await (const batch of this.readBucketInBatches(s3, bucket, batchSize, currentTime)) {
+                await backgroundStackRefresh.noOlderThan(600_000); // 10 mins
+                const { included: isolated, excluded: notIsolated } = partition(batch, asset => !activeAssets.contains(asset.fileName()));
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${isolated.length} isolated assets`));
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${notIsolated.length} not isolated assets`));
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${batch.length} objects total`));
+                let deletables = isolated;
+                let taggables = [];
+                let untaggables = [];
+                if (graceDays > 0) {
+                    await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg('Filtering out assets that are not old enough to delete'));
+                    await this.parallelReadAllTags(s3, batch);
+                    // We delete objects that are not referenced in ActiveAssets and have the Isolated Tag with a date
+                    // earlier than the current time - grace period.
+                    deletables = isolated.filter(obj => obj.isolatedTagBefore(new Date(currentTime - (graceDays * DAY))));
+                    // We tag objects that are not referenced in ActiveAssets and do not have the Isolated Tag.
+                    taggables = isolated.filter(obj => !obj.hasIsolatedTag());
+                    // We untag objects that are referenced in ActiveAssets and currently have the Isolated Tag.
+                    untaggables = notIsolated.filter(obj => obj.hasIsolatedTag());
+                }
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${deletables.length} deletable assets`));
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${taggables.length} taggable assets`));
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`${untaggables.length} assets to untag`));
+                if (this.permissionToDelete && deletables.length > 0) {
+                    await this.confirmationPrompt(printer, deletables, 'object');
+                    await this.parallelDeleteS3(s3, bucket, deletables, printer);
+                }
+                if (this.permissionToTag && taggables.length > 0) {
+                    await this.parallelTagS3(s3, bucket, taggables, currentTime, printer);
+                }
+                if (this.permissionToTag && untaggables.length > 0) {
+                    await this.parallelUntagS3(s3, bucket, untaggables);
+                }
+                printer.reportScannedAsset(batch.length);
+            }
+        }
+        catch (err) {
+            throw new toolkit_error_1.ToolkitError(err);
+        }
+        finally {
+            printer.stop();
+        }
+    }
+    async parallelReadAllTags(s3, objects) {
+        const limit = pLimit(P_LIMIT);
+        for (const obj of objects) {
+            await limit(() => obj.allTags(s3));
+        }
+    }
+    /**
+     * Untag assets that were previously tagged, but now currently referenced.
+     * Since this is treated as an implementation detail, we do not print the results in the printer.
+     */
+    async parallelUntagEcr(ecr, repo, untaggables) {
+        const limit = pLimit(P_LIMIT);
+        for (const img of untaggables) {
+            const tag = img.getIsolatedTag();
+            await limit(() => ecr.batchDeleteImage({
+                repositoryName: repo,
+                imageIds: [{
+                        imageTag: tag,
+                    }],
+            }));
+        }
+        await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Untagged ${untaggables.length} assets`));
+    }
+    /**
+     * Untag assets that were previously tagged, but now currently referenced.
+     * Since this is treated as an implementation detail, we do not print the results in the printer.
+     */
+    async parallelUntagS3(s3, bucket, untaggables) {
+        const limit = pLimit(P_LIMIT);
+        for (const obj of untaggables) {
+            const tags = await obj.allTags(s3) ?? [];
+            const updatedTags = tags.filter((tag) => tag.Key !== exports.S3_ISOLATED_TAG);
+            await limit(() => s3.deleteObjectTagging({
+                Bucket: bucket,
+                Key: obj.key,
+            }));
+            await limit(() => s3.putObjectTagging({
+                Bucket: bucket,
+                Key: obj.key,
+                Tagging: {
+                    TagSet: updatedTags,
+                },
+            }));
+        }
+        await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Untagged ${untaggables.length} assets`));
+    }
+    /**
+     * Tag images in parallel using p-limit
+     */
+    async parallelTagEcr(ecr, repo, taggables, printer) {
+        const limit = pLimit(P_LIMIT);
+        for (let i = 0; i < taggables.length; i++) {
+            const img = taggables[i];
+            const tagEcr = async () => {
+                try {
+                    await ecr.putImage({
+                        repositoryName: repo,
+                        imageDigest: img.digest,
+                        imageManifest: img.manifest,
+                        imageTag: img.buildImageTag(i),
+                    });
+                }
+                catch (error) {
+                    // This is a false negative -- an isolated asset is untagged
+                    // likely due to an imageTag collision. We can safely ignore,
+                    // and the isolated asset will be tagged next time.
+                    await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Warning: unable to tag image ${JSON.stringify(img.tags)} with ${img.buildImageTag(i)} due to the following error: ${error}`));
+                }
+            };
+            await limit(() => tagEcr());
+        }
+        printer.reportTaggedAsset(taggables);
+        await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Tagged ${taggables.length} assets`));
+    }
+    /**
+     * Tag objects in parallel using p-limit. The putObjectTagging API does not
+     * support batch tagging so we must handle the parallelism client-side.
+     */
+    async parallelTagS3(s3, bucket, taggables, date, printer) {
+        const limit = pLimit(P_LIMIT);
+        for (const obj of taggables) {
+            await limit(() => s3.putObjectTagging({
+                Bucket: bucket,
+                Key: obj.key,
+                Tagging: {
+                    TagSet: [
+                        {
+                            Key: exports.S3_ISOLATED_TAG,
+                            Value: String(date),
+                        },
+                    ],
+                },
+            }));
+        }
+        printer.reportTaggedAsset(taggables);
+        await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Tagged ${taggables.length} assets`));
+    }
+    /**
+     * Delete images in parallel. The deleteImage API supports batches of 100.
+     */
+    async parallelDeleteEcr(ecr, repo, deletables, printer) {
+        const batchSize = 100;
+        const imagesToDelete = deletables.map(img => ({
+            imageDigest: img.digest,
+        }));
+        try {
+            const batches = [];
+            for (let i = 0; i < imagesToDelete.length; i += batchSize) {
+                batches.push(imagesToDelete.slice(i, i + batchSize));
+            }
+            // Delete images in batches
+            for (const batch of batches) {
+                await ecr.batchDeleteImage({
+                    imageIds: batch,
+                    repositoryName: repo,
+                });
+                const deletedCount = batch.length;
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Deleted ${deletedCount} assets`));
+                printer.reportDeletedAsset(deletables.slice(0, deletedCount));
+            }
+        }
+        catch (err) {
+            await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_ERROR.msg(`Error deleting images: ${err}`));
+        }
+    }
+    /**
+     * Delete objects in parallel. The deleteObjects API supports batches of 1000.
+     */
+    async parallelDeleteS3(s3, bucket, deletables, printer) {
+        const batchSize = 1000;
+        const objectsToDelete = deletables.map(asset => ({
+            Key: asset.key,
+        }));
+        try {
+            const batches = [];
+            for (let i = 0; i < objectsToDelete.length; i += batchSize) {
+                batches.push(objectsToDelete.slice(i, i + batchSize));
+            }
+            // Delete objects in batches
+            for (const batch of batches) {
+                await s3.deleteObjects({
+                    Bucket: bucket,
+                    Delete: {
+                        Objects: batch,
+                        Quiet: true,
+                    },
+                });
+                const deletedCount = batch.length;
+                await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Deleted ${deletedCount} assets`));
+                printer.reportDeletedAsset(deletables.slice(0, deletedCount));
+            }
+        }
+        catch (err) {
+            await this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(chalk.red(`Error deleting objects: ${err}`)));
+        }
+    }
+    async bootstrapBucketName(sdk, bootstrapStackName) {
+        const toolkitInfo = await toolkit_info_1.ToolkitInfo.lookup(this.props.resolvedEnvironment, sdk, this.ioHelper, bootstrapStackName);
+        return toolkitInfo.bucketName;
+    }
+    async bootstrapRepositoryName(sdk, bootstrapStackName) {
+        const toolkitInfo = await toolkit_info_1.ToolkitInfo.lookup(this.props.resolvedEnvironment, sdk, this.ioHelper, bootstrapStackName);
+        return toolkitInfo.repositoryName;
+    }
+    async bootstrapQualifier(sdk, bootstrapStackName) {
+        const toolkitInfo = await toolkit_info_1.ToolkitInfo.lookup(this.props.resolvedEnvironment, sdk, this.ioHelper, bootstrapStackName);
+        return toolkitInfo.bootstrapStack.parameters.Qualifier;
+    }
+    async numObjectsInBucket(s3, bucket) {
+        let totalCount = 0;
+        let continuationToken;
+        do {
+            const response = await s3.listObjectsV2({
+                Bucket: bucket,
+                ContinuationToken: continuationToken,
+            });
+            totalCount += response.KeyCount ?? 0;
+            continuationToken = response.NextContinuationToken;
+        } while (continuationToken);
+        return totalCount;
+    }
+    async numImagesInRepo(ecr, repo) {
+        let totalCount = 0;
+        let nextToken;
+        do {
+            const response = await ecr.listImages({
+                repositoryName: repo,
+                nextToken: nextToken,
+            });
+            totalCount += response.imageIds?.length ?? 0;
+            nextToken = response.nextToken;
+        } while (nextToken);
+        return totalCount;
+    }
+    async *readRepoInBatches(ecr, repo, batchSize = 1000, currentTime) {
+        let continuationToken;
+        do {
+            const batch = [];
+            while (batch.length < batchSize) {
+                const response = await ecr.listImages({
+                    repositoryName: repo,
+                    nextToken: continuationToken,
+                });
+                // No images in the repository
+                if (!response.imageIds || response.imageIds.length === 0) {
+                    break;
+                }
+                // map unique image digest to (possibly multiple) tags
+                const images = imageMap(response.imageIds ?? []);
+                const imageIds = Object.keys(images).map(key => ({
+                    imageDigest: key,
+                }));
+                const describeImageInfo = await ecr.describeImages({
+                    repositoryName: repo,
+                    imageIds: imageIds,
+                });
+                const getImageInfo = await ecr.batchGetImage({
+                    repositoryName: repo,
+                    imageIds: imageIds,
+                });
+                const combinedImageInfo = describeImageInfo.imageDetails?.map(imageDetail => {
+                    const matchingImage = getImageInfo.images?.find(img => img.imageId?.imageDigest === imageDetail.imageDigest);
+                    return {
+                        ...imageDetail,
+                        manifest: matchingImage?.imageManifest,
+                    };
+                });
+                for (const image of combinedImageInfo ?? []) {
+                    const lastModified = image.imagePushedAt ?? new Date(currentTime);
+                    // Store the image if it was pushed earlier than today - createdBufferDays
+                    if (image.imageDigest && lastModified < new Date(currentTime - (this.props.createdBufferDays * DAY))) {
+                        batch.push(new ImageAsset(image.imageDigest, image.imageSizeInBytes ?? 0, image.imageTags ?? [], image.manifest ?? ''));
+                    }
+                }
+                continuationToken = response.nextToken;
+                if (!continuationToken)
+                    break; // No more images to fetch
+            }
+            if (batch.length > 0) {
+                yield batch;
+            }
+        } while (continuationToken);
+    }
+    /**
+     * Generator function that reads objects from the S3 Bucket in batches.
+     */
+    async *readBucketInBatches(s3, bucket, batchSize = 1000, currentTime) {
+        let continuationToken;
+        do {
+            const batch = [];
+            while (batch.length < batchSize) {
+                const response = await s3.listObjectsV2({
+                    Bucket: bucket,
+                    ContinuationToken: continuationToken,
+                });
+                response.Contents?.forEach((obj) => {
+                    const key = obj.Key ?? '';
+                    const size = obj.Size ?? 0;
+                    const lastModified = obj.LastModified ?? new Date(currentTime);
+                    // Store the object if it has a Key and
+                    // if it has not been modified since today - createdBufferDays
+                    if (key && lastModified < new Date(currentTime - (this.props.createdBufferDays * DAY))) {
+                        batch.push(new ObjectAsset(bucket, key, size));
+                    }
+                });
+                continuationToken = response.NextContinuationToken;
+                if (!continuationToken)
+                    break; // No more objects to fetch
+            }
+            if (batch.length > 0) {
+                yield batch;
+            }
+        } while (continuationToken);
+    }
+    async confirmationPrompt(printer, deletables, type) {
+        const pluralize = (name, count) => {
+            return count === 1 ? name : `${name}s`;
+        };
+        if (this.confirm) {
+            const message = [
+                `Found ${deletables.length} ${pluralize(type, deletables.length)} to delete based off of the following criteria:`,
+                `- ${type}s have been isolated for > ${this.props.rollbackBufferDays} days`,
+                `- ${type}s were created > ${this.props.createdBufferDays} days ago`,
+                '',
+                'Delete this batch (yes/no/delete-all)?',
+            ].join('\n');
+            printer.pause();
+            const response = await promptly.prompt(message, { trim: true });
+            // Anything other than yes/y/delete-all is treated as no
+            if (!response || !['yes', 'y', 'delete-all'].includes(response.toLowerCase())) {
+                throw new toolkit_error_1.ToolkitError('Deletion aborted by user');
+            }
+            else if (response.toLowerCase() == 'delete-all') {
+                this.confirm = false;
+            }
+        }
+        printer.resume();
+    }
+}
+exports.GarbageCollector = GarbageCollector;
+function partition(xs, pred) {
+    const result = {
+        included: [],
+        excluded: [],
+    };
+    for (const x of xs) {
+        if (pred(x)) {
+            result.included.push(x);
+        }
+        else {
+            result.excluded.push(x);
+        }
+    }
+    return result;
+}
+function imageMap(imageIds) {
+    const images = {};
+    for (const image of imageIds ?? []) {
+        if (!image.imageDigest || !image.imageTag) {
+            continue;
+        }
+        if (!images[image.imageDigest]) {
+            images[image.imageDigest] = [];
+        }
+        images[image.imageDigest].push(image.imageTag);
+    }
+    return images;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"garbage-collector.js","sourceRoot":"","sources":["garbage-collector.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as cxapi from '@aws-cdk/cx-api';\nimport type { ImageIdentifier } from '@aws-sdk/client-ecr';\nimport type { Tag } from '@aws-sdk/client-s3';\nimport * as chalk from 'chalk';\nimport * as promptly from 'promptly';\nimport type { IECRClient, IS3Client, SDK, SdkProvider } from '../aws-auth/private';\nimport { DEFAULT_TOOLKIT_STACK_NAME, ToolkitInfo } from '../toolkit-info';\nimport { ProgressPrinter } from './progress-printer';\nimport { ActiveAssetCache, BackgroundStackRefresh, refreshStacks } from './stack-refresh';\nimport { ToolkitError } from '../../toolkit/toolkit-error';\nimport { IO, type IoHelper } from '../io/private';\nimport { Mode } from '../plugin';\n\n// Must use a require() otherwise esbuild complains\n// eslint-disable-next-line @typescript-eslint/no-require-imports,@typescript-eslint/consistent-type-imports\nconst pLimit: typeof import('p-limit') = require('p-limit');\n\nexport const S3_ISOLATED_TAG = 'aws-cdk:isolated';\nexport const ECR_ISOLATED_TAG = 'aws-cdk.isolated'; // ':' is not valid in ECR tags\nconst P_LIMIT = 50;\nconst DAY = 24 * 60 * 60 * 1000; // Number of milliseconds in a day\n\nexport type GcAsset = ImageAsset | ObjectAsset;\n\n/**\n * An image asset that lives in the bootstrapped ECR Repository\n */\nexport class ImageAsset {\n  public constructor(\n    public readonly digest: string,\n    public readonly size: number,\n    public readonly tags: string[],\n    public readonly manifest: string,\n  ) {\n  }\n\n  private getTag(tag: string) {\n    return this.tags.find(t => t.includes(tag));\n  }\n\n  private hasTag(tag: string) {\n    return this.tags.some(t => t.includes(tag));\n  }\n\n  public hasIsolatedTag() {\n    return this.hasTag(ECR_ISOLATED_TAG);\n  }\n\n  public getIsolatedTag() {\n    return this.getTag(ECR_ISOLATED_TAG);\n  }\n\n  public isolatedTagBefore(date: Date) {\n    const dateIsolated = this.dateIsolated();\n    if (!dateIsolated || dateIsolated == '') {\n      return false;\n    }\n    return new Date(dateIsolated) < date;\n  }\n\n  public buildImageTag(inc: number) {\n    // isolatedTag will look like \"X-aws-cdk.isolated-YYYYY\"\n    return `${inc}-${ECR_ISOLATED_TAG}-${String(Date.now())}`;\n  }\n\n  public dateIsolated() {\n    // isolatedTag will look like \"X-aws-cdk.isolated-YYYYY\"\n    return this.getIsolatedTag()?.split('-')[3];\n  }\n}\n\n/**\n * An object asset that lives in the bootstrapped S3 Bucket\n */\nexport class ObjectAsset {\n  private cached_tags: Tag[] | undefined = undefined;\n\n  public constructor(private readonly bucket: string, public readonly key: string, public readonly size: number) {\n  }\n\n  public fileName(): string {\n    return this.key.split('.')[0];\n  }\n\n  public async allTags(s3: IS3Client) {\n    if (this.cached_tags) {\n      return this.cached_tags;\n    }\n\n    const response = await s3.getObjectTagging({ Bucket: this.bucket, Key: this.key });\n    this.cached_tags = response.TagSet;\n    return this.cached_tags;\n  }\n\n  private getTag(tag: string) {\n    if (!this.cached_tags) {\n      throw new ToolkitError('Cannot call getTag before allTags');\n    }\n    return this.cached_tags.find((t: any) => t.Key === tag)?.Value;\n  }\n\n  private hasTag(tag: string) {\n    if (!this.cached_tags) {\n      throw new ToolkitError('Cannot call hasTag before allTags');\n    }\n    return this.cached_tags.some((t: any) => t.Key === tag);\n  }\n\n  public hasIsolatedTag() {\n    return this.hasTag(S3_ISOLATED_TAG);\n  }\n\n  public isolatedTagBefore(date: Date) {\n    const tagValue = this.getTag(S3_ISOLATED_TAG);\n    if (!tagValue || tagValue == '') {\n      return false;\n    }\n    return new Date(tagValue) < date;\n  }\n}\n\n/**\n * Props for the Garbage Collector\n */\ninterface GarbageCollectorProps {\n  /**\n   * The action to perform. Specify this if you want to perform a truncated set\n   * of actions available.\n   */\n  readonly action: 'print' | 'tag' | 'delete-tagged' | 'full';\n\n  /**\n   * The type of asset to garbage collect.\n   */\n  readonly type: 's3' | 'ecr' | 'all';\n\n  /**\n   * The days an asset must be in isolation before being actually deleted.\n   */\n  readonly rollbackBufferDays: number;\n\n  /**\n   * Refuse deletion of any assets younger than this number of days.\n   */\n  readonly createdBufferDays: number;\n\n  /**\n   * The environment to deploy this stack in\n   *\n   * The environment on the stack artifact may be unresolved, this one\n   * must be resolved.\n   */\n  readonly resolvedEnvironment: cxapi.Environment;\n\n  /**\n   * SDK provider (seeded with default credentials)\n   *\n   * Will be used to make SDK calls to CloudFormation, S3, and ECR.\n   */\n  readonly sdkProvider: SdkProvider;\n\n  /**\n   * Used to send messages.\n   */\n  readonly ioHelper: IoHelper;\n\n  /**\n   * The name of the bootstrap stack to look for.\n   *\n   * @default DEFAULT_TOOLKIT_STACK_NAME\n   */\n  readonly bootstrapStackName?: string;\n\n  /**\n   * Confirm with the user before actual deletion happens\n   *\n   * @default true\n   */\n  readonly confirm?: boolean;\n}\n\n/**\n * A class to facilitate Garbage Collection of S3 and ECR assets\n */\nexport class GarbageCollector {\n  private garbageCollectS3Assets: boolean;\n  private garbageCollectEcrAssets: boolean;\n  private permissionToDelete: boolean;\n  private permissionToTag: boolean;\n  private bootstrapStackName: string;\n  private confirm: boolean;\n  private ioHelper: IoHelper;\n\n  public constructor(readonly props: GarbageCollectorProps) {\n    this.ioHelper = props.ioHelper;\n\n    this.garbageCollectS3Assets = ['s3', 'all'].includes(props.type);\n    this.garbageCollectEcrAssets = ['ecr', 'all'].includes(props.type);\n\n    this.permissionToDelete = ['delete-tagged', 'full'].includes(props.action);\n    this.permissionToTag = ['tag', 'full'].includes(props.action);\n    this.confirm = props.confirm ?? true;\n\n    this.bootstrapStackName = props.bootstrapStackName ?? DEFAULT_TOOLKIT_STACK_NAME;\n  }\n\n  /**\n   * Perform garbage collection on the resolved environment.\n   */\n  public async garbageCollect() {\n    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${this.garbageCollectS3Assets} ${this.garbageCollectEcrAssets}`));\n\n    // SDKs\n    const sdk = (await this.props.sdkProvider.forEnvironment(this.props.resolvedEnvironment, Mode.ForWriting)).sdk;\n    const cfn = sdk.cloudFormation();\n\n    const qualifier = await this.bootstrapQualifier(sdk, this.bootstrapStackName);\n    const activeAssets = new ActiveAssetCache();\n\n    // Grab stack templates first\n    await refreshStacks(cfn, this.ioHelper, activeAssets, qualifier);\n    // Start the background refresh\n    const backgroundStackRefresh = new BackgroundStackRefresh({\n      cfn,\n      ioHelper: this.ioHelper,\n      activeAssets,\n      qualifier,\n    });\n    backgroundStackRefresh.start();\n\n    try {\n      if (this.garbageCollectS3Assets) {\n        await this.garbageCollectS3(sdk, activeAssets, backgroundStackRefresh);\n      }\n\n      if (this.garbageCollectEcrAssets) {\n        await this.garbageCollectEcr(sdk, activeAssets, backgroundStackRefresh);\n      }\n    } catch (err: any) {\n      throw new ToolkitError(err);\n    } finally {\n      backgroundStackRefresh.stop();\n    }\n  }\n\n  /**\n   * Perform garbage collection on ECR assets\n   */\n  public async garbageCollectEcr(sdk: SDK, activeAssets: ActiveAssetCache, backgroundStackRefresh: BackgroundStackRefresh) {\n    const ecr = sdk.ecr();\n    const repo = await this.bootstrapRepositoryName(sdk, this.bootstrapStackName);\n    const numImages = await this.numImagesInRepo(ecr, repo);\n    const printer = new ProgressPrinter(this.ioHelper, numImages, 1000);\n\n    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Found bootstrap repo ${repo} with ${numImages} images`));\n\n    try {\n      // const batches = 1;\n      const batchSize = 1000;\n      const currentTime = Date.now();\n      const graceDays = this.props.rollbackBufferDays;\n\n      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Parsing through ${numImages} images in batches`));\n\n      printer.start();\n\n      for await (const batch of this.readRepoInBatches(ecr, repo, batchSize, currentTime)) {\n        await backgroundStackRefresh.noOlderThan(600_000); // 10 mins\n\n        const { included: isolated, excluded: notIsolated } = partition(batch, asset => !asset.tags.some(t => activeAssets.contains(t)));\n\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${isolated.length} isolated images`));\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${notIsolated.length} not isolated images`));\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${batch.length} images total`));\n\n        let deletables: ImageAsset[] = isolated;\n        let taggables: ImageAsset[] = [];\n        let untaggables: ImageAsset[] = [];\n\n        if (graceDays > 0) {\n          await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg('Filtering out images that are not old enough to delete'));\n\n          // We delete images that are not referenced in ActiveAssets and have the Isolated Tag with a date\n          // earlier than the current time - grace period.\n          deletables = isolated.filter(img => img.isolatedTagBefore(new Date(currentTime - (graceDays * DAY))));\n\n          // We tag images that are not referenced in ActiveAssets and do not have the Isolated Tag.\n          taggables = isolated.filter(img => !img.hasIsolatedTag());\n\n          // We untag images that are referenced in ActiveAssets and currently have the Isolated Tag.\n          untaggables = notIsolated.filter(img => img.hasIsolatedTag());\n        }\n\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${deletables.length} deletable assets`));\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${taggables.length} taggable assets`));\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${untaggables.length} assets to untag`));\n\n        if (this.permissionToDelete && deletables.length > 0) {\n          await this.confirmationPrompt(printer, deletables, 'image');\n          await this.parallelDeleteEcr(ecr, repo, deletables, printer);\n        }\n\n        if (this.permissionToTag && taggables.length > 0) {\n          await this.parallelTagEcr(ecr, repo, taggables, printer);\n        }\n\n        if (this.permissionToTag && untaggables.length > 0) {\n          await this.parallelUntagEcr(ecr, repo, untaggables);\n        }\n\n        printer.reportScannedAsset(batch.length);\n      }\n    } catch (err: any) {\n      throw new ToolkitError(err);\n    } finally {\n      printer.stop();\n    }\n  }\n\n  /**\n   * Perform garbage collection on S3 assets\n   */\n  public async garbageCollectS3(sdk: SDK, activeAssets: ActiveAssetCache, backgroundStackRefresh: BackgroundStackRefresh) {\n    const s3 = sdk.s3();\n    const bucket = await this.bootstrapBucketName(sdk, this.bootstrapStackName);\n    const numObjects = await this.numObjectsInBucket(s3, bucket);\n    const printer = new ProgressPrinter(this.ioHelper, numObjects, 1000);\n\n    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Found bootstrap bucket ${bucket} with ${numObjects} objects`));\n\n    try {\n      const batchSize = 1000;\n      const currentTime = Date.now();\n      const graceDays = this.props.rollbackBufferDays;\n\n      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Parsing through ${numObjects} objects in batches`));\n\n      printer.start();\n\n      // Process objects in batches of 1000\n      // This is the batch limit of s3.DeleteObject and we intend to optimize for the \"worst case\" scenario\n      // where gc is run for the first time on a long-standing bucket where ~100% of objects are isolated.\n      for await (const batch of this.readBucketInBatches(s3, bucket, batchSize, currentTime)) {\n        await backgroundStackRefresh.noOlderThan(600_000); // 10 mins\n\n        const { included: isolated, excluded: notIsolated } = partition(batch, asset => !activeAssets.contains(asset.fileName()));\n\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${isolated.length} isolated assets`));\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${notIsolated.length} not isolated assets`));\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${batch.length} objects total`));\n\n        let deletables: ObjectAsset[] = isolated;\n        let taggables: ObjectAsset[] = [];\n        let untaggables: ObjectAsset[] = [];\n\n        if (graceDays > 0) {\n          await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg('Filtering out assets that are not old enough to delete'));\n          await this.parallelReadAllTags(s3, batch);\n\n          // We delete objects that are not referenced in ActiveAssets and have the Isolated Tag with a date\n          // earlier than the current time - grace period.\n          deletables = isolated.filter(obj => obj.isolatedTagBefore(new Date(currentTime - (graceDays * DAY))));\n\n          // We tag objects that are not referenced in ActiveAssets and do not have the Isolated Tag.\n          taggables = isolated.filter(obj => !obj.hasIsolatedTag());\n\n          // We untag objects that are referenced in ActiveAssets and currently have the Isolated Tag.\n          untaggables = notIsolated.filter(obj => obj.hasIsolatedTag());\n        }\n\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${deletables.length} deletable assets`));\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${taggables.length} taggable assets`));\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`${untaggables.length} assets to untag`));\n\n        if (this.permissionToDelete && deletables.length > 0) {\n          await this.confirmationPrompt(printer, deletables, 'object');\n          await this.parallelDeleteS3(s3, bucket, deletables, printer);\n        }\n\n        if (this.permissionToTag && taggables.length > 0) {\n          await this.parallelTagS3(s3, bucket, taggables, currentTime, printer);\n        }\n\n        if (this.permissionToTag && untaggables.length > 0) {\n          await this.parallelUntagS3(s3, bucket, untaggables);\n        }\n\n        printer.reportScannedAsset(batch.length);\n      }\n    } catch (err: any) {\n      throw new ToolkitError(err);\n    } finally {\n      printer.stop();\n    }\n  }\n\n  private async parallelReadAllTags(s3: IS3Client, objects: ObjectAsset[]) {\n    const limit = pLimit(P_LIMIT);\n\n    for (const obj of objects) {\n      await limit(() => obj.allTags(s3));\n    }\n  }\n\n  /**\n   * Untag assets that were previously tagged, but now currently referenced.\n   * Since this is treated as an implementation detail, we do not print the results in the printer.\n   */\n  private async parallelUntagEcr(ecr: IECRClient, repo: string, untaggables: ImageAsset[]) {\n    const limit = pLimit(P_LIMIT);\n\n    for (const img of untaggables) {\n      const tag = img.getIsolatedTag();\n      await limit(() =>\n        ecr.batchDeleteImage({\n          repositoryName: repo,\n          imageIds: [{\n            imageTag: tag,\n          }],\n        }),\n      );\n    }\n\n    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Untagged ${untaggables.length} assets`));\n  }\n\n  /**\n   * Untag assets that were previously tagged, but now currently referenced.\n   * Since this is treated as an implementation detail, we do not print the results in the printer.\n   */\n  private async parallelUntagS3(s3: IS3Client, bucket: string, untaggables: ObjectAsset[]) {\n    const limit = pLimit(P_LIMIT);\n\n    for (const obj of untaggables) {\n      const tags = await obj.allTags(s3) ?? [];\n      const updatedTags = tags.filter((tag: Tag) => tag.Key !== S3_ISOLATED_TAG);\n      await limit(() =>\n        s3.deleteObjectTagging({\n          Bucket: bucket,\n          Key: obj.key,\n\n        }),\n      );\n      await limit(() =>\n        s3.putObjectTagging({\n          Bucket: bucket,\n          Key: obj.key,\n          Tagging: {\n            TagSet: updatedTags,\n          },\n        }),\n      );\n    }\n\n    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Untagged ${untaggables.length} assets`));\n  }\n\n  /**\n   * Tag images in parallel using p-limit\n   */\n  private async parallelTagEcr(ecr: IECRClient, repo: string, taggables: ImageAsset[], printer: ProgressPrinter) {\n    const limit = pLimit(P_LIMIT);\n\n    for (let i = 0; i < taggables.length; i++) {\n      const img = taggables[i];\n      const tagEcr = async () => {\n        try {\n          await ecr.putImage({\n            repositoryName: repo,\n            imageDigest: img.digest,\n            imageManifest: img.manifest,\n            imageTag: img.buildImageTag(i),\n          });\n        } catch (error) {\n          // This is a false negative -- an isolated asset is untagged\n          // likely due to an imageTag collision. We can safely ignore,\n          // and the isolated asset will be tagged next time.\n          await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Warning: unable to tag image ${JSON.stringify(img.tags)} with ${img.buildImageTag(i)} due to the following error: ${error}`));\n        }\n      };\n      await limit(() => tagEcr());\n    }\n\n    printer.reportTaggedAsset(taggables);\n    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Tagged ${taggables.length} assets`));\n  }\n\n  /**\n   * Tag objects in parallel using p-limit. The putObjectTagging API does not\n   * support batch tagging so we must handle the parallelism client-side.\n   */\n  private async parallelTagS3(s3: IS3Client, bucket: string, taggables: ObjectAsset[], date: number, printer: ProgressPrinter) {\n    const limit = pLimit(P_LIMIT);\n\n    for (const obj of taggables) {\n      await limit(() =>\n        s3.putObjectTagging({\n          Bucket: bucket,\n          Key: obj.key,\n          Tagging: {\n            TagSet: [\n              {\n                Key: S3_ISOLATED_TAG,\n                Value: String(date),\n              },\n            ],\n          },\n        }),\n      );\n    }\n\n    printer.reportTaggedAsset(taggables);\n    await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Tagged ${taggables.length} assets`));\n  }\n\n  /**\n   * Delete images in parallel. The deleteImage API supports batches of 100.\n   */\n  private async parallelDeleteEcr(ecr: IECRClient, repo: string, deletables: ImageAsset[], printer: ProgressPrinter) {\n    const batchSize = 100;\n    const imagesToDelete = deletables.map(img => ({\n      imageDigest: img.digest,\n    }));\n\n    try {\n      const batches = [];\n      for (let i = 0; i < imagesToDelete.length; i += batchSize) {\n        batches.push(imagesToDelete.slice(i, i + batchSize));\n      }\n      // Delete images in batches\n      for (const batch of batches) {\n        await ecr.batchDeleteImage({\n          imageIds: batch,\n          repositoryName: repo,\n        });\n\n        const deletedCount = batch.length;\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Deleted ${deletedCount} assets`));\n        printer.reportDeletedAsset(deletables.slice(0, deletedCount));\n      }\n    } catch (err) {\n      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_ERROR.msg(`Error deleting images: ${err}`));\n    }\n  }\n\n  /**\n   * Delete objects in parallel. The deleteObjects API supports batches of 1000.\n   */\n  private async parallelDeleteS3(s3: IS3Client, bucket: string, deletables: ObjectAsset[], printer: ProgressPrinter) {\n    const batchSize = 1000;\n    const objectsToDelete = deletables.map(asset => ({\n      Key: asset.key,\n    }));\n\n    try {\n      const batches = [];\n      for (let i = 0; i < objectsToDelete.length; i += batchSize) {\n        batches.push(objectsToDelete.slice(i, i + batchSize));\n      }\n      // Delete objects in batches\n      for (const batch of batches) {\n        await s3.deleteObjects({\n          Bucket: bucket,\n          Delete: {\n            Objects: batch,\n            Quiet: true,\n          },\n        });\n\n        const deletedCount = batch.length;\n        await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Deleted ${deletedCount} assets`));\n        printer.reportDeletedAsset(deletables.slice(0, deletedCount));\n      }\n    } catch (err) {\n      await this.ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(chalk.red(`Error deleting objects: ${err}`)));\n    }\n  }\n\n  private async bootstrapBucketName(sdk: SDK, bootstrapStackName: string): Promise<string> {\n    const toolkitInfo = await ToolkitInfo.lookup(this.props.resolvedEnvironment, sdk, this.ioHelper, bootstrapStackName);\n    return toolkitInfo.bucketName;\n  }\n\n  private async bootstrapRepositoryName(sdk: SDK, bootstrapStackName: string): Promise<string> {\n    const toolkitInfo = await ToolkitInfo.lookup(this.props.resolvedEnvironment, sdk, this.ioHelper, bootstrapStackName);\n    return toolkitInfo.repositoryName;\n  }\n\n  private async bootstrapQualifier(sdk: SDK, bootstrapStackName: string): Promise<string | undefined> {\n    const toolkitInfo = await ToolkitInfo.lookup(this.props.resolvedEnvironment, sdk, this.ioHelper, bootstrapStackName);\n    return toolkitInfo.bootstrapStack.parameters.Qualifier;\n  }\n\n  private async numObjectsInBucket(s3: IS3Client, bucket: string): Promise<number> {\n    let totalCount = 0;\n    let continuationToken: string | undefined;\n\n    do {\n      const response = await s3.listObjectsV2({\n        Bucket: bucket,\n        ContinuationToken: continuationToken,\n      });\n\n      totalCount += response.KeyCount ?? 0;\n      continuationToken = response.NextContinuationToken;\n    } while (continuationToken);\n\n    return totalCount;\n  }\n\n  private async numImagesInRepo(ecr: IECRClient, repo: string): Promise<number> {\n    let totalCount = 0;\n    let nextToken: string | undefined;\n\n    do {\n      const response = await ecr.listImages({\n        repositoryName: repo,\n        nextToken: nextToken,\n      });\n\n      totalCount += response.imageIds?.length ?? 0;\n      nextToken = response.nextToken;\n    } while (nextToken);\n\n    return totalCount;\n  }\n\n  private async *readRepoInBatches(ecr: IECRClient, repo: string, batchSize: number = 1000, currentTime: number): AsyncGenerator<ImageAsset[]> {\n    let continuationToken: string | undefined;\n\n    do {\n      const batch: ImageAsset[] = [];\n\n      while (batch.length < batchSize) {\n        const response = await ecr.listImages({\n          repositoryName: repo,\n          nextToken: continuationToken,\n        });\n\n        // No images in the repository\n        if (!response.imageIds || response.imageIds.length === 0) {\n          break;\n        }\n\n        // map unique image digest to (possibly multiple) tags\n        const images = imageMap(response.imageIds ?? []);\n\n        const imageIds = Object.keys(images).map(key => ({\n          imageDigest: key,\n        }));\n\n        const describeImageInfo = await ecr.describeImages({\n          repositoryName: repo,\n          imageIds: imageIds,\n        });\n\n        const getImageInfo = await ecr.batchGetImage({\n          repositoryName: repo,\n          imageIds: imageIds,\n        });\n\n        const combinedImageInfo = describeImageInfo.imageDetails?.map(imageDetail => {\n          const matchingImage = getImageInfo.images?.find(\n            img => img.imageId?.imageDigest === imageDetail.imageDigest,\n          );\n\n          return {\n            ...imageDetail,\n            manifest: matchingImage?.imageManifest,\n          };\n        });\n\n        for (const image of combinedImageInfo ?? []) {\n          const lastModified = image.imagePushedAt ?? new Date(currentTime);\n          // Store the image if it was pushed earlier than today - createdBufferDays\n          if (image.imageDigest && lastModified < new Date(currentTime - (this.props.createdBufferDays * DAY))) {\n            batch.push(new ImageAsset(image.imageDigest, image.imageSizeInBytes ?? 0, image.imageTags ?? [], image.manifest ?? ''));\n          }\n        }\n\n        continuationToken = response.nextToken;\n\n        if (!continuationToken) break; // No more images to fetch\n      }\n\n      if (batch.length > 0) {\n        yield batch;\n      }\n    } while (continuationToken);\n  }\n\n  /**\n   * Generator function that reads objects from the S3 Bucket in batches.\n   */\n  private async *readBucketInBatches(s3: IS3Client, bucket: string, batchSize: number = 1000, currentTime: number): AsyncGenerator<ObjectAsset[]> {\n    let continuationToken: string | undefined;\n\n    do {\n      const batch: ObjectAsset[] = [];\n\n      while (batch.length < batchSize) {\n        const response = await s3.listObjectsV2({\n          Bucket: bucket,\n          ContinuationToken: continuationToken,\n        });\n\n        response.Contents?.forEach((obj: any) => {\n          const key = obj.Key ?? '';\n          const size = obj.Size ?? 0;\n          const lastModified = obj.LastModified ?? new Date(currentTime);\n          // Store the object if it has a Key and\n          // if it has not been modified since today - createdBufferDays\n          if (key && lastModified < new Date(currentTime - (this.props.createdBufferDays * DAY))) {\n            batch.push(new ObjectAsset(bucket, key, size));\n          }\n        });\n\n        continuationToken = response.NextContinuationToken;\n\n        if (!continuationToken) break; // No more objects to fetch\n      }\n\n      if (batch.length > 0) {\n        yield batch;\n      }\n    } while (continuationToken);\n  }\n\n  private async confirmationPrompt(printer: ProgressPrinter, deletables: GcAsset[], type: string) {\n    const pluralize = (name: string, count: number): string => {\n      return count === 1 ? name : `${name}s`;\n    };\n\n    if (this.confirm) {\n      const message = [\n        `Found ${deletables.length} ${pluralize(type, deletables.length)} to delete based off of the following criteria:`,\n        `- ${type}s have been isolated for > ${this.props.rollbackBufferDays} days`,\n        `- ${type}s were created > ${this.props.createdBufferDays} days ago`,\n        '',\n        'Delete this batch (yes/no/delete-all)?',\n      ].join('\\n');\n      printer.pause();\n      const response = await promptly.prompt(message,\n        { trim: true },\n      );\n\n      // Anything other than yes/y/delete-all is treated as no\n      if (!response || !['yes', 'y', 'delete-all'].includes(response.toLowerCase())) {\n        throw new ToolkitError('Deletion aborted by user');\n      } else if (response.toLowerCase() == 'delete-all') {\n        this.confirm = false;\n      }\n    }\n    printer.resume();\n  }\n}\n\nfunction partition<A>(xs: Iterable<A>, pred: (x: A) => boolean): { included: A[]; excluded: A[] } {\n  const result = {\n    included: [] as A[],\n    excluded: [] as A[],\n  };\n\n  for (const x of xs) {\n    if (pred(x)) {\n      result.included.push(x);\n    } else {\n      result.excluded.push(x);\n    }\n  }\n\n  return result;\n}\n\nfunction imageMap(imageIds: ImageIdentifier[]) {\n  const images: Record<string, string[]> = {};\n  for (const image of imageIds ?? []) {\n    if (!image.imageDigest || !image.imageTag) {\n      continue;\n    }\n    if (!images[image.imageDigest]) {\n      images[image.imageDigest] = [];\n    }\n    images[image.imageDigest].push(image.imageTag);\n  }\n  return images;\n}\n"]}