io.fabric8.maven.docker.config.BuildImageConfiguration Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of docker-maven-plugin Show documentation
Docker Maven Plugin
The newest version!
package io.fabric8.maven.docker.config;

import java.io.File;
import java.util.*;

import io.fabric8.maven.docker.util.EnvUtil;
import io.fabric8.maven.docker.util.Logger;
import io.fabric8.maven.docker.util.MojoParameters;

/**
 * @author roland
 * @since 02.09.14
 */
public class BuildImageConfiguration {

    /**
     * Directory holding an external Dockerfile which is used to build the
     * image. This Dockerfile will be enriched by the addition build configuration
     *
     * @parameter
     */
    private String dockerFileDir;

    /**
     * Path to a dockerfile to use. Its parent directory is used as build context (i.e. as dockerFileDir).
     * Multiple different Dockerfiles can be specified that way. If set overwrites a possibly givem
     * dockerFileDir
     *
     * @parameter
     */
    private String dockerFile;

    // Base Image name of the data image to use.
    /**
     * @parameter
     */
    private String from;

    /**
     * @parameter
     */
    private String registry;

    /**
     * @parameter
     */
    private String maintainer;

    /**
     * @parameter
     */
    private List ports;

    /**
     * RUN Commands within Build/Image
     * @parameter
     */
    private List runCmds;

    /**
     * @parameter default-value="try"
     */
    private String cleanup = "try";

    /**
     * @parameter default-value="false"
     */
    private boolean nocache = false;

    /**
     * @parameter default-value="false"
     */
    private boolean optimise = false;

    /**
     * @parameter
     */
    private List volumes;

    /**
     * @parameter
     */
    private List tags;
    
    /**
     * @parameter
     */
    private Map env;

    /**
     * @parameter
     */
    private Map labels;

    /**
     * @parameter
     */
    private Map args;

    /**
     * @parameter
     */
    private Arguments entryPoint;

    /**
     * @parameter
     * @deprecated
     */
    private String command;

    /**
     * @parameter
     */
    private String workdir;

    /**
     * @parameter
     */
    private Arguments cmd;

    /**
     * @parameter
     */
    private AssemblyConfiguration assembly;

    /**
     * @parameter
     */
    private boolean skip = false;

    /**
     * @parameter
     */
    private BuildTarArchiveCompression compression = BuildTarArchiveCompression.none;

    // Path to Dockerfile to use, initialized lazily ....
    File dockerFileFile;
    private boolean dockerFileMode;

    public BuildImageConfiguration() {}

    public boolean isDockerFileMode() {
        return dockerFileMode;
    }

    public File getDockerFile() {
        return dockerFileFile;
    }

    public String getFrom() {
        return from;
    }

    public String getRegistry() {
        return registry;
    }

    public String getMaintainer() {
        return maintainer;
    }

    public String getWorkdir() {
        return workdir;
    }

    public AssemblyConfiguration getAssemblyConfiguration() {
        return assembly;
    }

    public List getPorts() {
        return ports;
    }

    public List getVolumes() {
        return volumes != null ? volumes : Collections.emptyList();
    }

    public List getTags() {
        return tags != null ? tags : Collections.emptyList();
    }

    public Map getEnv() {
        return env;
    }

    public Map getLabels() {
        return labels;
    }

    public Arguments getCmd() {
        return cmd;
    }

    @Deprecated
    public String getCommand() {
        return command;
    }
    
    public CleanupMode cleanupMode() {
        return CleanupMode.parse(cleanup);
    }

    public boolean nocache() {
        return nocache;
    }

    public boolean optimise() {
        return optimise;
    }

    public boolean skip() {
        return skip;
    }

    public BuildTarArchiveCompression getCompression() {
        return compression;
    }

    public Arguments getEntryPoint() {
        return entryPoint;
    }

    public List getRunCmds() {
        return runCmds;
    }

    public Map getArgs() {
        return args;
    }

    public File getAbsoluteDockerFilePath(MojoParameters mojoParams) {
        return EnvUtil.prepareAbsoluteSourceDirPath(mojoParams, getDockerFile().getPath());
    }

    public static class Builder {
        private final BuildImageConfiguration config = new BuildImageConfiguration();

