DefaultMagnoliaPropertiesResolver

/**
 * This file Copyright (c) 2011-2018 Magnolia International
 * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
 *
 *
 * This file is dual-licensed under both the Magnolia
 * Network Agreement and the GNU General Public License.
 * You may elect to use one or the other of these licenses.
 *
 * This file is distributed in the hope that it will be
 * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
 * Redistribution, except as permitted by whichever of the GPL
 * or MNA you select, is prohibited.
 *
 * 1. For the GPL license (GPL), you can redistribute and/or
 * modify this file under the terms of the GNU General
 * Public License, Version 3, as published by the Free Software
 * Foundation.  You should have received a copy of the GNU
 * General Public License, Version 3 along with this program;
 * if not, write to the Free Software Foundation, Inc., 51
 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * 2. For the Magnolia Network Agreement (MNA), this file
 * and the accompanying materials are made available under the
 * terms of the MNA which accompanies this distribution, and
 * is available at http://www.magnolia-cms.com/mna.html
 *
 * Any modifications to this file must keep this entire header
 * intact.
 *
 */
package info.magnolia.init;

import static info.magnolia.objectfactory.Components.getComponent;
import static org.apache.commons.collections4.CollectionUtils.isEmpty;
import static org.apache.commons.lang3.StringUtils.substringAfter;

import info.magnolia.init.properties.EnvironmentPropertySource;
import info.magnolia.init.properties.FileSystemPropertySource;
import info.magnolia.init.properties.ServletContextPropertySource;
import info.magnolia.init.properties.SystemPropertySource;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import javax.inject.Inject;
import javax.inject.Singleton;
import javax.servlet.ServletContext;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.text.StringSubstitutor;
import org.apache.commons.text.lookup.StringLookup;

import com.google.common.base.Suppliers;

