644 lines
23 KiB
TypeScript
644 lines
23 KiB
TypeScript
import * as plugins from './tsdocker.plugins.js';
|
|
import * as paths from './tsdocker.paths.js';
|
|
import { logger, formatDuration } from './tsdocker.logging.js';
|
|
import { DockerRegistry } from './classes.dockerregistry.js';
|
|
import type { IDockerfileOptions, ITsDockerConfig, IBuildCommandOptions } from './interfaces/index.js';
|
|
import type { TsDockerManager } from './classes.tsdockermanager.js';
|
|
import * as fs from 'fs';
|
|
|
|
const smartshellInstance = new plugins.smartshell.Smartshell({
|
|
executor: 'bash',
|
|
});
|
|
|
|
const LOCAL_REGISTRY_PORT = 5234;
|
|
const LOCAL_REGISTRY_HOST = `localhost:${LOCAL_REGISTRY_PORT}`;
|
|
const LOCAL_REGISTRY_CONTAINER = 'tsdocker-local-registry';
|
|
|
|
/**
|
|
* Class Dockerfile represents a Dockerfile on disk
|
|
*/
|
|
export class Dockerfile {
|
|
// STATIC METHODS
|
|
|
|
/**
|
|
* Creates instances of class Dockerfile for all Dockerfiles in cwd
|
|
*/
|
|
public static async readDockerfiles(managerRef: TsDockerManager): Promise<Dockerfile[]> {
|
|
const entries = await plugins.smartfs.directory(paths.cwd).filter('Dockerfile*').list();
|
|
const fileTree = entries
|
|
.filter(entry => entry.isFile)
|
|
.map(entry => plugins.path.join(paths.cwd, entry.name));
|
|
|
|
const readDockerfilesArray: Dockerfile[] = [];
|
|
logger.log('info', `found ${fileTree.length} Dockerfile(s):`);
|
|
for (const filePath of fileTree) {
|
|
logger.log('info', ` ${plugins.path.basename(filePath)}`);
|
|
}
|
|
|
|
for (const dockerfilePath of fileTree) {
|
|
const myDockerfile = new Dockerfile(managerRef, {
|
|
filePath: dockerfilePath,
|
|
read: true,
|
|
});
|
|
readDockerfilesArray.push(myDockerfile);
|
|
}
|
|
|
|
return readDockerfilesArray;
|
|
}
|
|
|
|
/**
|
|
* Sorts Dockerfiles into a build order based on dependencies (topological sort)
|
|
*/
|
|
public static async sortDockerfiles(dockerfiles: Dockerfile[]): Promise<Dockerfile[]> {
|
|
logger.log('info', 'Sorting Dockerfiles based on dependencies...');
|
|
|
|
// Map from cleanTag to Dockerfile instance for quick lookup
|
|
const tagToDockerfile = new Map<string, Dockerfile>();
|
|
dockerfiles.forEach((dockerfile) => {
|
|
tagToDockerfile.set(dockerfile.cleanTag, dockerfile);
|
|
});
|
|
|
|
// Build the dependency graph
|
|
const graph = new Map<Dockerfile, Dockerfile[]>();
|
|
dockerfiles.forEach((dockerfile) => {
|
|
const dependencies: Dockerfile[] = [];
|
|
const baseImage = dockerfile.baseImage;
|
|
|
|
// Extract repo:version from baseImage for comparison with cleanTag
|
|
// baseImage may include a registry prefix (e.g., "host.today/repo:version")
|
|
// but cleanTag is just "repo:version", so we strip the registry prefix
|
|
const baseImageKey = Dockerfile.extractRepoVersion(baseImage);
|
|
|
|
// Check if the baseImage is among the local Dockerfiles
|
|
if (tagToDockerfile.has(baseImageKey)) {
|
|
const baseDockerfile = tagToDockerfile.get(baseImageKey)!;
|
|
dependencies.push(baseDockerfile);
|
|
dockerfile.localBaseImageDependent = true;
|
|
dockerfile.localBaseDockerfile = baseDockerfile;
|
|
}
|
|
|
|
graph.set(dockerfile, dependencies);
|
|
});
|
|
|
|
// Perform topological sort
|
|
const sortedDockerfiles: Dockerfile[] = [];
|
|
const visited = new Set<Dockerfile>();
|
|
const tempMarked = new Set<Dockerfile>();
|
|
|
|
const visit = (dockerfile: Dockerfile) => {
|
|
if (tempMarked.has(dockerfile)) {
|
|
throw new Error(`Circular dependency detected involving ${dockerfile.cleanTag}`);
|
|
}
|
|
if (!visited.has(dockerfile)) {
|
|
tempMarked.add(dockerfile);
|
|
const dependencies = graph.get(dockerfile) || [];
|
|
dependencies.forEach((dep) => visit(dep));
|
|
tempMarked.delete(dockerfile);
|
|
visited.add(dockerfile);
|
|
sortedDockerfiles.push(dockerfile);
|
|
}
|
|
};
|
|
|
|
try {
|
|
dockerfiles.forEach((dockerfile) => {
|
|
if (!visited.has(dockerfile)) {
|
|
visit(dockerfile);
|
|
}
|
|
});
|
|
} catch (error) {
|
|
logger.log('error', (error as Error).message);
|
|
throw error;
|
|
}
|
|
|
|
// Log the sorted order
|
|
sortedDockerfiles.forEach((dockerfile, index) => {
|
|
logger.log(
|
|
'info',
|
|
`Build order ${index + 1}: ${dockerfile.cleanTag} with base image ${dockerfile.baseImage}`
|
|
);
|
|
});
|
|
|
|
return sortedDockerfiles;
|
|
}
|
|
|
|
/**
|
|
* Maps local Dockerfiles dependencies to the corresponding Dockerfile class instances
|
|
*/
|
|
public static async mapDockerfiles(sortedDockerfileArray: Dockerfile[]): Promise<Dockerfile[]> {
|
|
sortedDockerfileArray.forEach((dockerfileArg) => {
|
|
if (dockerfileArg.localBaseImageDependent) {
|
|
// Extract repo:version from baseImage for comparison with cleanTag
|
|
const baseImageKey = Dockerfile.extractRepoVersion(dockerfileArg.baseImage);
|
|
sortedDockerfileArray.forEach((dockfile2: Dockerfile) => {
|
|
if (dockfile2.cleanTag === baseImageKey) {
|
|
dockerfileArg.localBaseDockerfile = dockfile2;
|
|
}
|
|
});
|
|
}
|
|
});
|
|
return sortedDockerfileArray;
|
|
}
|
|
|
|
/** Determines if a local registry is needed for buildx dependency resolution. */
|
|
public static needsLocalRegistry(
|
|
dockerfiles: Dockerfile[],
|
|
options?: { platform?: string },
|
|
): boolean {
|
|
const hasLocalDeps = dockerfiles.some(df => df.localBaseImageDependent);
|
|
if (!hasLocalDeps) return false;
|
|
const config = dockerfiles[0]?.managerRef?.config;
|
|
return !!options?.platform || !!(config?.platforms && config.platforms.length > 1);
|
|
}
|
|
|
|
/** Starts a temporary registry:2 container on port 5234. */
|
|
public static async startLocalRegistry(): Promise<void> {
|
|
await smartshellInstance.execSilent(
|
|
`docker rm -f ${LOCAL_REGISTRY_CONTAINER} 2>/dev/null || true`
|
|
);
|
|
const result = await smartshellInstance.execSilent(
|
|
`docker run -d --name ${LOCAL_REGISTRY_CONTAINER} -p ${LOCAL_REGISTRY_PORT}:5000 registry:2`
|
|
);
|
|
if (result.exitCode !== 0) {
|
|
throw new Error(`Failed to start local registry: ${result.stderr || result.stdout}`);
|
|
}
|
|
// registry:2 starts near-instantly; brief wait for readiness
|
|
await new Promise(resolve => setTimeout(resolve, 1000));
|
|
logger.log('info', `Started local registry at ${LOCAL_REGISTRY_HOST} (buildx dependency bridge)`);
|
|
}
|
|
|
|
/** Stops and removes the temporary local registry container. */
|
|
public static async stopLocalRegistry(): Promise<void> {
|
|
await smartshellInstance.execSilent(
|
|
`docker rm -f ${LOCAL_REGISTRY_CONTAINER} 2>/dev/null || true`
|
|
);
|
|
logger.log('info', 'Stopped local registry');
|
|
}
|
|
|
|
/** Pushes a built image to the local registry for buildx consumption. */
|
|
public static async pushToLocalRegistry(dockerfile: Dockerfile): Promise<void> {
|
|
const registryTag = `${LOCAL_REGISTRY_HOST}/${dockerfile.buildTag}`;
|
|
await smartshellInstance.execSilent(`docker tag ${dockerfile.buildTag} ${registryTag}`);
|
|
const result = await smartshellInstance.execSilent(`docker push ${registryTag}`);
|
|
if (result.exitCode !== 0) {
|
|
throw new Error(`Failed to push to local registry: ${result.stderr || result.stdout}`);
|
|
}
|
|
dockerfile.localRegistryTag = registryTag;
|
|
logger.log('info', `Pushed ${dockerfile.buildTag} to local registry as ${registryTag}`);
|
|
}
|
|
|
|
/**
|
|
* Builds the corresponding real docker image for each Dockerfile class instance
|
|
*/
|
|
public static async buildDockerfiles(
|
|
sortedArrayArg: Dockerfile[],
|
|
options?: { platform?: string; timeout?: number; noCache?: boolean; verbose?: boolean },
|
|
): Promise<Dockerfile[]> {
|
|
const total = sortedArrayArg.length;
|
|
const overallStart = Date.now();
|
|
const useRegistry = Dockerfile.needsLocalRegistry(sortedArrayArg, options);
|
|
|
|
if (useRegistry) {
|
|
await Dockerfile.startLocalRegistry();
|
|
}
|
|
|
|
try {
|
|
for (let i = 0; i < total; i++) {
|
|
const dockerfileArg = sortedArrayArg[i];
|
|
const progress = `(${i + 1}/${total})`;
|
|
logger.log('info', `${progress} Building ${dockerfileArg.cleanTag}...`);
|
|
|
|
const elapsed = await dockerfileArg.build(options);
|
|
logger.log('ok', `${progress} Built ${dockerfileArg.cleanTag} in ${formatDuration(elapsed)}`);
|
|
|
|
// Tag in host daemon for standard docker build compatibility
|
|
const dependentBaseImages = new Set<string>();
|
|
for (const other of sortedArrayArg) {
|
|
if (other.localBaseDockerfile === dockerfileArg && other.baseImage !== dockerfileArg.buildTag) {
|
|
dependentBaseImages.add(other.baseImage);
|
|
}
|
|
}
|
|
for (const fullTag of dependentBaseImages) {
|
|
logger.log('info', `Tagging ${dockerfileArg.buildTag} as ${fullTag} for local dependency resolution`);
|
|
await smartshellInstance.exec(`docker tag ${dockerfileArg.buildTag} ${fullTag}`);
|
|
}
|
|
|
|
// Push to local registry for buildx dependency resolution
|
|
if (useRegistry && sortedArrayArg.some(other => other.localBaseDockerfile === dockerfileArg)) {
|
|
await Dockerfile.pushToLocalRegistry(dockerfileArg);
|
|
}
|
|
}
|
|
} finally {
|
|
if (useRegistry) {
|
|
await Dockerfile.stopLocalRegistry();
|
|
}
|
|
}
|
|
|
|
logger.log('info', `Total build time: ${formatDuration(Date.now() - overallStart)}`);
|
|
return sortedArrayArg;
|
|
}
|
|
|
|
/**
|
|
* Tests all Dockerfiles by calling Dockerfile.test()
|
|
*/
|
|
public static async testDockerfiles(sortedArrayArg: Dockerfile[]): Promise<Dockerfile[]> {
|
|
const total = sortedArrayArg.length;
|
|
const overallStart = Date.now();
|
|
|
|
for (let i = 0; i < total; i++) {
|
|
const dockerfileArg = sortedArrayArg[i];
|
|
const progress = `(${i + 1}/${total})`;
|
|
logger.log('info', `${progress} Testing ${dockerfileArg.cleanTag}...`);
|
|
|
|
const elapsed = await dockerfileArg.test();
|
|
logger.log('ok', `${progress} Tested ${dockerfileArg.cleanTag} in ${formatDuration(elapsed)}`);
|
|
}
|
|
|
|
logger.log('info', `Total test time: ${formatDuration(Date.now() - overallStart)}`);
|
|
return sortedArrayArg;
|
|
}
|
|
|
|
/**
|
|
* Returns a version for a docker file
|
|
* Dockerfile_latest -> latest
|
|
* Dockerfile_v1.0.0 -> v1.0.0
|
|
* Dockerfile -> latest
|
|
*/
|
|
public static dockerFileVersion(
|
|
dockerfileInstanceArg: Dockerfile,
|
|
dockerfileNameArg: string
|
|
): string {
|
|
let versionString: string;
|
|
const versionRegex = /Dockerfile_(.+)$/;
|
|
const regexResultArray = versionRegex.exec(dockerfileNameArg);
|
|
if (regexResultArray && regexResultArray.length === 2) {
|
|
versionString = regexResultArray[1];
|
|
} else {
|
|
versionString = 'latest';
|
|
}
|
|
|
|
// Replace ##version## placeholder with actual package version if available
|
|
if (dockerfileInstanceArg.managerRef?.projectInfo?.npm?.version) {
|
|
versionString = versionString.replace(
|
|
'##version##',
|
|
dockerfileInstanceArg.managerRef.projectInfo.npm.version
|
|
);
|
|
}
|
|
|
|
return versionString;
|
|
}
|
|
|
|
/**
|
|
* Extracts the base image from a Dockerfile content
|
|
* Handles ARG substitution for variable base images
|
|
*/
|
|
public static dockerBaseImage(dockerfileContentArg: string): string {
|
|
const lines = dockerfileContentArg.split(/\r?\n/);
|
|
const args: { [key: string]: string } = {};
|
|
|
|
for (const line of lines) {
|
|
const trimmedLine = line.trim();
|
|
|
|
// Skip empty lines and comments
|
|
if (trimmedLine === '' || trimmedLine.startsWith('#')) {
|
|
continue;
|
|
}
|
|
|
|
// Match ARG instructions
|
|
const argMatch = trimmedLine.match(/^ARG\s+([^\s=]+)(?:=(.*))?$/i);
|
|
if (argMatch) {
|
|
const argName = argMatch[1];
|
|
const argValue = argMatch[2] !== undefined ? argMatch[2] : process.env[argName] || '';
|
|
args[argName] = argValue;
|
|
continue;
|
|
}
|
|
|
|
// Match FROM instructions
|
|
const fromMatch = trimmedLine.match(/^FROM\s+(.+?)(?:\s+AS\s+[^\s]+)?$/i);
|
|
if (fromMatch) {
|
|
let baseImage = fromMatch[1].trim();
|
|
|
|
// Substitute variables in the base image name
|
|
baseImage = Dockerfile.substituteVariables(baseImage, args);
|
|
|
|
return baseImage;
|
|
}
|
|
}
|
|
|
|
throw new Error('No FROM instruction found in Dockerfile');
|
|
}
|
|
|
|
/**
|
|
* Substitutes variables in a string, supporting default values like ${VAR:-default}
|
|
*/
|
|
private static substituteVariables(str: string, vars: { [key: string]: string }): string {
|
|
return str.replace(/\${([^}:]+)(:-([^}]+))?}/g, (_, varName, __, defaultValue) => {
|
|
if (vars[varName] !== undefined) {
|
|
return vars[varName];
|
|
} else if (defaultValue !== undefined) {
|
|
return defaultValue;
|
|
} else {
|
|
return '';
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Extracts the repo:version part from a full image reference, stripping any registry prefix.
|
|
* Examples:
|
|
* "registry.example.com/repo:version" -> "repo:version"
|
|
* "repo:version" -> "repo:version"
|
|
* "host.today/ht-docker-node:npmci" -> "ht-docker-node:npmci"
|
|
*/
|
|
private static extractRepoVersion(imageRef: string): string {
|
|
const parts = imageRef.split('/');
|
|
if (parts.length === 1) {
|
|
// No registry prefix: "repo:version"
|
|
return imageRef;
|
|
}
|
|
|
|
// Check if first part looks like a registry (contains '.' or ':' or is 'localhost')
|
|
const firstPart = parts[0];
|
|
const looksLikeRegistry =
|
|
firstPart.includes('.') || firstPart.includes(':') || firstPart === 'localhost';
|
|
|
|
if (looksLikeRegistry) {
|
|
// Strip registry: "registry.example.com/repo:version" -> "repo:version"
|
|
return parts.slice(1).join('/');
|
|
}
|
|
|
|
// No registry prefix, could be "org/repo:version"
|
|
return imageRef;
|
|
}
|
|
|
|
/**
|
|
* Returns the docker tag string for a given registry and repo
|
|
*/
|
|
public static getDockerTagString(
|
|
managerRef: TsDockerManager,
|
|
registryArg: string,
|
|
repoArg: string,
|
|
versionArg: string,
|
|
suffixArg?: string
|
|
): string {
|
|
// Determine whether the repo should be mapped according to the registry
|
|
const config = managerRef.config;
|
|
const mappedRepo = config.registryRepoMap?.[registryArg];
|
|
const repo = mappedRepo || repoArg;
|
|
|
|
// Determine whether the version contains a suffix
|
|
let version = versionArg;
|
|
if (suffixArg) {
|
|
version = versionArg + '_' + suffixArg;
|
|
}
|
|
|
|
const tagString = `${registryArg}/${repo}:${version}`;
|
|
return tagString;
|
|
}
|
|
|
|
/**
|
|
* Gets build args from environment variable mapping
|
|
*/
|
|
public static async getDockerBuildArgs(managerRef: TsDockerManager): Promise<string> {
|
|
logger.log('info', 'checking for env vars to be supplied to the docker build');
|
|
let buildArgsString: string = '';
|
|
const config = managerRef.config;
|
|
|
|
if (config.buildArgEnvMap) {
|
|
for (const dockerArgKey of Object.keys(config.buildArgEnvMap)) {
|
|
const dockerArgOuterEnvVar = config.buildArgEnvMap[dockerArgKey];
|
|
logger.log(
|
|
'note',
|
|
`docker ARG "${dockerArgKey}" maps to outer env var "${dockerArgOuterEnvVar}"`
|
|
);
|
|
const targetValue = process.env[dockerArgOuterEnvVar];
|
|
if (targetValue) {
|
|
buildArgsString = `${buildArgsString} --build-arg ${dockerArgKey}="${targetValue}"`;
|
|
}
|
|
}
|
|
}
|
|
return buildArgsString;
|
|
}
|
|
|
|
// INSTANCE PROPERTIES
|
|
public managerRef: TsDockerManager;
|
|
public filePath!: string;
|
|
public repo: string;
|
|
public version: string;
|
|
public cleanTag: string;
|
|
public buildTag: string;
|
|
public pushTag!: string;
|
|
public containerName: string;
|
|
public content!: string;
|
|
public baseImage: string;
|
|
public localBaseImageDependent: boolean;
|
|
public localBaseDockerfile!: Dockerfile;
|
|
public localRegistryTag?: string;
|
|
|
|
constructor(managerRefArg: TsDockerManager, options: IDockerfileOptions) {
|
|
this.managerRef = managerRefArg;
|
|
this.filePath = options.filePath!;
|
|
|
|
// Build repo name from project info or directory name
|
|
const projectInfo = this.managerRef.projectInfo;
|
|
if (projectInfo?.npm?.name) {
|
|
// Use package name, removing scope if present
|
|
const packageName = projectInfo.npm.name.replace(/^@[^/]+\//, '');
|
|
this.repo = packageName;
|
|
} else {
|
|
// Fallback to directory name
|
|
this.repo = plugins.path.basename(paths.cwd);
|
|
}
|
|
|
|
this.version = Dockerfile.dockerFileVersion(this, plugins.path.parse(this.filePath).base);
|
|
this.cleanTag = this.repo + ':' + this.version;
|
|
this.buildTag = this.cleanTag;
|
|
this.containerName = 'dockerfile-' + this.version;
|
|
|
|
if (options.filePath && options.read) {
|
|
this.content = fs.readFileSync(plugins.path.resolve(options.filePath), 'utf-8');
|
|
} else if (options.fileContents) {
|
|
this.content = options.fileContents;
|
|
}
|
|
|
|
this.baseImage = Dockerfile.dockerBaseImage(this.content);
|
|
this.localBaseImageDependent = false;
|
|
}
|
|
|
|
/**
|
|
* Builds the Dockerfile
|
|
*/
|
|
public async build(options?: { platform?: string; timeout?: number; noCache?: boolean; verbose?: boolean }): Promise<number> {
|
|
const startTime = Date.now();
|
|
const buildArgsString = await Dockerfile.getDockerBuildArgs(this.managerRef);
|
|
const config = this.managerRef.config;
|
|
const platformOverride = options?.platform;
|
|
const timeout = options?.timeout;
|
|
const noCacheFlag = options?.noCache ? ' --no-cache' : '';
|
|
const verbose = options?.verbose ?? false;
|
|
|
|
let buildContextFlag = '';
|
|
if (this.localBaseImageDependent && this.localBaseDockerfile) {
|
|
const fromImage = this.baseImage;
|
|
if (this.localBaseDockerfile.localRegistryTag) {
|
|
// BuildKit pulls from the local registry (reachable via host network)
|
|
const registryTag = this.localBaseDockerfile.localRegistryTag;
|
|
buildContextFlag = ` --build-context "${fromImage}=docker-image://${registryTag}"`;
|
|
logger.log('info', `Using local registry build context: ${fromImage} -> docker-image://${registryTag}`);
|
|
}
|
|
}
|
|
|
|
let buildCommand: string;
|
|
|
|
if (platformOverride) {
|
|
// Single platform override via buildx
|
|
buildCommand = `docker buildx build --platform ${platformOverride}${noCacheFlag}${buildContextFlag} --load -t ${this.buildTag} -f ${this.filePath} ${buildArgsString} .`;
|
|
logger.log('info', `Build: buildx --platform ${platformOverride} --load`);
|
|
} else if (config.platforms && config.platforms.length > 1) {
|
|
// Multi-platform build using buildx
|
|
const platformString = config.platforms.join(',');
|
|
buildCommand = `docker buildx build --platform ${platformString}${noCacheFlag}${buildContextFlag} -t ${this.buildTag} -f ${this.filePath} ${buildArgsString} .`;
|
|
|
|
if (config.push) {
|
|
buildCommand += ' --push';
|
|
logger.log('info', `Build: buildx --platform ${platformString} --push`);
|
|
} else {
|
|
buildCommand += ' --load';
|
|
logger.log('info', `Build: buildx --platform ${platformString} --load`);
|
|
}
|
|
} else {
|
|
// Standard build
|
|
const versionLabel = this.managerRef.projectInfo?.npm?.version || 'unknown';
|
|
buildCommand = `docker build --label="version=${versionLabel}"${noCacheFlag} -t ${this.buildTag} -f ${this.filePath} ${buildArgsString} .`;
|
|
logger.log('info', 'Build: docker build (standard)');
|
|
}
|
|
|
|
if (timeout) {
|
|
// Use streaming execution with timeout
|
|
const streaming = verbose
|
|
? await smartshellInstance.execStreaming(buildCommand)
|
|
: await smartshellInstance.execStreamingSilent(buildCommand);
|
|
const timeoutPromise = new Promise<never>((_, reject) => {
|
|
setTimeout(() => {
|
|
streaming.childProcess.kill();
|
|
reject(new Error(`Build timed out after ${timeout}s for ${this.cleanTag}`));
|
|
}, timeout * 1000);
|
|
});
|
|
const result = await Promise.race([streaming.finalPromise, timeoutPromise]);
|
|
if (result.exitCode !== 0) {
|
|
logger.log('error', `Build failed for ${this.cleanTag}`);
|
|
throw new Error(`Build failed for ${this.cleanTag}`);
|
|
}
|
|
} else {
|
|
const result = verbose
|
|
? await smartshellInstance.exec(buildCommand)
|
|
: await smartshellInstance.execSilent(buildCommand);
|
|
if (result.exitCode !== 0) {
|
|
logger.log('error', `Build failed for ${this.cleanTag}`);
|
|
if (!verbose && result.stdout) {
|
|
logger.log('error', `Build output:\n${result.stdout}`);
|
|
}
|
|
throw new Error(`Build failed for ${this.cleanTag}`);
|
|
}
|
|
}
|
|
|
|
return Date.now() - startTime;
|
|
}
|
|
|
|
/**
|
|
* Pushes the Dockerfile to a registry
|
|
*/
|
|
public async push(dockerRegistryArg: DockerRegistry, versionSuffix?: string): Promise<void> {
|
|
this.pushTag = Dockerfile.getDockerTagString(
|
|
this.managerRef,
|
|
dockerRegistryArg.registryUrl,
|
|
this.repo,
|
|
this.version,
|
|
versionSuffix
|
|
);
|
|
|
|
await smartshellInstance.exec(`docker tag ${this.buildTag} ${this.pushTag}`);
|
|
const pushResult = await smartshellInstance.exec(`docker push ${this.pushTag}`);
|
|
|
|
if (pushResult.exitCode !== 0) {
|
|
logger.log('error', `Push failed for ${this.pushTag}`);
|
|
throw new Error(`Push failed for ${this.pushTag}`);
|
|
}
|
|
|
|
// Get image digest
|
|
const inspectResult = await smartshellInstance.exec(
|
|
`docker inspect --format="{{index .RepoDigests 0}}" ${this.pushTag}`
|
|
);
|
|
|
|
if (inspectResult.exitCode === 0 && inspectResult.stdout.includes('@')) {
|
|
const imageDigest = inspectResult.stdout.split('@')[1]?.trim();
|
|
logger.log('info', `The image ${this.pushTag} has digest ${imageDigest}`);
|
|
}
|
|
|
|
logger.log('ok', `Pushed ${this.pushTag}`);
|
|
}
|
|
|
|
/**
|
|
* Pulls the Dockerfile from a registry
|
|
*/
|
|
public async pull(registryArg: DockerRegistry, versionSuffixArg?: string): Promise<void> {
|
|
const pullTag = Dockerfile.getDockerTagString(
|
|
this.managerRef,
|
|
registryArg.registryUrl,
|
|
this.repo,
|
|
this.version,
|
|
versionSuffixArg
|
|
);
|
|
|
|
await smartshellInstance.exec(`docker pull ${pullTag}`);
|
|
await smartshellInstance.exec(`docker tag ${pullTag} ${this.buildTag}`);
|
|
|
|
logger.log('ok', `Pulled and tagged ${pullTag} as ${this.buildTag}`);
|
|
}
|
|
|
|
/**
|
|
* Tests the Dockerfile by running a test script if it exists
|
|
*/
|
|
public async test(): Promise<number> {
|
|
const startTime = Date.now();
|
|
const testDir = this.managerRef.config.testDir || plugins.path.join(paths.cwd, 'test');
|
|
const testFile = plugins.path.join(testDir, 'test_' + this.version + '.sh');
|
|
|
|
const testFileExists = fs.existsSync(testFile);
|
|
|
|
if (testFileExists) {
|
|
// Run tests in container
|
|
await smartshellInstance.exec(
|
|
`docker run --name tsdocker_test_container --entrypoint="bash" ${this.buildTag} -c "mkdir /tsdocker_test"`
|
|
);
|
|
await smartshellInstance.exec(`docker cp ${testFile} tsdocker_test_container:/tsdocker_test/test.sh`);
|
|
await smartshellInstance.exec(`docker commit tsdocker_test_container tsdocker_test_image`);
|
|
|
|
const testResult = await smartshellInstance.exec(
|
|
`docker run --entrypoint="bash" tsdocker_test_image -x /tsdocker_test/test.sh`
|
|
);
|
|
|
|
// Cleanup
|
|
await smartshellInstance.exec(`docker rm tsdocker_test_container`);
|
|
await smartshellInstance.exec(`docker rmi --force tsdocker_test_image`);
|
|
|
|
if (testResult.exitCode !== 0) {
|
|
throw new Error(`Tests failed for ${this.cleanTag}`);
|
|
}
|
|
} else {
|
|
logger.log('warn', `Skipping tests for ${this.cleanTag} — no test file at ${testFile}`);
|
|
}
|
|
|
|
return Date.now() - startTime;
|
|
}
|
|
|
|
/**
|
|
* Gets the ID of a built Docker image
|
|
*/
|
|
public async getId(): Promise<string> {
|
|
const result = await smartshellInstance.exec(
|
|
'docker inspect --type=image --format="{{.Id}}" ' + this.buildTag
|
|
);
|
|
return result.stdout.trim();
|
|
}
|
|
}
|