/*

 * Copyright 2013-2014 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.springframework.cloud.bootstrap.config;

import org.springframework.core.env.Environment;

import org.springframework.core.env.PropertySource;

/**

 * Strategy for locating (possibly remote) property sources for the Environment.

 * Implementations should not fail unless they intend to prevent the application from

 * starting.

 *

 * @author Dave Syer

 *

 */

public interface PropertySourceLocator {

    /**

     * @param environment the current Environment

     * @return a PropertySource or null if there is none

     *

     * @throws IllegalStateException if there is a fail fast condition

     */

    PropertySource<?> locate(Environment environment);

}

package com.bdqn.lyrk.config.bootstrap;

import org.springframework.cloud.bootstrap.config.PropertySourceLocator;

import org.springframework.context.annotation.Configuration;

import org.springframework.core.env.Environment;

import org.springframework.core.env.MapPropertySource;

import org.springframework.core.env.PropertySource;

import java.util.HashMap;

import java.util.Map;

@Configuration

public class MyTestPropertySourceLocator implements PropertySourceLocator {

    @Override

    public PropertySource<?> locate(Environment environment) {

        Map<String, Object> propertySource = new HashMap<>();

        propertySource.put("student.name", "admin");

        MapPropertySource mapPropertySource = new MapPropertySource("customer", propertySource);

        return mapPropertySource;

    }

}

org.springframework.cloud.bootstrap.BootstrapConfiguration=\

  com.bdqn.lyrk.config.bootstrap.MyTestPropertySourceLocator

package com.bdqn.lyrk.config.server;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.cloud.config.server.EnableConfigServer;

import org.springframework.context.ConfigurableApplicationContext;

import org.springframework.core.env.Environment;

@SpringBootApplication

@EnableConfigServer

public class ConfigServer {

    public static void main(String[] args) {

        ConfigurableApplicationContext applicationContext = SpringApplication.run(ConfigServer.class, args);

        Environment environment = applicationContext.getBean(Environment.class);

        System.out.println(environment);

        System.out.println(environment.getProperty("student.name"));

    }

}

/*

 * Copyright 2013-2015 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.springframework.cloud.config.server.environment;

import org.springframework.cloud.config.environment.Environment;

/**

 * @author Dave Syer

 * @author Roy Clarkson

 */

public interface EnvironmentRepository {

    Environment findOne(String application, String profile, String label);

}

/*

 * Copyright 2013-2015 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.springframework.cloud.config.environment;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import com.fasterxml.jackson.annotation.JsonCreator;

import com.fasterxml.jackson.annotation.JsonProperty;

/**

 * Simple plain text serializable encapsulation of a list of property sources. Basically a

 * DTO for {@link org.springframework.core.env.Environment}, but also applicable outside

 * the domain of a Spring application.

 *

 * @author Dave Syer

 * @author Spencer Gibb

 *

 */

public class Environment {

    private String name;

    private String[] profiles = new String[0];

    private String label;

    private List<PropertySource> propertySources = new ArrayList<>();

    private String version;

    private String state;

    public Environment(String name, String... profiles) {

        this(name, profiles, "master", null, null);

    }

    /**

     * Copies all fields except propertySources

     * @param env

     */

    public Environment(Environment env) {

        this(env.getName(), env.getProfiles(), env.getLabel(), env.getVersion(), env.getState());

    }

    @JsonCreator

    public Environment(@JsonProperty("name") String name,

            @JsonProperty("profiles") String[] profiles,

            @JsonProperty("label") String label,

            @JsonProperty("version") String version,

            @JsonProperty("state") String state) {

        super();

        this.name = name;

        this.profiles = profiles;

        this.label = label;

        this.version = version;

        this.state = state;

    }

    public void add(PropertySource propertySource) {

        this.propertySources.add(propertySource);

    }

    public void addAll(List<PropertySource> propertySources) {

        this.propertySources.addAll(propertySources);

    }

    public void addFirst(PropertySource propertySource) {

        this.propertySources.add(0, propertySource);

    }