/**
 * Resolves the paths of the properties files to load. The name of the file can be defined as a context parameter in
 * web.xml. Multiple paths, comma separated, are supported (the first existing file in the list will be used), and the
 * following variables will be used:
 *
 * <ul>
 * <li>{@code ${servername}}: name of the server where the webapp is running, lowercase</li>
 * <li>{@code ${webapp}}: the last token in the webapp path (e.g. {@code magnoliaPublic} for a webapp deployed at
 * {@code tomcat/webapps/magnoliaPublic})</li>
 * <li>{@code ${contextPath}}: the context path of the web application</li>
 * <li>{@code ${systemProperty/*}} is replaced with the corresponding system property</li>
 * <li>{@code ${env/*}} is replaced with the corresponding environment property}</li>
 * <li>{@code ${contextAttribute/*}} is replaced with the corresponding attribute from servlet context</li>
 * <li>{@code ${contextParam/*}} is replaced with the corresponding parameters from servlet context</li>
 * <li>{@code ${*}} is replaced with the corresponding value looked up from the system properties, the environment
 * variables, the context attributes and the context parameters in that order.</li>
 * </ul>
 *
 * <p>
 * If no {@code magnolia.initialization.file} context parameter is set a default is assumed, which depends
 * on the presence of a {@link DefaultMagnoliaPropertiesResolver#MAGNOLIA_PROFILE_ENV MAGNOLIA_PROFILE} environment
 * variable or system property:
 * </p>
 *
 * If {@code MAGNOLIA_PROFILE} is not set {@link DefaultMagnoliaPropertiesResolver#DEFAULT_INITIALIZATION_PARAMETER}
 * is used for a default:
 * <pre>
 * &lt;context-param>
 *   &lt;param-name>magnolia.initialization.file&lt;/param-name>
 *   &lt;param-value>
 *      WEB-INF/config/${servername}/${contextPath}/magnolia.properties,
 *      WEB-INF/config/${servername}/${webapp}/magnolia.properties,
 *      WEB-INF/config/${servername}/magnolia.properties,
 *      WEB-INF/config/${contextPath}/magnolia.properties,
 *      WEB-INF/config/${webapp}/magnolia.properties,
 *      WEB-INF/config/default/magnolia.properties,
 *      WEB-INF/config/magnolia.properties"
 *   &lt;/param-value>
 * &lt;/context-param>
 * </pre>
 *
 * If {@code MAGNOLIA_PROFILE} is set {@link DefaultMagnoliaPropertiesResolver#PROFILE_INITIALIZATION_PARAMETER}
 * is used for a default:
 * <pre>
 * &lt;context-param>
 *   &lt;param-name>magnolia.initialization.file&lt;/param-name>
 *   &lt;param-value>
 *      WEB-INF/config/${MAGNOLIA_PROFILE}/magnolia_${MAGNOLIA_INSTANCE_TYPE}_${MAGNOLIA_STAGE}.properties,"
 *      WEB-INF/config/${MAGNOLIA_PROFILE}/magnolia_${MAGNOLIA_INSTANCE_TYPE}.properties,"
 *      WEB-INF/config/${MAGNOLIA_PROFILE}/magnolia.properties,"
 *      WEB-INF/config/shared/magnolia_${MAGNOLIA_INSTANCE_TYPE}_${MAGNOLIA_STAGE}.properties,"
 *      WEB-INF/config/shared/magnolia_${MAGNOLIA_INSTANCE_TYPE}.properties,"
 *      WEB-INF/config/shared/magnolia.properties,"
 *      WEB-INF/config/default/magnolia_${MAGNOLIA_INSTANCE_TYPE}_${MAGNOLIA_STAGE}.properties,"
 *      WEB-INF/config/default/magnolia_${MAGNOLIA_INSTANCE_TYPE}.properties,"
 *      WEB-INF/config/default/magnolia.properties,"
 *   &lt;/param-value>
 * &lt;/context-param>
 * </pre>
 *
 * <h3>Advanced usage: deployment service</h3>
 *
 * <p>
 * Using the {@code ${servername}} and {@code ${webapp}} properties you can easily bundle in the same webapp
 * different set of configurations which are automatically applied depending on the server name (useful for switching
 * between development, test and production instances where the repository configuration need to be different) or the
 * webapp name (useful to bundle both the public and admin log4j/jndi/bootstrap configuration in the same war).
 * The values for the placeholders are provided by {@link MagnoliaInitPaths}. By default the initializer will try to
 * search for the file in different location with different combination of {@code ${servername}}, {@code ${contextPath}}
 * and {@code ${webapp}} in the following order of precedence:
 * <ol>
 * <li>{@code WEB-INF/config/${servername}/${contextPath}/magnolia.properties}</li>
 * <li>{@code WEB-INF/config/${servername}/${webapp}/magnolia.properties}</li>
 * <li>{@code WEB-INF/config/${servername}/magnolia.properties}</li>
 * <li>{@code WEB-INF/config/${contextPath}/magnolia.properties}</li>
 * <li>{@code WEB-INF/config/${webapp}/magnolia.properties}</li>
 * <li>{@code WEB-INF/config/default/magnolia.properties}</li>
 * <li>{@code WEB-INF/config/magnolia.properties}</li>
 * </ol>
 * </p>
 * <p>
 * <em><b>Deprecation note:</b> this configuration mode is deprecated and will be replaced by profile directories in
 * future versions. See the following section.</em>
 * </p>
 * <br>
 *
 * <h3>Advanced usage: configuration profiles</h3>
 * <p>
 * Alternatively, when the {@code MAGNOLIA_PROFILE} system property or environment variable is set, its value is used to
 * locate a directory at code {@code WEB_INF/config/${MAGNOLIA_PROFILE}}. Property files in that directory, the
 * {@code WEB-INF/config/shared} directory and the {@code WEB-INF/config/default} directory are resolved in the
 * following order of precedence:
 * <ol>
 * <li>{@code WEB-INF/config/${MAGNOLIA_PROFILE}/magnolia_${MAGNOLIA_INSTANCE_TYPE}_${MAGNOLIA_STAGE}.properties}</li>
 * <li>{@code WEB-INF/config/${MAGNOLIA_PROFILE}/magnolia_${MAGNOLIA_INSTANCE_TYPE}.properties}</li>
 * <li>{@code WEB-INF/config/${MAGNOLIA_PROFILE}/magnolia.properties}</li>
 * <li>{@code WEB-INF/config/shared/magnolia_${MAGNOLIA_INSTANCE_TYPE}_${MAGNOLIA_STAGE}.properties}</li>
 * <li>{@code WEB-INF/config/shared/magnolia_${MAGNOLIA_INSTANCE_TYPE}.properties}</li>
 * <li>{@code WEB-INF/config/shared/magnolia.properties}</li>
 * <li>{@code WEB-INF/config/default/magnolia_${MAGNOLIA_INSTANCE_TYPE}_${MAGNOLIA_STAGE}.properties}</li>
 * <li>{@code WEB-INF/config/default/magnolia_${MAGNOLIA_INSTANCE_TYPE}.properties}</li>
 * <li>{@code WEB-INF/config/default/magnolia.properties}</li>
 * </ol>
 * </p>
 *
 */
