@atomist/sdm-pack-s3/lib/publishToS3.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) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    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) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const automation_client_1 = require("@atomist/automation-client");
const sdm_1 = require("@atomist/sdm");
const AWS = require("aws-sdk");
const proxy = require("proxy-agent");
const deleteS3_1 = require("./deleteS3");
const putS3_1 = require("./putS3");
/**
 * Get a goal that will publish (portions of) a project to S3.
 * If the project needs to be built or otherwise processed first, use
 * `.withProjectListeners` to get those prerequisite steps done.
 */
class PublishToS3 extends sdm_1.GoalWithFulfillment {
    constructor(options) {
        super(Object.assign({ workingDescription: "Publishing to S3", completedDescription: "Published to S3" }, options));
        this.options = options;
    }
    /**
     * Called by the SDM on initialization.  This function calls
     * `super.register` and adds a startup listener to the SDM.  The
     * startup listener registers a default goal fulfillment if there
     * is none that suppresses logs posted to chat.
     */
    register(sdm) {
        super.register(sdm);
        sdm.addStartupListener(() => __awaiter(this, void 0, void 0, function* () {
            if (this.fulfillments.length === 0 && this.callbacks.length === 0) {
                this.with({
                    name: `publishToS3-${this.options.bucketName}`,
                    goalExecutor: executePublishToS3(this.options),
                    logInterpreter: sdm_1.LogSuppressor,
                });
            }
        }));
    }
}
exports.PublishToS3 = PublishToS3;
function executePublishToS3(inputParams) {
    const params = Object.assign({ pathTranslation: p => p, linkLabel: "S3 Website" }, inputParams);
    return sdm_1.doWithProject((inv) => __awaiter(this, void 0, void 0, function* () {
        if (!inv.id.sha) {
            return { code: 99, message: "SHA is not defined. I need that" };
        }
        if (inputParams.proxy) {
            AWS.config.update({
                // The output of proxy is ultimately an http|https agent, but the typings don't line up unfortunately
                httpOptions: { agent: new proxy(inputParams.proxy) },
            });
        }
        try {
            let s3;
            if (inv.configuration.sdm.aws && inv.configuration.sdm.aws.accessKey && inv.configuration.sdm.aws.secretKey) {
                const credentials = new AWS.Credentials(inv.configuration.sdm.aws.accessKey, inv.configuration.sdm.aws.secretKey);
                s3 = new AWS.S3({ credentials });
            }
            else {
                automation_client_1.logger.info(`No AWS keys in SDM configuration, falling back to default credentials`);
                s3 = new AWS.S3();
            }
            const result = yield pushToS3(s3, inv, params);
            let linkToIndex;
            if (params.pathToIndex) {
                linkToIndex = result.bucketUrl + params.pathTranslation(params.pathToIndex, inv);
                inv.progressLog.write("URL: " + linkToIndex);
            }
            inv.progressLog.write(result.warnings.join("\n"));
            inv.progressLog.write(`${result.fileCount} files uploaded to ${params.bucketName}`);
            inv.progressLog.write(`${result.deleted} objects deleted from ${params.bucketName}`);
            if (result.warnings.length > 0) {
                yield inv.addressChannels(formatWarningMessage(linkToIndex, result.warnings, inv.id, inv.context));
                if (result.fileCount === 0) {
                    return {
                        code: 1,
                        message: `0 files uploaded. ${result.warnings.length} warnings, including: ${result.warnings[0]}`,
                    };
                }
            }
            return {
                code: 0,
                externalUrls: (linkToIndex) ? [{ label: params.linkLabel, url: linkToIndex }] : undefined,
            };
        }
        catch (e) {
            return { code: 98, message: e.message };
        }
    }), { readOnly: true });
}
exports.executePublishToS3 = executePublishToS3;
function formatWarningMessage(url, warnings, id, ctx) {
    return sdm_1.slackWarningMessage("Some files were not uploaded to S3", warnings.join("\n"), ctx, {
        author_name: `published files from ${id.owner}/${id.repo}#${id.sha.substr(0, 7)}`,
        author_link: url,
    });
}
/**
 * Push files in project to S3 according to options provided by
 * `params`.
 *
 * @param s3 S3 client
 * @param inv goal invocation with project to upload
 * @param params options for upload
 * @return information on upload success and warnings
 */
function pushToS3(s3, inv, params) {
    return __awaiter(this, void 0, void 0, function* () {
        const { bucketName, region } = params;
        const project = inv.project;
        const log = inv.progressLog;
        const [fileCount, keysToKeep, warningsFromPut] = yield putS3_1.putFiles(project, inv, s3, params);
        let deleted = 0;
        let moreWarnings = [];
        if (params.sync) {
            const [keysToDelete, warningsFromGatheringFilesToDelete] = yield deleteS3_1.gatherKeysToDelete(s3, log, keysToKeep, params);
            const [deletedCount, warningsFromDeletions] = yield deleteS3_1.deleteKeys(s3, log, params, keysToDelete);
            deleted = deletedCount;
            moreWarnings = [...warningsFromGatheringFilesToDelete, ...warningsFromDeletions];
        }
        return {
            bucketUrl: `http://${bucketName}.s3-website.${region}.amazonaws.com/`,
            warnings: [...warningsFromPut, ...moreWarnings],
            fileCount,
            deleted,
        };
    });
}
exports.pushToS3 = pushToS3;
//# sourceMappingURL=publishToS3.js.map