    public List<PropertySource> getPropertySources() {

        return propertySources;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getLabel() {

        return label;

    }

    public void setLabel(String label) {

        this.label = label;

    }

    public String[] getProfiles() {

        return profiles;

    }

    public void setProfiles(String[] profiles) {

        this.profiles = profiles;

    }

    public String getVersion() {

        return version;

    }

    public void setVersion(String version) {

        this.version = version;

    }

    public String getState() {

        return state;

    }

    public void setState(String state) {

        this.state = state;

    }

    @Override

    public String toString() {

        return "Environment [name=" + name + ", profiles=" + Arrays.asList(profiles)

                + ", label=" + label + ", propertySources=" + propertySources

                + ", version=" + version

                + ", state=" + state + "]";

    }

}

# Bootstrap components

org.springframework.cloud.bootstrap.BootstrapConfiguration=\

org.springframework.cloud.config.server.bootstrap.ConfigServerBootstrapConfiguration,\

org.springframework.cloud.config.server.config.EncryptionAutoConfiguration

# Application listeners

org.springframework.context.ApplicationListener=\

org.springframework.cloud.config.server.bootstrap.ConfigServerBootstrapApplicationListener

# Autoconfiguration

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\

org.springframework.cloud.config.server.config.ConfigServerAutoConfiguration,\

org.springframework.cloud.config.server.config.EncryptionAutoConfiguration

/*

 * Copyright 2013-2015 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.springframework.cloud.config.server.bootstrap;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;

import org.springframework.boot.context.properties.EnableConfigurationProperties;

import org.springframework.cloud.config.client.ConfigClientProperties;

import org.springframework.cloud.config.server.config.ConfigServerProperties;

import org.springframework.cloud.config.server.config.EnvironmentRepositoryConfiguration;

import org.springframework.cloud.config.server.config.TransportConfiguration;

import org.springframework.cloud.config.server.environment.EnvironmentRepository;

import org.springframework.cloud.config.server.environment.EnvironmentRepositoryPropertySourceLocator;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.Import;

import org.springframework.util.StringUtils;

/**

 * Bootstrap configuration to fetch external configuration from a (possibly

 * remote) {@link EnvironmentRepository}. Off by default because it can delay

 * startup, but can be enabled with

 * <code>spring.cloud.config.server.bootstrap=true</code>. This would be useful,

 * for example, if the config server were embedded in another app that wanted to

 * be configured from the same repository as all the other clients.

 *

 * @author Dave Syer

 * @author Roy Clarkson

 */

@Configuration

@ConditionalOnProperty("spring.cloud.config.server.bootstrap")

public class ConfigServerBootstrapConfiguration {

	@EnableConfigurationProperties(ConfigServerProperties.class)

	@Import({ EnvironmentRepositoryConfiguration.class, TransportConfiguration.class })

	protected static class LocalPropertySourceLocatorConfiguration {

		@Autowired

		private EnvironmentRepository repository;

		@Autowired

		private ConfigClientProperties client;

		@Autowired

		private ConfigServerProperties server;

		@Bean

		public EnvironmentRepositoryPropertySourceLocator environmentRepositoryPropertySourceLocator() {

			return new EnvironmentRepositoryPropertySourceLocator(this.repository, this.client.getName(),

					this.client.getProfile(), getDefaultLabel());

		}

		private String getDefaultLabel() {

			if (StringUtils.hasText(this.client.getLabel())) {

				return this.client.getLabel();

			} else if (StringUtils.hasText(this.server.getDefaultLabel())) {

				return this.server.getDefaultLabel();

			}

			return null;

		}

	}

}

/*

 * Copyright 2013-2014 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.springframework.cloud.config.server.environment;

import java.util.Map;

import org.springframework.cloud.bootstrap.config.PropertySourceLocator;

import org.springframework.cloud.config.environment.PropertySource;

import org.springframework.core.env.CompositePropertySource;

import org.springframework.core.env.Environment;

import org.springframework.core.env.MapPropertySource;

/**

 * A PropertySourceLocator that reads from an EnvironmentRepository.

 *

 * @author Dave Syer

 *

 */

public class EnvironmentRepositoryPropertySourceLocator implements PropertySourceLocator {

    private EnvironmentRepository repository;

    private String name;

    private String profiles;

    private String label;

    public EnvironmentRepositoryPropertySourceLocator(EnvironmentRepository repository,

            String name, String profiles, String label) {

        this.repository = repository;

        this.name = name;

        this.profiles = profiles;

        this.label = label;

    }

    @Override

    public org.springframework.core.env.PropertySource<?> locate(Environment environment) {

        CompositePropertySource composite = new CompositePropertySource("configService");

        for (PropertySource source : repository.findOne(name, profiles, label)

                .getPropertySources()) {

            @SuppressWarnings("unchecked")

            Map<String, Object> map = (Map<String, Object>) source.getSource();

            composite.addPropertySource(new MapPropertySource(source.getName(), map));

        }

        return composite;

    }

}

# Auto Configure

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\

org.springframework.cloud.config.client.ConfigClientAutoConfiguration

# Bootstrap components

org.springframework.cloud.bootstrap.BootstrapConfiguration=\

org.springframework.cloud.config.client.ConfigServiceBootstrapConfiguration,\

org.springframework.cloud.config.client.DiscoveryClientConfigServiceBootstrapConfiguration

/*

 * Copyright 2013-2017 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.springframework.cloud.config.client;

import org.aspectj.lang.annotation.Aspect;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.autoconfigure.aop.AopAutoConfiguration;

import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;

import org.springframework.boot.context.properties.EnableConfigurationProperties;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.Import;

import org.springframework.core.env.ConfigurableEnvironment;

import org.springframework.retry.annotation.EnableRetry;

import org.springframework.retry.annotation.Retryable;

import org.springframework.retry.interceptor.RetryInterceptorBuilder;

import org.springframework.retry.interceptor.RetryOperationsInterceptor;

/**

 * @author Dave Syer

 * @author Tristan Hanson

 *

 */

@Configuration

@EnableConfigurationProperties

public class ConfigServiceBootstrapConfiguration {