@Singleton
public class DefaultMagnoliaPropertiesResolver implements MagnoliaPropertiesResolver {
    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(DefaultMagnoliaPropertiesResolver.class);

    /**
     * Context attribute prefix, to obtain a property definition like ${contextAttribute/property}, that can refer to
     * any context attribute.
     */
    public static final String CONTEXT_ATTRIBUTE_PLACEHOLDER_PREFIX = "contextAttribute/";

    /**
     * Context parameter prefix, to obtain a property definition like ${contextParam/property}, that can refer to any
     * context parameter.
     */
    public static final String CONTEXT_PARAM_PLACEHOLDER_PREFIX = "contextParam/";

    /**
     * System property prefix, to obtain a property definition like ${systemProperty/property}, that can refer to any
     * System property.
     */
    public static final String SYSTEM_PROPERTY_PLACEHOLDER_PREFIX = "systemProperty/";

    /**
     * System property prefix, to obtain a property definition like ${systemProperty/property}, that can refer to any
     * System property.
     */
    public static final String ENV_PROPERTY_PLACEHOLDER_PREFIX = "env/";

    /**
     * Context parameter name. Value should be a comma-separated list of paths to look for properties files.
     * Defaults to {@value #DEFAULT_INITIALIZATION_PARAMETER}
     */
    protected static final String MAGNOLIA_INITIALIZATION_FILE = "magnolia.initialization.file";

    /**
     * Default value for the MAGNOLIA_INITIALIZATION_FILE parameter,
     * unless {@link #MAGNOLIA_PROFILE_ENV MAGNOLIA_PROFILE} is set.
     *
     * @deprecated Use {@link #PROFILE_INITIALIZATION_PARAMETER} instead
     */
    @Deprecated
    protected static final String DEFAULT_INITIALIZATION_PARAMETER =
            "WEB-INF/config/${servername}/${contextPath}/magnolia.properties,"
                    + "WEB-INF/config/${servername}/${webapp}/magnolia.properties,"
                    + "WEB-INF/config/${servername}/magnolia.properties,"
                    + "WEB-INF/config/${contextPath}/magnolia.properties,"
                    + "WEB-INF/config/${webapp}/magnolia.properties,"
                    + "WEB-INF/config/default/magnolia.properties,"
                    + "WEB-INF/config/magnolia.properties";

    /**
     * Default value for the MAGNOLIA_INITIALIZATION_FILE parameter in profile based configuration.
     * if {@link #MAGNOLIA_PROFILE_ENV MAGNOLIA_PROFILE} is set.
     */
    protected static final String PROFILE_INITIALIZATION_PARAMETER =
            "WEB-INF/config/${MAGNOLIA_PROFILE}/magnolia_${MAGNOLIA_INSTANCE_TYPE}_${MAGNOLIA_STAGE}.properties," +
            "WEB-INF/config/${MAGNOLIA_PROFILE}/magnolia_${MAGNOLIA_INSTANCE_TYPE}.properties," +
            "WEB-INF/config/${MAGNOLIA_PROFILE}/magnolia.properties," +
            "WEB-INF/config/shared/magnolia_${MAGNOLIA_INSTANCE_TYPE}_${MAGNOLIA_STAGE}.properties," +
            "WEB-INF/config/shared/magnolia_${MAGNOLIA_INSTANCE_TYPE}.properties," +
            "WEB-INF/config/shared/magnolia.properties," +
            "WEB-INF/config/default/magnolia_${MAGNOLIA_INSTANCE_TYPE}_${MAGNOLIA_STAGE}.properties," +
            "WEB-INF/config/default/magnolia_${MAGNOLIA_INSTANCE_TYPE}.properties," +
            "WEB-INF/config/default/magnolia.properties,";

    /**
     * Enable profile based configuration by setting {@code MAGNOLIA_PROFILE}.
     */
    protected static final String MAGNOLIA_PROFILE_ENV = "MAGNOLIA_PROFILE";