        public Builder dockerFileDir(String dir) {
            config.dockerFileDir = dir;
            return this;
        }

        public Builder dockerFile(String file) {
            config.dockerFile = file;
            return this;
        }

        public Builder from(String from) {
            config.from = from;
            return this;
        }

        public Builder registry(String registry) {
            config.registry = registry;
            return this;
        }

        public Builder maintainer(String maintainer) {
            config.maintainer = maintainer;
            return this;
        }

        public Builder workdir(String workdir) {
            config.workdir = workdir;
            return this;
        }

        public Builder assembly(AssemblyConfiguration assembly) {
            config.assembly = assembly;
            return this;
        }
        
        public Builder ports(List ports) {
            config.ports = ports;
            return this;
        }

        public Builder runCmds(List theCmds) {
            if (config.runCmds == null) {
                config.runCmds = new ArrayList<>();
            }
            else
            	config.runCmds = theCmds;
            return this;
        }
        
        public Builder volumes(List volumes) {
            config.volumes = volumes;
            return this;
        }
        
        public Builder tags(List tags) {
            config.tags = tags;
            return this;
        }

        public Builder env(Map env) {
            config.env = env;
            return this;
        }

        public Builder args(Map args) {
            config.args = args;
            return this;
        }

        public Builder labels(Map labels) {
            config.labels = labels;
            return this;
        }

        public Builder cmd(String cmd) {
            if (config.cmd == null) {
                config.cmd = new Arguments();
            }
            config.cmd.setShell(cmd);
            return this;
        }
        
        public Builder cleanup(String cleanup) { 
            config.cleanup = cleanup;
            return this;
        }

        public Builder nocache(String nocache) {
            if (nocache != null) {
                config.nocache = Boolean.valueOf(nocache);
            }
            return this;
        }

        public Builder optimise(String optimise) {
            if (optimise != null) {
                config.optimise = Boolean.valueOf(optimise);
            }
            return this;
        }

        public Builder entryPoint(String entryPoint) {
            if (config.entryPoint == null) {
                config.entryPoint = new Arguments();
            }
            config.entryPoint.setShell(entryPoint);
            return this;
        }
        
        public Builder skip(String skip) {
            if (skip != null) {
                config.skip = Boolean.valueOf(skip);
            }
            return this;
        }

        public BuildImageConfiguration build() {
            return config;
        }
    }

    public String initAndValidate(Logger log) throws IllegalArgumentException {
        if (entryPoint != null) {
            entryPoint.validate();
        }
        if (cmd != null) {
            cmd.validate();
        }

        if (command != null) {
            log.warn(" in the  configuration is deprecated and will be be removed soon");
            log.warn("Please use  with nested  or  sections instead.");
            log.warn("");
            log.warn("More on this is explained in the user manual: ");
            log.warn("https://github.com/fabric8io/docker-maven-plugin/blob/master/doc/manual.md#start-up-arguments");
            log.warn("");
            log.warn("Migration is trivial, see changelog to version 0.12.0 -->");
            log.warn("https://github.com/fabric8io/docker-maven-plugin/blob/master/doc/changelog.md");
            log.warn("");
            log.warn("For now, the command is automatically translated for you to the shell form:");
            log.warn("   " + command + "");
        }

        initDockerFileFile(log);

        if (args != null) {
            // ARG support came in later
            return "1.21";
        } else {
            return null;
        }
    }

    // Initialize the dockerfile location and the build mode
    private void initDockerFileFile(Logger log) {
        if (dockerFile != null) {
            dockerFileFile = new File(dockerFile);
            dockerFileMode = true;
        } else if (dockerFileDir != null) {
            dockerFileFile = new File(dockerFileDir, "Dockerfile");
            dockerFileMode = true;
        } else {
            String deprecatedDockerFileDir = getAssemblyConfiguration() != null ?
                getAssemblyConfiguration().getDockerFileDir() :
                null;
            if (deprecatedDockerFileDir != null) {
                log.warn(" in the  section of a  configuration is deprecated");
                log.warn("Please use  or  directly within the  configuration instead");
                dockerFileFile = new File(deprecatedDockerFileDir,"Dockerfile");
                dockerFileMode = true;
            } else {
                dockerFileMode = false;
            }
        }
    }
}