	@Autowired

	private ConfigurableEnvironment environment;

	@Bean

	public ConfigClientProperties configClientProperties() {

		ConfigClientProperties client = new ConfigClientProperties(this.environment);

		return client;

	}

	@Bean

	@ConditionalOnMissingBean(ConfigServicePropertySourceLocator.class)

	@ConditionalOnProperty(value = "spring.cloud.config.enabled", matchIfMissing = true)

	public ConfigServicePropertySourceLocator configServicePropertySource(ConfigClientProperties properties) {

		ConfigServicePropertySourceLocator locator = new ConfigServicePropertySourceLocator(

				properties);

		return locator;

	}

	@ConditionalOnProperty(value = "spring.cloud.config.failFast", matchIfMissing=false)

	@ConditionalOnClass({ Retryable.class, Aspect.class, AopAutoConfiguration.class })

	@Configuration

	@EnableRetry(proxyTargetClass = true)

	@Import(AopAutoConfiguration.class)

	@EnableConfigurationProperties(RetryProperties.class)

	protected static class RetryConfiguration {

		@Bean

		@ConditionalOnMissingBean(name = "configServerRetryInterceptor")

		public RetryOperationsInterceptor configServerRetryInterceptor(

				RetryProperties properties) {

			return RetryInterceptorBuilder

					.stateless()

					.backOffOptions(properties.getInitialInterval(),

							properties.getMultiplier(), properties.getMaxInterval())

					.maxAttempts(properties.getMaxAttempts()).build();

		}

	}

}

/*

 * Copyright 2016-2017 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.springframework.cloud.config.server.environment;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Properties;

import org.springframework.boot.context.properties.ConfigurationProperties;

import org.springframework.cloud.config.environment.Environment;

import org.springframework.cloud.config.environment.PropertySource;

import org.springframework.core.Ordered;

import org.springframework.dao.DataAccessException;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.jdbc.core.ResultSetExtractor;

import org.springframework.util.StringUtils;

/**

 * An {@link EnvironmentRepository} that picks up data from a relational database. The

 * database should have a table called "PROPERTIES" with columns "APPLICATION", "PROFILE",

 * "LABEL" (with the usual {@link Environment} meaning), plus "KEY" and "VALUE" for the

 * key and value pairs in {@link Properties} style. Property values behave in the same way

 * as they would if they came from Spring Boot properties files named

 * <code>{application}-{profile}.properties</code>, including all the encryption and

 * decryption, which will be applied as post-processing steps (i.e. not in this repository

 * directly).

 *

 * @author Dave Syer

 *

 */

@ConfigurationProperties("spring.cloud.config.server.jdbc")

public class JdbcEnvironmentRepository implements EnvironmentRepository, Ordered {

    private static final String DEFAULT_SQL = "SELECT KEY, VALUE from PROPERTIES where APPLICATION=? and PROFILE=? and LABEL=?";

    private int order = Ordered.LOWEST_PRECEDENCE - 10;

    private final JdbcTemplate jdbc;

    private String sql = DEFAULT_SQL;

    private final PropertiesResultSetExtractor extractor = new PropertiesResultSetExtractor();

    public JdbcEnvironmentRepository(JdbcTemplate jdbc) {

        this.jdbc = jdbc;

    }

    public void setSql(String sql) {

        this.sql = sql;

    }

    public String getSql() {

        return this.sql;

    }

    @Override

    public Environment findOne(String application, String profile, String label) {

        String config = application;

        if (StringUtils.isEmpty(label)) {

            label = "master";

        }

        if (StringUtils.isEmpty(profile)) {

            profile = "default";

        }

        if (!profile.startsWith("default")) {

            profile = "default," + profile;

        }

        String[] profiles = StringUtils.commaDelimitedListToStringArray(profile);

        Environment environment = new Environment(application, profiles, label, null,

                null);

        if (!config.startsWith("application")) {

            config = "application," + config;

        }

        List<String> applications = new ArrayList<String>(new LinkedHashSet<>(

                Arrays.asList(StringUtils.commaDelimitedListToStringArray(config))));

        List<String> envs = new ArrayList<String>(new LinkedHashSet<>(Arrays.asList(profiles)));

        Collections.reverse(applications);

        Collections.reverse(envs);

        for (String app : applications) {

            for (String env : envs) {

                Map<String, String> next = (Map<String, String>) jdbc.query(this.sql,

                        new Object[] { app, env, label }, this.extractor);

                if (!next.isEmpty()) {

                    environment.add(new PropertySource(app + "-" + env, next));

                }

            }

        }

        return environment;

    }

    @Override

    public int getOrder() {

        return order;

    }

    public void setOrder(int order) {

        this.order = order;

    }

}

class PropertiesResultSetExtractor implements ResultSetExtractor<Map<String, String>> {

    @Override

    public Map<String, String> extractData(ResultSet rs)

            throws SQLException, DataAccessException {

        Map<String, String> map = new LinkedHashMap<>();

        while (rs.next()) {

            map.put(rs.getString(1), rs.getString(2));

        }

        return map;

    }

}