DockerfileStatement.java

package com.github.dockerjava.core.dockerfile;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;

import com.github.dockerjava.api.exception.DockerClientException;
import com.google.common.base.Function;
import com.google.common.base.Objects;
import com.google.common.base.Optional;
import com.google.common.base.Predicate;
import com.google.common.collect.Collections2;

/**
 * A statement present in a dockerfile.
 */
public abstract class DockerfileStatement<T extends DockerfileStatement<?>> {

    private DockerfileStatement() {
    }

    public T transform(Map<String, String> env) {
        return (T) this;
    }

    protected String filterForEnvironmentVars(Map<String, String> environmentMap, String extractedResource) {

        if (environmentMap.size() > 0) {

            String currentResourceContent = extractedResource;

            for (Map.Entry<String, String> entry : environmentMap.entrySet()) {

                String variable = entry.getKey();

                String replacementValue = entry.getValue();

                // handle: $VARIABLE case
                currentResourceContent = currentResourceContent.replaceAll("\\$" + variable,
                        Matcher.quoteReplacement(replacementValue));

                // handle ${VARIABLE} case
                currentResourceContent = currentResourceContent.replaceAll("\\$\\{" + variable + "\\}",
                        Matcher.quoteReplacement(replacementValue));

            }

            return currentResourceContent;
        } else {
            return extractedResource;
        }
    }

    /**
     * A statement that we don't particularly care about.
     */
    public static class OtherLine extends DockerfileStatement {

        public final String statement;

        public OtherLine(String statement) {
            this.statement = statement;
        }

        @Override
        public String toString() {
            return statement;
        }
    }

    /**
     * An ADD or a COPY
     */
    public static class Add extends DockerfileStatement<Add> {

        private static final Pattern ARGUMENT_TOKENIZER = Pattern.compile("(?:\"[^\"]+\")|(\\S+)");

        public final Collection<String> sources;

        public final String destination;

        private Add(Collection<String> sources, String destination) {
            this.sources = sources;
            this.destination = destination;
        }

        @Override
        public Add transform(final Map<String, String> env) {
            Collection<String> resources = Collections2.transform(sources, new Function<String, String>() {
                @Override
                public String apply(String source) {
                    return filterForEnvironmentVars(env, source).trim();
                }
            });
            return new Add(resources, destination);
        }

        public Iterable<String> getFileResources() {
            return Collections2.filter(sources, new Predicate<String>() {

                @Override
                public boolean apply(String source) {
                    URI uri;
                    try {
                        uri = new URI(source);
                    } catch (URISyntaxException e) {
                        return false;
                    }
                    return uri.getScheme() == null || "file".equals(uri.getScheme());
                }
            });
        }

        /**
         * Createa an Add if it matches, or missing if not.
         *
         * @param statement
         *            statement that may be an ADD or a COPY
         * @return optional typed item.
         */
        public static Optional<Add> create(String statement) {
            Matcher argumentMatcher = ARGUMENT_TOKENIZER.matcher(statement.trim());

            if (!argumentMatcher.find()) {
                return Optional.absent();
            }

            String commandName = argumentMatcher.group();
            if (!(StringUtils.equals(commandName, "ADD") || StringUtils.equals(commandName, "COPY"))) {
                return Optional.absent();
            }

            String lastToken = null;
            Collection<String> sources = new ArrayList<>();

            while (argumentMatcher.find()) {
                if (lastToken != null) {
                    sources.add(lastToken);
                }
                lastToken = argumentMatcher.group().replaceAll("(^\")|(\"$)", "");
            }

            if (sources.isEmpty()) {
                throw new DockerClientException("Wrong ADD or COPY format");
            }

            return Optional.of(new Add(sources, lastToken));
        }

        @Override
        public String toString() {
            return Objects.toStringHelper(this).add("sources", sources).add("destination", destination).toString();
        }
    }

    public static class Env extends DockerfileStatement<Env> {

        private static final Pattern ENV_PATTERN = Pattern.compile("^ENV\\s+(.*)\\s+(.*)$");

        public final String variable;

        public final String value;

        private Env(String variable, String value) {
            this.variable = variable;
            this.value = value;
        }

        private Env(Matcher envMatcher) {
            this.variable = envMatcher.group(1).trim();
            this.value = envMatcher.group(2).trim();
        }

        public static Optional<Env> create(String statement) {
            Matcher matcher = ENV_PATTERN.matcher(statement.trim());
            if (!matcher.find()) {
                return Optional.absent();
            }

            if (matcher.groupCount() != 2) {
                throw new DockerClientException("Wrong ENV format");
            }

            return Optional.of(new Env(matcher));
        }

        @Override
        public String toString() {
            return Objects.toStringHelper(this).add("variable", variable).add("value", value).toString();
        }
    }

    /**
     * Return a dockerfile statement
     */
    public static Optional<? extends DockerfileStatement> createFromLine(String cmd) {
        if (cmd.trim().isEmpty() || cmd.startsWith("#")) {
            return Optional.absent();
        }

        Optional<? extends DockerfileStatement> line;

        line = Add.create(cmd);

        if (line.isPresent()) {
            return line;
        }

        line = Env.create(cmd);

        if (line.isPresent()) {
            return line;
        }

        return Optional.of(new OtherLine(cmd));

    }

}