@atomist/sdm-pack-docker/lib/docker/executeDockerBuild.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 });
const automation_client_1 = require("@atomist/automation-client");
const sdm_1 = require("@atomist/sdm");
const sdm_core_1 = require("@atomist/sdm-core");
const fs = require("fs-extra");
const _ = require("lodash");
const os = require("os");
const path = require("path");
const name_1 = require("./name");
/**
 * Execute a Docker build for the project
 * @param {DockerOptions} options
 * @returns {ExecuteGoal}
 */
function executeDockerBuild(options) {
    return sdm_1.doWithProject((gi) => __awaiter(this, void 0, void 0, function* () {
        const { goalEvent, context, project } = gi;
        const optsToUse = sdm_1.mergeOptions(options, {}, "docker.build");
        switch (optsToUse.builder) {
            case "docker":
                yield checkIsBuilderAvailable("docker", "help");
                break;
            case "kaniko":
                yield checkIsBuilderAvailable("/kaniko/executor", "--help");
                break;
        }
        const imageName = yield optsToUse.dockerImageNameCreator(project, goalEvent, optsToUse, context);
        const dockerfilePath = yield (optsToUse.dockerfileFinder ? optsToUse.dockerfileFinder(project) : "Dockerfile");
        const externalUrls = getExternalUrls(imageName.tags, optsToUse);
        let result;
        if (optsToUse.builder === "docker") {
            const tags = _.flatten(imageName.tags.map(i => ["-t", i]));
            result = yield gi.spawn("docker", ["build", "-f", dockerfilePath, ...tags, ...optsToUse.builderArgs, "."], {
                env: Object.assign({}, process.env, { DOCKER_CONFIG: dockerConfigPath(optsToUse, gi.goalEvent) }),
                log: gi.progressLog,
            });
            if (result.code !== 0) {
                return result;
            }
            result = yield dockerPush(imageName.tags, optsToUse, gi);
            if (result.code !== 0) {
                return result;
            }
        }
        else if (optsToUse.builder === "kaniko") {
            // 2. run kaniko build
            const builderArgs = [];
            if (yield pushEnabled(gi, optsToUse)) {
                builderArgs.push(...imageName.tags.map(i => `-d=${i}`), "--cache=true");
            }
            else {
                builderArgs.push("--no-push");
            }
            builderArgs.push(...(optsToUse.builderArgs.length > 0 ? optsToUse.builderArgs : ["--snapshotMode=time", "--reproducible"]));
            // Check if base image cache dir is available
            const cacheFilPath = _.get(gi, "configuration.sdm.cache.path", "/opt/data");
            if (_.get(gi, "configuration.sdm.cache.enabled") === true && (yield fs.pathExists(cacheFilPath))) {
                const baseImageCache = path.join(cacheFilPath, "base-image-cache");
                yield fs.mkdirs(baseImageCache);
                builderArgs.push(`--cache-dir=${baseImageCache}`, "--cache=true");
            }
            result = yield gi.spawn("/kaniko/executor", ["--dockerfile", dockerfilePath, "--context", `dir://${project.baseDir}`, ..._.uniq(builderArgs)], {
                env: Object.assign({}, process.env, { DOCKER_CONFIG: dockerConfigPath(optsToUse, gi.goalEvent) }),
                log: gi.progressLog,
            });
            if (result.code !== 0) {
                return result;
            }
        }
        // 4. create image link
        if (yield sdm_core_1.postLinkImageWebhook(goalEvent.repo.owner, goalEvent.repo.name, goalEvent.sha, imageName.tags[0], context.workspaceId)) {
            return {
                code: 0,
                externalUrls,
            };
        }
        else {
            return { code: 1, message: "Image link failed" };
        }
    }), {
        readOnly: true,
        detachHead: false,
    });
}
exports.executeDockerBuild = executeDockerBuild;
function dockerLogin(options, optsToUse, gi) {
    return __awaiter(this, void 0, void 0, function* () {
        if (options.username && options.password) {
            gi.progressLog.write("Running 'docker login'");
            const loginArgs = ["login", "--username", options.username, "--password", options.password];
            if (/[^A-Za-z0-9]/.test(options.url)) {
                loginArgs.push(options.url);
            }
            // 2. run docker login
            return gi.spawn("docker", loginArgs, {
                logCommand: false,
                log: gi.progressLog,
            });
        }
        else if (optsToUse.config) {
            gi.progressLog.write("Authenticating with provided Docker 'config.json'");
            const dockerConfig = path.join(dockerConfigPath(optsToUse, gi.goalEvent), "config.json");
            yield fs.ensureDir(path.dirname(dockerConfig));
            yield fs.writeFile(dockerConfig, optsToUse.config);
        }
        else {
            gi.progressLog.write("Skipping 'docker auth' because no credentials configured");
        }
        return automation_client_1.Success;
    });
}
function dockerPush(images, options, gi) {
    return __awaiter(this, void 0, void 0, function* () {
        if (yield pushEnabled(gi, options)) {
            // Login to registry(s)
            yield Promise.all(options.registries.map((r) => __awaiter(this, void 0, void 0, function* () {
                const loginResult = yield dockerLogin(r, options, gi);
                if (loginResult.code !== 0) {
                    throw new Error(`Failed login for registry => ${r.url}!`);
                }
            })));
            yield Promise.all(images.map((image) => __awaiter(this, void 0, void 0, function* () {
                const pushResult = yield gi.spawn("docker", ["push", image], {
                    env: Object.assign({}, process.env, { DOCKER_CONFIG: dockerConfigPath(options, gi.goalEvent) }),
                    log: gi.progressLog,
                });
                if (pushResult.code !== 0) {
                    throw new Error(`Failed to push image ${image}!  Error (code: ${pushResult.code}) => ${pushResult.stderr}`);
                }
            })));
        }
        else {
            gi.progressLog.write("Skipping 'docker push'");
        }
        return { code: 0 };
    });
}
exports.DefaultDockerImageNameCreator = (p, sdmGoal, options, context) => __awaiter(this, void 0, void 0, function* () {
    const name = name_1.cleanImageName(p.name);
    const version = yield sdm_core_1.readSdmVersion(sdmGoal.repo.owner, sdmGoal.repo.name, sdmGoal.repo.providerId, sdmGoal.sha, sdmGoal.branch, context);
    // If there are configured registries, set tags for each; otherwise return just version
    const tags = [];
    const latestTag = yield sdm_1.projectConfigurationValue("docker.tag.latest", p, false);
    options.registries.map(r => {
        tags.push(`${r.url}/${name}:${version}`);
        if (latestTag && sdmGoal.branch === sdmGoal.push.repo.defaultBranch) {
            tags.push(`${r.url}/${name}:latest`);
        }
    });
    return {
        name,
        tags,
    };
});
function checkIsBuilderAvailable(cmd, ...args) {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            yield sdm_1.spawnLog(cmd, args, { log: new sdm_1.LoggingProgressLog("docker-build-check") });
        }
        catch (e) {
            throw new Error(`Configured Docker image builder '${cmd}' is not available`);
        }
    });
}
function pushEnabled(gi, options) {
    return __awaiter(this, void 0, void 0, function* () {
        let push;
        // tslint:disable-next-line:no-boolean-literal-compare
        if (options.push === true || options.push === false) {
            push = options.push;
        }
        else if (options.registries.some(r => !!(r.username && r.password)) || !!options.config) {
            push = true;
        }
        return sdm_1.projectConfigurationValue("docker.build.push", gi.project, push);
    });
}
function dockerConfigPath(options, goalEvent) {
    if (options.registries.some(r => !!(r.username && r.password))) {
        return path.join(os.homedir(), ".docker");
    }
    else if (!!options.config) {
        return path.join(os.homedir(), `.docker-${goalEvent.goalSetId}`);
    }
}
function getExternalUrls(tags, options) {
    const externalUrls = tags.map(t => {
        const reg = options.registries.filter(r => t.includes(r.url))[0];
        if (reg.display !== false) {
            let url = !!reg.displayUrl ? t.replace(reg.url, reg.displayUrl) : t;
            if (!!reg.displayBrowsePath) {
                const replace = url.split(":").pop();
                url = url.replace(`:${replace}`, `${reg.displayBrowsePath}`);
            }
            if (!!reg.label) {
                return { label: reg.label, url };
            }
            else {
                return { url };
            }
        }
    });
    return _.uniqBy(externalUrls, "url");
}
//# sourceMappingURL=executeDockerBuild.js.map