Environment.java

/*
 * Copyright 2020 the original author or authors.
 *
 * 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.
 */
package org.mvndaemon.mvnd.common;

import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.Duration;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.Properties;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Collects system properties and environment variables used by mvnd client or server.
 *
 * Duration properties such as {@link #MVND_IDLE_TIMEOUT}, {@link #MVND_KEEP_ALIVE},
 * {@link #MVND_EXPIRATION_CHECK_DELAY} or {@link #MVND_LOG_PURGE_PERIOD} are expressed
 * in a human readable format such as <code>2h30m</code>, <code>600ms</code> or <code>10 seconds</code>.
 * The available units are <i>d/day/days</i>, <i>h/hour/hours</i>, <i>m/min/minute/minutes</i>,
 * <i>s/sec/second/seconds</i> and <i>ms/millis/msec/milliseconds</i>.
 */
public enum Environment {

    /**
     * Print the completion for the given shell to stdout. Only <code>--completion bash</code> is supported at this time.
     */
    COMPLETION(null, null, null, OptionType.STRING, Flags.OPTIONAL, "mvnd:--completion"),
    /**
     * Delete log files under the <code>mvnd.registry</code> directory that are older than <code>mvnd.logPurgePeriod</code>
     */
    PURGE(null, null, null, OptionType.VOID, Flags.OPTIONAL, "mvnd:--purge"),
    /** Prints the status of daemon instances registered in the registry specified by <code>mvnd.registry</code> */
    STATUS(null, null, null, OptionType.VOID, Flags.OPTIONAL, "mvnd:--status"),
    /** Stop all daemon instances registered in the registry specified by <code>mvnd.registry</code> */
    STOP(null, null, null, OptionType.VOID, Flags.OPTIONAL, "mvnd:--stop"),
    /** Use one thread, no log buffering and the default project builder to behave like a standard maven */
    SERIAL("mvnd.serial", null, Boolean.FALSE, OptionType.VOID, Flags.OPTIONAL, "mvnd:-1", "mvnd:--serial"),

    //
    // Log properties
    //

    /**
     * The location of the Logback configuration file the daemon should use to configure its logging.
     */
    MVND_LOGBACK("mvnd.logback", null, null, OptionType.PATH, Flags.NONE),
    /** The system property expected by logback to set the configuration file */
    LOGBACK_CONFIGURATION_FILE("logback.configurationFile", null, null, OptionType.PATH, Flags.INTERNAL),

    //
    // System properties
    //
    /** Java home for starting the daemon */
    JAVA_HOME("java.home", "JAVA_HOME", null, OptionType.PATH, Flags.NONE),
    /**
     * The daemon installation directory. The client normally sets this according to where its <code>mvnd</code>
     * executable is located
     */
    MVND_HOME("mvnd.home", "MVND_HOME", null, OptionType.PATH, Flags.NONE),
    /** The user home directory */
    USER_HOME("user.home", null, null, OptionType.PATH, Flags.NONE),
    /** The current working directory */
    USER_DIR("user.dir", null, null, OptionType.PATH, Flags.NONE),
    /** The JDK_JAVA_OPTIONS option */
    JDK_JAVA_OPTIONS("jdk.java.options", "JDK_JAVA_OPTIONS", "", OptionType.STRING, Flags.DISCRIMINATING) {

    },

    //
    // Maven properties
    //
    /** The path to the Maven local repository */
    MAVEN_REPO_LOCAL("maven.repo.local", null, null, OptionType.PATH, Flags.NONE),
    /** The location of the maven settings file */
    MAVEN_SETTINGS("maven.settings", null, null, OptionType.PATH, Flags.NONE, "mvn:-s", "mvn:--settings"),
    /** The pom or directory to build */
    MAVEN_FILE(null, null, null, OptionType.PATH, Flags.NONE, "mvn:-f", "mvn:--file"),
    /** The root directory of the current multi module Maven project */
    MAVEN_MULTIMODULE_PROJECT_DIRECTORY("maven.multiModuleProjectDirectory", null, null, OptionType.PATH, Flags.NONE),
    /** Log file */
    MAVEN_LOG_FILE(null, null, null, OptionType.PATH, Flags.INTERNAL, "mvn:-l", "mvn:--log-file"),
    /** Batch mode */
    MAVEN_BATCH_MODE(null, null, null, OptionType.BOOLEAN, Flags.INTERNAL, "mvn:-B", "mvn:--batch-mode"),
    /** Debug */
    MAVEN_DEBUG(null, null, null, OptionType.BOOLEAN, Flags.INTERNAL, "mvn:-X", "mvn:--debug"),
    /** Version */
    MAVEN_VERSION(null, null, null, OptionType.BOOLEAN, Flags.INTERNAL, "mvn:-v", "mvn:-version", "mvn:--version"),
    /** Show version */
    MAVEN_SHOW_VERSION(null, null, null, OptionType.BOOLEAN, Flags.INTERNAL, "mvn:-V", "mvn:--show-version"),
    /** Define */
    MAVEN_DEFINE(null, null, null, OptionType.STRING, Flags.INTERNAL, "mvn:-D", "mvn:--define"),
    /** Whether the output should be styled using ANSI color codes; possible values: auto, always, never */
    MAVEN_COLOR("style.color", null, "auto", OptionType.STRING, Flags.OPTIONAL, "mvnd:--color"),

    //
    // mvnd properties
    //

    /**
     * The location of the user supplied <code>mvnd.properties</code> file.
     */
    MVND_PROPERTIES_PATH("mvnd.propertiesPath", "MVND_PROPERTIES_PATH", null, OptionType.PATH, Flags.NONE),
    /**
     * The directory under which the daemon stores its registry, log files, etc.
     * Default: <code>${user.home}/.m2/mvnd</code>
     */
    MVND_DAEMON_STORAGE("mvnd.daemonStorage", null, null, OptionType.PATH, Flags.NONE),
    /**
     * The path to the daemon registry.
     * Default: <code>${mvnd.daemonStorage}/registry.bin</code>
     */
    MVND_REGISTRY("mvnd.registry", null, null, OptionType.PATH, Flags.NONE),
    /**
     * If <code>true</code> the log messages are displayed continuously like with stock Maven; otherwise buffer the
     * messages and output at the end of the build, grouped by module. Passing <code>-B</code> or
     * <code>--batch-mode</code> on the command line enables this too for the given build.
     */
    MVND_NO_BUFERING("mvnd.noBuffering", null, Boolean.FALSE, OptionType.BOOLEAN, Flags.NONE),
    /**
     * The number of log lines to display for each Maven module that is built in parallel. The value can be increased
     * or decreased by pressing + or - key during the build respectively. This option has no effect with
     * <code>-Dmvnd.noBuffering=true</code>, <code>-B</code> or <code>--batch-mode</code>.
     */
    MVND_ROLLING_WINDOW_SIZE("mvnd.rollingWindowSize", null, "0", OptionType.INTEGER, Flags.NONE),
    /**
     * Daemon log files older than this value will be removed automatically.
     */
    MVND_LOG_PURGE_PERIOD("mvnd.logPurgePeriod", null, "7 days", OptionType.DURATION, Flags.NONE),
    /**
     * If <code>true</code>, the client and daemon will run in the same JVM that exits when the build is finished;
     * otherwise the client starts/connects to a long living daemon process. This option is only available with
     * non-native clients and is useful mostly for debugging.
     */
    MVND_NO_DAEMON("mvnd.noDaemon", "MVND_NO_DAEMON", Boolean.FALSE, OptionType.BOOLEAN, Flags.DISCRIMINATING),
    /**
     * If <code>true</code>, the daemon will be launched in debug mode with the following JVM argument:
     * <code>-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=8000</code>; otherwise the debug argument is
     * not passed to the daemon.
     */
    MVND_DEBUG("mvnd.debug", null, Boolean.FALSE, OptionType.BOOLEAN, Flags.DISCRIMINATING),
    /**
     * A time period after which an unused daemon will terminate by itself.
     */
    MVND_IDLE_TIMEOUT("mvnd.idleTimeout", null, "3 hours", OptionType.DURATION, Flags.DISCRIMINATING),
    /**
     * If the daemon does not send any message to the client in this period of time, send a keep-alive message so that
     * the client knows that the daemon is still alive.
     */
    MVND_KEEP_ALIVE("mvnd.keepAlive", null, "100 ms", OptionType.DURATION, Flags.DISCRIMINATING),
    /**
     * The maximum number of keep alive messages that can be missed by the client before the client considers the daemon
     * to be dead.
     */
    MVND_MAX_LOST_KEEP_ALIVE("mvnd.maxLostKeepAlive", null, 30, OptionType.INTEGER, Flags.NONE),
    /**
     * The minimum number of threads to use when constructing the default <code>-T</code> parameter for the daemon.
     * This value is ignored if the user passes <code>-T</code>, <code>--threads</code> or <code>-Dmvnd.threads</code>
     * on the command line or if he sets <code>mvnd.threads</code> in <code>~/.m2/mvnd.properties</code>.
     */
    MVND_MIN_THREADS("mvnd.minThreads", null, 1, OptionType.INTEGER, Flags.NONE),
    /**
     * The number of threads to pass to the daemon; same syntax as Maven's <code>-T</code>/<code>--threads</code>
     * option.
     */
    MVND_THREADS("mvnd.threads", null, null, OptionType.STRING, Flags.NONE, "mvn:-T", "mvn:--threads"),
    /**
     * The builder implementation the daemon should use
     */
    MVND_BUILDER("mvnd.builder", null, "smart", OptionType.STRING, Flags.NONE, "mvn:-b", "mvn:--builder"),
    /**
     * An ID for a newly started daemon
     */
    MVND_ID("mvnd.id", null, null, OptionType.STRING, Flags.INTERNAL),
    /**
     * Internal option to specify the maven extension classpath
     */
    MVND_EXT_CLASSPATH("mvnd.extClasspath", null, null, OptionType.STRING, Flags.DISCRIMINATING | Flags.INTERNAL),
    /**
     * Internal option to specify the list of maven extension to register
     */
    MVND_CORE_EXTENSIONS("mvnd.coreExtensions", null, null, OptionType.STRING, Flags.DISCRIMINATING | Flags.INTERNAL),
    /**
     * The <code>-Xms</code> value to pass to the daemon
     */
    MVND_MIN_HEAP_SIZE("mvnd.minHeapSize", null, "128M", OptionType.MEMORY_SIZE, Flags.DISCRIMINATING),
    /**
     * The <code>-Xmx</code> value to pass to the daemon
     */
    MVND_MAX_HEAP_SIZE("mvnd.maxHeapSize", null, "2G", OptionType.MEMORY_SIZE, Flags.DISCRIMINATING),
    /**
     * The <code>-Xss</code> value to pass to the daemon
     */
    MVND_THREAD_STACK_SIZE("mvnd.threadStackSize", null, "1M", OptionType.MEMORY_SIZE, Flags.DISCRIMINATING),
    /**
     * Additional JVM args to pass to the daemon
     */
    MVND_JVM_ARGS("mvnd.jvmArgs", null, null, OptionType.STRING, Flags.DISCRIMINATING | Flags.OPTIONAL),
    /**
     * If <code>true</code>, the <code>-ea</code> option will be passed to the daemon; otherwise the <code>-ea</code>
     * option is not passed to the daemon.
     */
    MVND_ENABLE_ASSERTIONS("mvnd.enableAssertions", null, Boolean.FALSE, OptionType.BOOLEAN, Flags.DISCRIMINATING),
    /**
     * The daemon will check this often whether it should exit.
     */
    MVND_EXPIRATION_CHECK_DELAY("mvnd.expirationCheckDelay", null, "10 seconds", OptionType.DURATION, Flags.DISCRIMINATING),
    /**
     * Period after which idle duplicate daemons will be shut down. Duplicate daemons are daemons with the same set of
     * discriminating start parameters.
     */
    MVND_DUPLICATE_DAEMON_GRACE_PERIOD("mvnd.duplicateDaemonGracePeriod", null, "10 seconds", OptionType.DURATION,
            Flags.DISCRIMINATING),
    /**
     * Internal property to tell the daemon the width of the terminal
     */
    MVND_TERMINAL_WIDTH("mvnd.terminalWidth", null, 0, OptionType.INTEGER, Flags.INTERNAL),
    /**
     * Internal property to tell the daemon which JAVA_HOME was used to start it. It needs to be passed explicitly
     * because the value may differ from what the daemon sees through <code>System.getProperty("java.home")</code>.
     */
    MVND_JAVA_HOME("mvnd.java.home", null, null, OptionType.PATH, Flags.INTERNAL),
    /**
     * Log mojos execution time at the end of the build.
     */
    MVND_BUILD_TIME("mvnd.buildTime", null, null, OptionType.BOOLEAN, Flags.NONE),
    /**
     * Socket family to use
     */
    MVND_SOCKET_FAMILY("mvnd.socketFamily", null, "inet", OptionType.STRING, Flags.DISCRIMINATING),
    /**
     * Pattern that will force eviction of the plugin realms if one of its dependencies matches.
     * The overall pattern is a comma separated list of:<ul>
     *   <li>a glob pattern starting with <code>glob:</code> (the default syntax if no scheme is specified)</li>
     *   <li>a regex pattern starting with <code>regex:</code></li>
     *   <li>a maven expression, either <code>mvn:[groupId]:[artifactId]:[version]</code>,
     *      <code>mvn:[groupId]:[artifactId]</code> or <code>mvn:[artifactId]</code></li>
     * </ul>
     * This pattern will be evaluated against the full path of the dependencies, so it is usually desirable to
     * start with <code>"glob:**{@literal /}"</code> to support any location of the local repository.
     */
    MVND_PLUGIN_REALM_EVICT_PATTERN("mvnd.pluginRealmEvictPattern", null, "", OptionType.STRING, Flags.OPTIONAL),
    /**
     * The SyncContextFactory to use (can be either 'noop' or 'ipc' for a server-wide factory).
     */
    MVND_SYNC_CONTEXT_FACTORY("mvnd.syncContextFactory", null, "local", OptionType.BOOLEAN, Flags.OPTIONAL);

    static Properties properties;

    public static void setProperties(Properties properties) {
        Environment.properties = properties;
    }

    public static String getProperty(String property) {
        Properties props = Environment.properties;
        if (props == null) {
            props = System.getProperties();
        }
        return props.getProperty(property);
    }

    private final String property;
    private final String environmentVariable;
    private final String default_;
    private final int flags;
    private final OptionType type;
    private final Map<String, OptionOrigin> options;

    Environment(String property, String environmentVariable, Object default_, OptionType type, int flags,
            String... options) {
        if (property == null && options.length == 0) {
            throw new IllegalArgumentException(
                    "An " + Environment.class.getSimpleName() + " entry must have property or options set");
        }
        this.property = property;
        this.environmentVariable = environmentVariable;
        this.default_ = default_ != null ? default_.toString() : null;
        this.flags = flags;
        this.type = type;
        if (options.length == 0) {
            this.options = Collections.emptyMap();
        } else {
            final Map<String, OptionOrigin> optMap = new LinkedHashMap<>();
            for (String opt : options) {
                OPTION_ORIGIN_SEARCH: {
                    for (OptionOrigin oo : OptionOrigin.values()) {
                        if (opt.startsWith(oo.prefix)) {
                            optMap.put(opt.substring(oo.prefix.length()), oo);
                            break OPTION_ORIGIN_SEARCH;
                        }
                    }
                    throw new IllegalArgumentException(
                            "Unexpected option prefix: '" + opt + "'; Options should start with any of "
                                    + Stream.of(OptionOrigin.values()).map(oo -> oo.prefix).collect(Collectors.joining(",")));
                }
            }
            this.options = Collections.unmodifiableMap(optMap);
        }
    }

    public String getProperty() {
        return property;
    }

    public String getEnvironmentVariable() {
        return environmentVariable;
    }

    public String getDefault() {
        return default_;
    }

    public Set<String> getOptions() {
        return options.keySet();
    }

    public Map<String, OptionOrigin> getOptionMap() {
        return options;
    }

    public OptionType getType() {
        return type;
    }

    public boolean isDiscriminating() {
        return (flags & Flags.DISCRIMINATING) != 0;
    }

    public boolean isInternal() {
        return (flags & Flags.INTERNAL) != 0;
    }

    public boolean isOptional() {
        return (flags & Flags.OPTIONAL) != 0;
    }

    public String asString() {
        String val = getProperty(property);
        if (val == null) {
            throw new IllegalStateException("The system property " + property + " is missing");
        }
        return val;
    }

    public Optional<String> asOptional() {
        String val = getProperty(property);
        if (val != null) {
            return Optional.of(val);
        } else if (isOptional()) {
            return Optional.empty();
        } else {
            throw new IllegalStateException("The system property " + property + " is missing");
        }
    }

    public int asInt() {
        return Integer.parseInt(asString());
    }

    public boolean asBoolean() {
        return Boolean.parseBoolean(asString());
    }

    public Path asPath() {
        String result = asString();
        if (Os.current().isCygwin()) {
            result = cygpath(result);
        }
        return Paths.get(result);
    }

    public Duration asDuration() {
        return TimeUtils.toDuration(asString());
    }

    public String asDaemonOpt(String value) {
        return property + "=" + type.normalize(value);
    }

    public void addCommandLineOption(Collection<String> args, String value) {
        if (!options.isEmpty()) {
            args.add(options.keySet().iterator().next());
            args.add(type.normalize(value));
        } else {
            args.add("-D" + property + "=" + type.normalize(value));
        }
    }

    public boolean hasCommandLineOption(Collection<String> args) {
        final String[] prefixes = getPrefixes();
        return args.stream().anyMatch(arg -> Stream.of(prefixes).anyMatch(arg::startsWith));
    }

    public String getCommandLineOption(Collection<String> args) {
        return getCommandLineOption(args, false);
    }

    public String removeCommandLineOption(Collection<String> args) {
        return getCommandLineOption(args, true);
    }

    String getCommandLineOption(Collection<String> args, boolean remove) {
        final String[] prefixes = getPrefixes();
        String value = null;
        for (Iterator<String> it = args.iterator(); it.hasNext();) {
            String arg = it.next();
            if (Stream.of(prefixes).anyMatch(arg::startsWith)) {
                if (remove) {
                    it.remove();
                }
                if (type == OptionType.VOID) {
                    value = "";
                } else {
                    String opt = Stream.of(prefixes).filter(arg::startsWith)
                            .max(Comparator.comparing(String::length)).get();
                    value = arg.substring(opt.length());
                    if (value.isEmpty()) {
                        if (it.hasNext()) {
                            value = it.next();
                            if (remove) {
                                it.remove();
                            }
                        }
                    } else {
                        if (value.charAt(0) == '=') {
                            value = value.substring(1);
                        }
                    }
                }
            }
        }
        return value;
    }

    private String[] getPrefixes() {
        final String[] prefixes;
        if (options.isEmpty()) {
            prefixes = new String[] { "-D" + property + "=" };
        } else if (property != null) {
            prefixes = new String[options.size() + 1];
            options.keySet().toArray(prefixes);
            prefixes[options.size()] = "-D" + property + "=";
        } else {
            prefixes = options.keySet().toArray(new String[0]);
        }
        return prefixes;
    }

    public static String cygpath(String result) {
        String path = result.replace('/', '\\');
        if (path.matches("\\\\cygdrive\\\\[a-z]\\\\.*")) {
            String s = path.substring("\\cygdrive\\".length());
            result = s.substring(0, 1).toUpperCase(Locale.ENGLISH) + ":" + s.substring(1);
        }
        return result;
    }

    public static boolean isNative() {
        return "executable".equals(System.getProperty("org.graalvm.nativeimage.kind"));
    }

    public static Stream<DocumentedEnumEntry<Environment>> documentedEntries() {
        Properties props = new Properties();
        Environment[] values = values();
        final String cliOptionsPath = values[0].getClass().getSimpleName() + ".javadoc.properties";
        try (InputStream in = Environment.class.getResourceAsStream(cliOptionsPath)) {
            props.load(in);
        } catch (IOException e) {
            throw new RuntimeException("Could not read " + cliOptionsPath, e);
        }
        return Stream.of(values)
                .filter(env -> !env.isInternal())
                .sorted(Comparator.<Environment, String> comparing(env -> env.property != null ? env.property : "")
                        .thenComparing(env -> !env.options.isEmpty() ? env.options.keySet().iterator().next() : ""))
                .map(env -> new DocumentedEnumEntry<>(env, props.getProperty(env.name())));
    }

    public enum OptionOrigin {
        mvn, mvnd;

        private final String prefix;

        private OptionOrigin() {
            this.prefix = name() + ":";
        }
    }

    /**
     * The values of {@link Environment#MAVEN_COLOR} option.
     */
    public enum Color {
        always, never, auto;

        public static Optional<Color> of(String color) {
            return color == null ? Optional.empty() : Optional.of(Color.valueOf(color));
        }
    }

    public static class DocumentedEnumEntry<E> {

        private final E entry;
        private final String javaDoc;

        public DocumentedEnumEntry(E entry, String javaDoc) {
            this.entry = entry;
            this.javaDoc = javaDoc;
        }

        public E getEntry() {
            return entry;
        }

        public String getJavaDoc() {
            return javaDoc;
        }
    }

    static class Flags {
        private static final int NONE = 0b0;
        private static final int DISCRIMINATING = 0b1;
        private static final int INTERNAL = 0b10;
        private static final int OPTIONAL = 0b100;
    }

}