mirror of
https://github.com/redhat-actions/buildah-build.git
synced 2025-04-15 07:21:23 +00:00
311 lines
11 KiB
TypeScript
311 lines
11 KiB
TypeScript
/***************************************************************************************************
|
|
* Copyright (c) Red Hat, Inc. All rights reserved.
|
|
* Licensed under the MIT License. See LICENSE file in the project root for license information.
|
|
**************************************************************************************************/
|
|
|
|
import * as core from "@actions/core";
|
|
import * as exec from "@actions/exec";
|
|
import * as path from "path";
|
|
import CommandResult from "./types";
|
|
import { isStorageDriverOverlay, findFuseOverlayfsPath, getFullImageName } from "./utils";
|
|
|
|
export interface BuildahConfigSettings {
|
|
entrypoint?: string[];
|
|
envs?: string[];
|
|
port?: string;
|
|
workingdir?: string;
|
|
arch?: string;
|
|
labels?: string[];
|
|
}
|
|
|
|
interface Buildah {
|
|
buildUsingDocker(
|
|
image: string, context: string, containerFiles: string[], buildArgs: string[],
|
|
useOCI: boolean, labels: string[], layers: string,
|
|
extraArgs: string[], tlsVerify: boolean, arch?: string, platform?: string,
|
|
): Promise<CommandResult>;
|
|
from(baseImage: string, tlsVerify: boolean, extraArgs: string[]): Promise<CommandResult>;
|
|
config(container: string, setting: BuildahConfigSettings): Promise<CommandResult>;
|
|
copy(container: string, contentToCopy: string[]): Promise<CommandResult | undefined>;
|
|
commit(container: string, newImageName: string, useOCI: boolean): Promise<CommandResult>;
|
|
manifestCreate(manifest: string): Promise<void>;
|
|
manifestAdd(manifest: string, imageName: string, tags: string[]): Promise<void>;
|
|
}
|
|
|
|
export class BuildahCli implements Buildah {
|
|
private readonly executable: string;
|
|
|
|
public storageOptsEnv = "";
|
|
|
|
constructor(executable: string) {
|
|
this.executable = executable;
|
|
}
|
|
|
|
// Checks for storage driver if found "overlay",
|
|
// then checks if "fuse-overlayfs" is installed.
|
|
// If yes, add mount program to use "fuse-overlayfs"
|
|
async setStorageOptsEnv(): Promise<void> {
|
|
if (await isStorageDriverOverlay()) {
|
|
const fuseOverlayfsPath = await findFuseOverlayfsPath();
|
|
if (fuseOverlayfsPath) {
|
|
core.info(`Overriding storage mount_program with "fuse-overlayfs" in environment`);
|
|
this.storageOptsEnv = `overlay.mount_program=${fuseOverlayfsPath}`;
|
|
}
|
|
else {
|
|
core.warning(`"fuse-overlayfs" is not found. Install it before running this action. `
|
|
+ `For more detail see https://github.com/redhat-actions/buildah-build/issues/45`);
|
|
}
|
|
}
|
|
else {
|
|
core.info("Storage driver is not 'overlay', so not overriding storage configuration");
|
|
}
|
|
}
|
|
|
|
private static getImageFormatOption(useOCI: boolean): string[] {
|
|
return [ "--format", useOCI ? "oci" : "docker" ];
|
|
}
|
|
|
|
async buildUsingDocker(
|
|
image: string,
|
|
context: string,
|
|
containerFiles: string[],
|
|
buildArgs: string[],
|
|
useOCI: boolean,
|
|
labels: string[],
|
|
layers: string,
|
|
extraArgs: string[],
|
|
tlsVerify: boolean,
|
|
arch?: string,
|
|
platform?: string
|
|
): Promise<CommandResult> {
|
|
const args: string[] = [ "bud" ];
|
|
if (arch) {
|
|
args.push("--arch");
|
|
args.push(arch);
|
|
}
|
|
if (platform) {
|
|
args.push("--platform");
|
|
args.push(platform);
|
|
}
|
|
containerFiles.forEach((file) => {
|
|
args.push("-f");
|
|
args.push(file);
|
|
});
|
|
labels.forEach((label) => {
|
|
args.push("--label");
|
|
args.push(label);
|
|
});
|
|
buildArgs.forEach((buildArg) => {
|
|
args.push("--build-arg");
|
|
args.push(buildArg);
|
|
});
|
|
args.push(...BuildahCli.getImageFormatOption(useOCI));
|
|
args.push(`--tls-verify=${tlsVerify}`);
|
|
if (layers) {
|
|
args.push(`--layers=${layers}`);
|
|
}
|
|
if (extraArgs.length > 0) {
|
|
args.push(...extraArgs);
|
|
}
|
|
args.push("-t");
|
|
args.push(image);
|
|
args.push(context);
|
|
return this.execute(args);
|
|
}
|
|
|
|
async from(baseImage: string, tlsVerify: boolean, extraArgs: string[]): Promise<CommandResult> {
|
|
const args: string[] = [ "from" ];
|
|
args.push(`--tls-verify=${tlsVerify}`);
|
|
if (extraArgs.length > 0) {
|
|
args.push(...extraArgs);
|
|
}
|
|
args.push(baseImage);
|
|
return this.execute(args);
|
|
}
|
|
|
|
async copy(container: string, contentToCopy: string[], contentPath?: string): Promise<CommandResult | undefined> {
|
|
if (contentToCopy.length === 0) {
|
|
return undefined;
|
|
}
|
|
|
|
core.debug("copy");
|
|
core.debug(container);
|
|
core.debug("content: " + contentToCopy.join(" "));
|
|
if (contentToCopy.length > 0) {
|
|
const args: string[] = [ "copy", container ].concat(contentToCopy);
|
|
if (contentPath) {
|
|
args.push(contentPath);
|
|
}
|
|
return this.execute(args);
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
async config(container: string, settings: BuildahConfigSettings): Promise<CommandResult> {
|
|
core.debug("config");
|
|
core.debug(container);
|
|
const args: string[] = [ "config" ];
|
|
if (settings.entrypoint) {
|
|
args.push("--entrypoint");
|
|
args.push(BuildahCli.convertArrayToStringArg(settings.entrypoint));
|
|
}
|
|
if (settings.port) {
|
|
args.push("--port");
|
|
args.push(settings.port);
|
|
}
|
|
if (settings.envs) {
|
|
settings.envs.forEach((env) => {
|
|
args.push("--env");
|
|
args.push(env);
|
|
});
|
|
}
|
|
if (settings.arch) {
|
|
args.push("--arch");
|
|
args.push(settings.arch);
|
|
}
|
|
if (settings.workingdir) {
|
|
args.push("--workingdir");
|
|
args.push(settings.workingdir);
|
|
}
|
|
if (settings.labels) {
|
|
settings.labels.forEach((label) => {
|
|
args.push("--label");
|
|
args.push(label);
|
|
});
|
|
}
|
|
args.push(container);
|
|
return this.execute(args);
|
|
}
|
|
|
|
async commit(container: string, newImageName: string, useOCI: boolean): Promise<CommandResult> {
|
|
core.debug("commit");
|
|
core.debug(container);
|
|
core.debug(newImageName);
|
|
const args: string[] = [
|
|
"commit", ...BuildahCli.getImageFormatOption(useOCI),
|
|
"--squash", container, newImageName,
|
|
];
|
|
return this.execute(args);
|
|
}
|
|
|
|
async tag(imageName: string, tags: string[]): Promise<void> {
|
|
const args: string[] = [ "tag" ];
|
|
const builtImage = [];
|
|
for (const tag of tags) {
|
|
args.push(getFullImageName(imageName, tag));
|
|
builtImage.push(getFullImageName(imageName, tag));
|
|
}
|
|
core.info(`Tagging the built image with tags ${tags.toString()}`);
|
|
await this.execute(args);
|
|
core.info(`✅ Successfully built image${builtImage.length !== 1 ? "s" : ""} "${builtImage.join(", ")}"`);
|
|
}
|
|
|
|
// Unfortunately buildah doesn't support the exists command yet
|
|
// https://github.com/containers/buildah/issues/4217
|
|
|
|
// async manifestExists(manifest: string): Promise<boolean> {
|
|
// const args: string[] = [ "manifest", "exists" ];
|
|
// args.push(manifest);
|
|
// const execOptions: exec.ExecOptions = {ignoreReturnCode: true};
|
|
// core.info(`Checking if manifest ${manifest} exists`);
|
|
// const {exitCode} = await this.execute(args, execOptions);
|
|
// return exitCode ? false : true;
|
|
// }
|
|
|
|
async manifestRm(manifest: string): Promise<void> {
|
|
const execOptions: exec.ExecOptions = { ignoreReturnCode: true };
|
|
const args: string[] = [ "manifest", "rm" ];
|
|
args.push(manifest);
|
|
core.info(`Removing existing manifest ${manifest}`);
|
|
await this.execute(args, execOptions);
|
|
}
|
|
|
|
async manifestCreate(manifest: string): Promise<void> {
|
|
const args: string[] = [ "manifest", "create" ];
|
|
args.push(manifest);
|
|
core.info(`Creating manifest ${manifest}`);
|
|
await this.execute(args);
|
|
}
|
|
|
|
async manifestAdd(manifest: string, image: string): Promise<void> {
|
|
const args: string[] = [ "manifest", "add" ];
|
|
args.push(manifest);
|
|
args.push(image);
|
|
core.info(`Adding image "${image}" to the manifest.`);
|
|
await this.execute(args);
|
|
}
|
|
|
|
private static convertArrayToStringArg(args: string[]): string {
|
|
let arrayAsString = "[";
|
|
args.forEach((arg) => {
|
|
arrayAsString += `"${arg}",`;
|
|
});
|
|
return `${arrayAsString.slice(0, -1)}]`;
|
|
}
|
|
|
|
async execute(
|
|
args: string[],
|
|
execOptions: exec.ExecOptions & { group?: boolean } = {},
|
|
): Promise<CommandResult> {
|
|
// ghCore.info(`${EXECUTABLE} ${args.join(" ")}`)
|
|
|
|
let stdout = "";
|
|
let stderr = "";
|
|
|
|
const finalExecOptions = { ...execOptions };
|
|
finalExecOptions.ignoreReturnCode = true; // the return code is processed below
|
|
|
|
finalExecOptions.listeners = {
|
|
stdline: (line): void => {
|
|
stdout += line + "\n";
|
|
},
|
|
errline: (line):void => {
|
|
stderr += line + "\n";
|
|
},
|
|
};
|
|
|
|
if (execOptions.group) {
|
|
const groupName = [ this.executable, ...args ].join(" ");
|
|
core.startGroup(groupName);
|
|
}
|
|
|
|
// To solve https://github.com/redhat-actions/buildah-build/issues/45
|
|
const execEnv: { [key: string] : string } = {};
|
|
Object.entries(process.env).forEach(([ key, value ]) => {
|
|
if (value != null) {
|
|
execEnv[key] = value;
|
|
}
|
|
});
|
|
|
|
if (this.storageOptsEnv) {
|
|
execEnv.STORAGE_OPTS = this.storageOptsEnv;
|
|
}
|
|
|
|
finalExecOptions.env = execEnv;
|
|
|
|
try {
|
|
const exitCode = await exec.exec(this.executable, args, finalExecOptions);
|
|
|
|
if (execOptions.ignoreReturnCode !== true && exitCode !== 0) {
|
|
// Throwing the stderr as part of the Error makes the stderr
|
|
// show up in the action outline, which saves some clicking when debugging.
|
|
let error = `${path.basename(this.executable)} exited with code ${exitCode}`;
|
|
if (stderr) {
|
|
error += `\n${stderr}`;
|
|
}
|
|
throw new Error(error);
|
|
}
|
|
|
|
return {
|
|
exitCode, output: stdout, error: stderr,
|
|
};
|
|
}
|
|
|
|
finally {
|
|
if (execOptions.group) {
|
|
core.endGroup();
|
|
}
|
|
}
|
|
}
|
|
}
|