    private final ServletContext context;
    private final MagnoliaInitPaths initPaths;
    private final SystemPropertySource systemPropertySource;
    private final EnvironmentPropertySource environmentPropertySource;
    private final Supplier<List<String>> locations = Suppliers.memoize(this::resolveLocations);

    @Inject
    public DefaultMagnoliaPropertiesResolver(ServletContext context, MagnoliaInitPaths initPaths, SystemPropertySource systemPropertySource, EnvironmentPropertySource environmentPropertySource) {
        this.context = context;
        this.initPaths = initPaths;
        this.systemPropertySource = systemPropertySource;
        this.environmentPropertySource = environmentPropertySource;
    }

    /**
     * @deprecated  use {@link #DefaultMagnoliaPropertiesResolver(ServletContext, MagnoliaInitPaths, SystemPropertySource, EnvironmentPropertySource)}  } instead.
     */
    @Deprecated
    public DefaultMagnoliaPropertiesResolver(ServletContext context, MagnoliaInitPaths initPaths) {
        this(context, initPaths, getComponent(SystemPropertySource.class), getComponent(EnvironmentPropertySource.class));
    }

    protected String getConfigurationProfile() {
        String profile = systemPropertySource.getProperty(MAGNOLIA_PROFILE_ENV);
        return profile != null ? profile : environmentPropertySource.getProperty(MAGNOLIA_PROFILE_ENV);
    }

    protected String getInitParameter(ServletContext ctx, String name, String defaultValue) {
        final String propertiesFilesString = ctx.getInitParameter(name);
        if (StringUtils.isEmpty(propertiesFilesString)) {
            log.debug("{} value in web.xml is undefined, falling back to default: {}", name, defaultValue);
            String profile = getConfigurationProfile();
            if (profile == null) {
                log.info("Profile based configuration is disabled, falling back to configuration based on servername, webapp and contextPath");
                log.warn("This configuration mode is deprecated and will not be supported in future versions. " +
                        "Consider migrating to profile directory based configuration.");
            } else {
                String profileDir = "/WEB-INF/config/" + profile;
                if (isEmpty(ctx.getResourcePaths(profileDir))) {
                    throw new RuntimeException("Invalid profile " + profile + ". Directory " + profileDir + " is empty or does not exist");
                } else {
                    log.info("Profile based configuration is enabled. Profile is set to {}", profile);
                }
            }
            return defaultValue;
        }
        log.info("Found custom value of the {} context attribute in web.xml. " +
                "Resolving Magnolia property files from that location: {}", name, propertiesFilesString);
        return propertiesFilesString;
    }

    /**
     * Used in tests, potentially in subclasses.
     */
    protected List<String> getLocations() {
        return locations.get();
    }

    private List<String> resolveLocations() {
        String propertiesFilesString = getInitParameter(context, MAGNOLIA_INITIALIZATION_FILE,
                getConfigurationProfile() == null ? DEFAULT_INITIALIZATION_PARAMETER : PROFILE_INITIALIZATION_PARAMETER);

        return Arrays.stream(propertiesFilesString.trim().split("[,]+", 0))
                .map(String::trim)
                .map(this::interpolate)
                .filter(Optional::isPresent)  // Use Optional::stream once we bump above Java 8
                .map(Optional::get)
                .collect(Collectors.toList());
    }

    @Override
    public List<PropertySource> getSources() {
        final List<PropertySource> sources = new ArrayList<PropertySource>();
        boolean foundFiles = false;
        for (String location : getLocations()) {
            try {
                if (Paths.get(location).isAbsolute()) {
                    sources.add(new FileSystemPropertySource(location));
                } else {
                    sources.add(new ServletContextPropertySource(context, location));
                }
                foundFiles = true;
            } catch (FileNotFoundException e) {
                log.debug("Configuration file not found with path [{}]", location);
            } catch (IOException e) {
                throw new RuntimeException("Error while reading from the configuration file " + location, e);
            }
        }
        if (!foundFiles) {
            log.warn("No configuration files found using location list {}.", getLocations());
        }

        return sources;
    }

