Merge pull request #190 from restx/improve-config-loader

improve config loader (#186 #158)

restx-factory-testing/src/test/java/restx/config/ConfigMachineTest.java

@@ -1,8 +1,12 @@
package restx.config;

import com.google.common.base.Charsets;
import com.google.common.base.Optional;
import com.google.common.io.Files;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import restx.common.ConfigElement;
import restx.common.RestxConfig;
import restx.common.StdRestxConfig;
@@ -11,6 +15,8 @@
import restx.config.ElementsFromConfigFactoryMachine;
import restx.factory.*;

import java.io.File;

import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;

@@ -20,6 +26,9 @@
 * Time: 10:05 PM
 */
public class ConfigMachineTest {
    @Rule
    public TemporaryFolder folder = new TemporaryFolder();

    @BeforeClass
    public static void deactivateElementsFromConfig() {
        System.setProperty("restx.activation::java.lang.String::mandatory.dep.result1", "false");
@@ -133,6 +142,44 @@ public void should_load_from_loader() throws Exception {
                        "classpath:restx/common/config.properties", "Doc 1", "key1", "val1"));
    }

    @Test
    public void should_loader_load_settings_from_file_setup_with_system_property() throws Exception {
        String key = "restx.common.config.location";
        try {
            File file = folder.newFile("config.properties");
            Files.append("key1=myval1", file, Charsets.UTF_8);
            System.setProperty(key, file.getAbsolutePath());

            Factory factory = Factory.builder()
                    .addFromServiceLoader()
                    .build();

            RestxConfig config = factory.getComponent(RestxConfig.class);

            assertThat(config.getString("key1")).isEqualTo(Optional.of("myval1"));
            assertThat(config.getElement("key1").get())
                    .isEqualToComparingFieldByField(ConfigElement.of(
                            "file://" + file.getAbsolutePath(), "Doc 1", "key1", "myval1"));

        } finally {
            System.clearProperty(key);
        }
    }

    @Test
    public void should_loader_load_settings_from_file() throws Exception {
        File file = folder.newFile("config.properties");
        Files.append("key1=myval1", file, Charsets.UTF_8);

        RestxConfig config = new ConfigLoader(Optional.<String>absent())
                .fromFile(file.getAbsolutePath()).get();

        assertThat(config.getString("key1")).isEqualTo(Optional.of("myval1"));
        assertThat(config.getElement("key1").get())
                .isEqualToComparingFieldByField(ConfigElement.of(
                        "file://" + file.getAbsolutePath(), "", "key1", "myval1"));
    }

    private SingletonFactoryMachine<ConfigSupplier> configSupplierMachine(
            int priority, String name, final ConfigElement... config) {
        return new SingletonFactoryMachine<>(priority,

restx-factory/src/main/java/restx/config/ConfigLoader.java

@@ -7,14 +7,19 @@
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import restx.common.ConfigElement;
import restx.common.RestxConfig;
import restx.common.StdRestxConfig;

import static com.google.common.io.Files.asCharSource;

/**
 * User: xavierhanin
 * Date: 9/24/13
@@ -34,7 +39,11 @@ public ConfigLoader(Optional<String> env) {
     *
     * The name of the resource provided must not contain the extension, which must be .properties
     *
     * The loader will first try to load an env specific resource named [resource].[env].properties.
     * The loader will first try to load config from a file which location is provided by a system
     * property, the name of the property being the name returned by #locationKeyForResource.
     *
     * Then it will try to load an env specific resource named [resource].[env].properties.
     *
     * Then it will load a resource named [resource].properties.
     *
     * @param resource the path of the resource to load, without extension.
@@ -46,14 +55,107 @@ public ConfigSupplier fromResource(final String resource) {
            @Override
            public RestxConfig get() {
                List<ConfigElement> elements = new ArrayList<>();
                loadResourceInto(resource + "." + env + ".properties", elements);
                loadResourceInto(resource + ".properties", elements);

                loadAllFromResource(elements, resource);

                return StdRestxConfig.of(elements);
            }
        };
    }

    /**
     * Provides a ConfigSupplier loading config from a file.
     *
     * The loader will first try to load an env specific file named [path].[env].properties.
     *
     * Then it will try to load a file named [path].properties.
     *
     * Then it will try to load a file named [path] (without extension).
     *
     * @param path the path of the file to load config from.
     *
     * @return a ConfigSupplier ready to load corresponding file.
     */
    public ConfigSupplier fromFile(final String path) {
        return new ConfigSupplier() {
            @Override
            public RestxConfig get() {
                List<ConfigElement> elements = new ArrayList<>();

                loadAllFromFile(elements, path);

                return StdRestxConfig.of(elements);
            }
        };
    }

    private void loadResourceInto(String name, List<ConfigElement> elements) {
    /**
     * Gives the name of the system property that can be used to provide a file location
     * to load to override settings for a particular resource.
     *
     * By defaut the name is equal to the resource name where slashes `/` are replaced by dots `.`,
     * with `.location` suffix.
     *
     * Eg.
     * `myapp/settings` becomes `myapp.settings.location`
     *
     * @param resource the resource for which the system property name should be provided.
     *
     * @return the system property name.
     */
    public String locationKeyForResource(String resource) {
        return resource.replace('/', '.') + ".location";
    }

    protected void loadAllFromResource(List<ConfigElement> elements, String resource) {
        String locationKey = locationKeyForResource(resource);
        String location = System.getProperty(locationKey);
        if (location != null) {
            Path path = Paths.get(location).toAbsolutePath();
            logger.info("loading {} settings from {}", resource, path);
            loadFileInto(path, elements);
        } else {
            logger.debug("system property `{}` is not set, no file to load to override settings from {}",
                    locationKey, resource);
        }

        loadResourceInto(resource + "." + env + ".properties", elements);
        loadResourceInto(resource + ".properties", elements);
    }

    protected void loadAllFromFile(List<ConfigElement> elements, String path) {
        if (!path.endsWith(".properties")) {
            loadFileInto(Paths.get(path + "." + env + ".properties"), elements);
            loadFileInto(Paths.get(path + ".properties"), elements);
        }

        loadFileInto(Paths.get(path), elements);
    }

    protected void loadFileInto(Path path, List<ConfigElement> elements) {
        File file = path.toFile().getAbsoluteFile();
        if (!file.exists()) {
            logger.debug("no settings loaded from {}: file not available", file);
            return;
        }

        if (!file.isFile()) {
            logger.warn("no settings loaded from {}: this is not a file", file);
            return;
        }

        try {
            Iterable<ConfigElement> loadedElements = StdRestxConfig.parse("file://" + file,
                    asCharSource(file, Charsets.UTF_8)).elements();
            Iterables.addAll(elements, loadedElements);
            logger.debug("loaded {} elements from {}", Iterables.size(loadedElements), file);
        } catch (IOException e) {
            logger.warn("can't load " + file + ": " + e.getMessage(), e);
        }

    }

    protected void loadResourceInto(String name, List<ConfigElement> elements) {
        URL r;
        r = Thread.currentThread().getContextClassLoader().getResource(name);
        if (r != null) {