@atomist/sdm-pack-s3/lib/deleteS3.js

"use strict";
/*
 * Copyright © 2019 Atomist, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
function deleteKeys(s3, log, params, keysToDelete) {
    return __awaiter(this, void 0, void 0, function* () {
        const { bucketName } = params;
        let deleted = 0;
        const warnings = [];
        const maxItems = 1000;
        for (let i = 0; i < keysToDelete.length; i += maxItems) {
            const deleteNow = keysToDelete.slice(i, i + maxItems);
            try {
                const deleteObjectsResult = yield s3.deleteObjects({
                    Bucket: bucketName,
                    Delete: {
                        Objects: deleteNow,
                    },
                }).promise();
                deleted += deleteObjectsResult.Deleted.length;
                const deletedString = deleteObjectsResult.Deleted.map(o => o.Key).join(",");
                log.write(`Deleted objects (${deletedString}) in 's3://${bucketName}'`);
                if (deleteObjectsResult.Errors && deleteObjectsResult.Errors.length > 0) {
                    deleteObjectsResult.Errors.forEach(e => {
                        const msg = `Error deleting object '${e.Key}': ${e.Message}`;
                        log.write(msg);
                        warnings.push(msg);
                    });
                }
            }
            catch (e) {
                const keysString = deleteNow.map(o => o.Key).join(",");
                const msg = `Failed to delete objects (${keysString}) in 's3://${bucketName}': ${e.message}`;
                log.write(msg);
                warnings.push(msg);
                break;
            }
        }
        return [deleted, warnings];
    });
}
exports.deleteKeys = deleteKeys;
function gatherKeysToDelete(s3, log, keysToKeep, params) {
    return __awaiter(this, void 0, void 0, function* () {
        const { bucketName } = params;
        const keysToDelete = [];
        const warnings = [];
        let listObjectsResponse = {
            IsTruncated: true,
            NextContinuationToken: undefined,
        };
        const maxItems = 1000;
        while (listObjectsResponse.IsTruncated) {
            try {
                listObjectsResponse = yield s3.listObjectsV2({
                    Bucket: bucketName,
                    MaxKeys: maxItems,
                    ContinuationToken: listObjectsResponse.NextContinuationToken,
                }).promise();
                keysToDelete.push(...filterKeys(keysToKeep, listObjectsResponse.Contents));
            }
            catch (e) {
                const msg = `Failed to list objects in 's3://${bucketName}': ${e.message}`;
                log.write(msg);
                warnings.push(msg);
                break;
            }
        }
        return [keysToDelete, warnings];
    });
}
exports.gatherKeysToDelete = gatherKeysToDelete;
/**
 * Remove objects that either have no key or match a key in `keys`.
 *
 * @param keys Keys that should be removed from `objects`
 * @param objects Array to filter
 * @return Array of object identifiers
 */
function filterKeys(keys, objects) {
    return objects.filter(o => o.Key && !keys.includes(o.Key)).map(o => ({ Key: o.Key }));
}
exports.filterKeys = filterKeys;
//# sourceMappingURL=deleteS3.js.map