    /**
     * Replace placeholders in configuration location strings with values looked up from
     * {@link MagnoliaInitPaths init paths}, the {@link ServletContext servlet context}, system properties and
     * environment variables.
     * <p>
     * <ul>
     * <li>{@code ${servername}} is replaced with the host name</li>
     * <li>{@code ${webapp}} is replaced with name of the web application</li>
     * <li>{@code ${contextPath} is replace with the context path of the web application</li>
     * <li>{@code ${systemProperty/*}} is replaced with the corresponding system property</li>
     * <li>{@code ${env/*}} is replaced with the corresponding environment property}</li>
     * <li>{@code ${contextAttribute/*}} is replaced with the corresponding attribute from servlet context</li>
     * <li>{@code ${contextParam/*}} is replaced with the corresponding parameters from servlet context</li>
     * <li>{@code ${*}} is replaced with the corresponding value looked up from the system properties, the environment
     * variables, the context attributes and the context parameters in that order.</li>
     * </ul>

     * @param source  configuration location to interpolate
     * @return  the interpolated configuration location or {@code empty} if not all placeholders in {@code source}
     *          could be resolved.
     */
    private Optional<String> interpolate(String source) {
        Resolver resolver = new Resolver();
        String interpolation = new StringSubstitutor(resolver).replace(source);
        if (resolver.getUnresolvedKeys().isEmpty()) {
            log.info("Resolved Magnolia property file location {} to {}", source, interpolation);
            return Optional.of(interpolation);
        } else {
            log.debug("Could not resolve Magnolia property file locations {}. Missing keys: {}", source, resolver.getUnresolvedKeys());
            return Optional.empty();
        }
    }

    private class Resolver implements StringLookup {
            private List<String> unresolvedKeys = new ArrayList<>();

            Optional<String> getBasicProperty(String key) {
                switch (key) {
                    case "servername":
                        return Optional.ofNullable(initPaths.getServerName());
                    case "webapp":
                        return Optional.ofNullable(initPaths.getWebappFolderName());
                    case "contextPath":
                        // Use ROOT for the default (root) context, otherwise trim the leading slash to prevent double slashes
                        String contextPath = initPaths.getContextPath();
                        if (contextPath.length() == 0) {
                            return Optional.of("ROOT");
                        } else {
                            return Optional.of(contextPath.substring(1));
                        }
                    default:
                        return Optional.empty();
                    }
            }

            private boolean qualified(String key) {
                return key.contains("/");
            }

            private Optional<String> stripPrefix(String key, String prefix) {
                if (key.startsWith(prefix)) {
                    return Optional.of(substringAfter(key, prefix));
                } else if (!qualified(key)) {
                    return Optional.of(key);
                } else {
                    return Optional.empty();
                }
            }

            private Optional<String> getContextAttribute(String key) {
                return stripPrefix(key, CONTEXT_ATTRIBUTE_PLACEHOLDER_PREFIX)
                        .map(context::getAttribute)
                        .map(Object::toString);
            }

            private Optional<String> getContextParameter(String key) {
                return stripPrefix(key, CONTEXT_PARAM_PLACEHOLDER_PREFIX)
                        .map(context::getInitParameter);
            }

            private Optional<String> getSystemProperty(String key) {
                return stripPrefix(key, SYSTEM_PROPERTY_PLACEHOLDER_PREFIX)
                        .filter(StringUtils::isNoneBlank)
                        .map(systemPropertySource::getProperty);
            }

            private Optional<String> getEnvironmentVariable(String key) {
                return stripPrefix(key, ENV_PROPERTY_PLACEHOLDER_PREFIX)
                        .filter(StringUtils::isNoneBlank)
                        .map(environmentPropertySource::getProperty);
            }

            @Override
            public String lookup(String key) {
                Optional<String> value = Stream.<Supplier<Optional<String>>>of(
                        () -> getBasicProperty(key),
                        () -> getContextAttribute(key),
                        () -> getContextParameter(key),
                        () -> getSystemProperty(key),
                        () -> getEnvironmentVariable(key)
                )
                        .map(Supplier::get)
                        .filter(Optional::isPresent)  // Use Optional::stream once we bump above Java 8
                        .map(Optional::get)
                        .findFirst();

                if (value.isPresent()) {
                    return value.get();
                } else {
                    unresolvedKeys.add(key);
                    return null;
                }
            }

            List<String> getUnresolvedKeys() {
                return unresolvedKeys;
            }
        }

}