# Auto Configuration
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.cloud.consul.config.ConsulConfigAutoConfiguration# Bootstrap Configuration
org.springframework.cloud.bootstrap.BootstrapConfiguration=\
org.springframework.cloud.consul.config.ConsulConfigBootstrapConfiguration

@Configuration
@ConditionalOnConsulEnabled
@ConditionalOnProperty(name = "spring.cloud.consul.config.enabled", matchIfMissing = true)
public class ConsulConfigAutoConfiguration {@Configuration@ConditionalOnClass(RefreshEndpoint.class)protected static class ConsulRefreshConfiguration {@Bean@ConditionalOnProperty(name = "spring.cloud.consul.config.watch.enabled", matchIfMissing = true)public ConfigWatch configWatch(ConsulConfigProperties properties,ConsulPropertySourceLocator locator, ConsulClient consul) {return new ConfigWatch(properties, consul, locator.getContextIndexes());}}
}

    @Scheduled(fixedDelayString = "${spring.cloud.consul.config.watch.delay:1000}")public void watchConfigKeyValues() {if (this.running.get()) {for (String context : this.consulIndexes.keySet()) {// turn the context into a Consul folder path (unless our config format are FILES)if (properties.getFormat() != FILES && !context.endsWith("/")) {context = context + "/";}try {Long currentIndex = this.consulIndexes.get(context);if (currentIndex == null) {currentIndex = -1L;}// use the consul ACL token if foundString aclToken = properties.getAclToken();if (StringUtils.isEmpty(aclToken)) {aclToken = null;}Response<List<GetValue>> response = this.consul.getKVValues(context, aclToken,new QueryParams(this.properties.getWatch().getWaitTime(),currentIndex));// if response.value == null, response was a 404, otherwise it was a 200// reducing churn if there wasn't anythingif (response.getValue() != null && !response.getValue().isEmpty()) {Long newIndex = response.getConsulIndex();if (newIndex != null && !newIndex.equals(currentIndex)) {// don't publish the same index again, don't publish the first time (-1) so index can be primedif (!this.consulIndexes.containsValue(newIndex) && !currentIndex.equals(-1L)) {RefreshEventData data = new RefreshEventData(context, currentIndex, newIndex);this.publisher.publishEvent(new RefreshEvent(this, data, data.toString()));}this.consulIndexes.put(context, newIndex);}}} catch (Exception e) {// only fail fast on the initial query, otherwise just log the errorif (firstTime && this.properties.isFailFast()) {log.error("Fail fast is set and there was an error reading configuration from consul.");ReflectionUtils.rethrowRuntimeException(e);} else if (log.isTraceEnabled()) {log.trace("Error querying consul Key/Values for context '" + context + "'", e);} else if (log.isWarnEnabled()) {// simplified one line log message in the event of an agent failurelog.warn("Error querying consul Key/Values for context '" + context + "'. Message: " + e.getMessage());}}}}firstTime = false;}

@Configuration
@ConditionalOnConsulEnabled
public class ConsulConfigBootstrapConfiguration {@Configuration@EnableConfigurationProperties@Import(ConsulAutoConfiguration.class)@ConditionalOnProperty(name = "spring.cloud.consul.config.enabled", matchIfMissing = true)protected static class ConsulPropertySourceConfiguration {@Autowiredprivate ConsulClient consul;@Beanpublic ConsulConfigProperties consulConfigProperties() {return new ConsulConfigProperties();}@Beanpublic ConsulPropertySourceLocator consulPropertySourceLocator(ConsulConfigProperties consulConfigProperties) {return new ConsulPropertySourceLocator(consul, consulConfigProperties);}}
}

    @Override@Retryable(interceptor = "consulRetryInterceptor")public PropertySource<?> locate(Environment environment) {if (environment instanceof ConfigurableEnvironment) {ConfigurableEnvironment env = (ConfigurableEnvironment) environment;RelaxedPropertyResolver propertyResolver = new RelaxedPropertyResolver(env);String appName = properties.getName();if (appName == null) {appName = propertyResolver.getProperty("spring.application.name");}List<String> profiles = Arrays.asList(env.getActiveProfiles());String prefix = this.properties.getPrefix();List<String> suffixes = new ArrayList<>();if (this.properties.getFormat() != FILES) {suffixes.add("/");} else {suffixes.add(".yml");suffixes.add(".yaml");suffixes.add(".properties");}String defaultContext = prefix + "/" + this.properties.getDefaultContext();for (String suffix : suffixes) {this.contexts.add(defaultContext + suffix);}for (String suffix : suffixes) {addProfiles(this.contexts, defaultContext, profiles, suffix);}String baseContext = prefix + "/" + appName;for (String suffix : suffixes) {this.contexts.add(baseContext + suffix);}for (String suffix : suffixes) {addProfiles(this.contexts, baseContext, profiles, suffix);}Collections.reverse(this.contexts);CompositePropertySource composite = new CompositePropertySource("consul");for (String propertySourceContext : this.contexts) {try {ConsulPropertySource propertySource = null;if (this.properties.getFormat() == FILES) {Response<GetValue> response = this.consul.getKVValue(propertySourceContext, this.properties.getAclToken());addIndex(propertySourceContext, response.getConsulIndex());if (response.getValue() != null) {ConsulFilesPropertySource filesPropertySource = new ConsulFilesPropertySource(propertySourceContext, this.consul, this.properties);filesPropertySource.init(response.getValue());propertySource = filesPropertySource;}} else {propertySource = create(propertySourceContext, contextIndex);}if (propertySource != null) {composite.addPropertySource(propertySource);}} catch (Exception e) {if (this.properties.isFailFast()) {log.error("Fail fast is set and there was an error reading configuration from consul.");ReflectionUtils.rethrowRuntimeException(e);} else {log.warn("Unable to load consul config from "+ propertySourceContext, e);}}}return composite;}return null;}

# Auto Configuration
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.cloud.consul.ConsulAutoConfiguration

@Configuration
@EnableConfigurationProperties
@ConditionalOnConsulEnabled
public class ConsulAutoConfiguration {@Bean@ConditionalOnMissingBeanpublic ConsulProperties consulProperties() {return new ConsulProperties();}@Bean@ConditionalOnMissingBeanpublic ConsulClient consulClient(ConsulProperties consulProperties) {return new ConsulClient(consulProperties.getHost(), consulProperties.getPort()); } @Configuration @ConditionalOnClass(Endpoint.class) protected static class ConsulHealthConfig { @Bean @ConditionalOnMissingBean @ConditionalOnEnabledEndpoint("consul") public ConsulEndpoint consulEndpoint(ConsulClient consulClient) { return new ConsulEndpoint(consulClient); } @Bean @ConditionalOnMissingBean @ConditionalOnEnabledHealthIndicator("consul") public ConsulHealthIndicator consulHealthIndicator(ConsulClient consulClient) { return new ConsulHealthIndicator(consulClient); } } @ConditionalOnClass({ Retryable.class, Aspect.class, AopAutoConfiguration.class }) @Configuration @EnableRetry(proxyTargetClass = true) @Import(AopAutoConfiguration.class) @EnableConfigurationProperties(RetryProperties.class) protected static class RetryConfiguration { @Bean(name = "consulRetryInterceptor") @ConditionalOnMissingBean(name = "consulRetryInterceptor") public RetryOperationsInterceptor consulRetryInterceptor( RetryProperties properties) { return RetryInterceptorBuilder .stateless() .backOffOptions(properties.getInitialInterval(), properties.getMultiplier(), properties.getMaxInterval()) .maxAttempts(properties.getMaxAttempts()).build(); } } }

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.cloud.consul.discovery.RibbonConsulAutoConfiguration,\
org.springframework.cloud.consul.discovery.configclient.ConsulConfigServerAutoConfiguration,\
org.springframework.cloud.consul.serviceregistry.ConsulAutoServiceRegistrationAutoConfiguration,\
org.springframework.cloud.consul.serviceregistry.ConsulServiceRegistryAutoConfiguration# Discovery Client Configuration
org.springframework.cloud.client.discovery.EnableDiscoveryClient=\
org.springframework.cloud.consul.discovery.ConsulDiscoveryClientConfigurationorg.springframework.cloud.bootstrap.BootstrapConfiguration=\
org.springframework.cloud.consul.discovery.configclient.ConsulDiscoveryClientConfigServiceBootstrapConfiguration

@Configuration
@EnableConfigurationProperties
@ConditionalOnConsulEnabled
@ConditionalOnBean(SpringClientFactory.class)
@ConditionalOnProperty(value = "spring.cloud.consul.ribbon.enabled", matchIfMissing = true)
@AutoConfigureAfter(RibbonAutoConfiguration.class)
@RibbonClients(defaultConfiguration = ConsulRibbonClientConfiguration.class)
public class RibbonConsulAutoConfiguration {}

/*** Extra configuration for config server if it happens to be registered with Consul.** @author Dave Syer*/
@Configuration
@EnableConfigurationProperties
@ConditionalOnClass({ ConsulDiscoveryProperties.class, ConsulClient.class,ConfigServerProperties.class })
public class ConsulConfigServerAutoConfiguration {@Autowired(required = false)private ConsulDiscoveryProperties properties;@Autowired(required = false)private ConfigServerProperties server;@PostConstructpublic void init() {if (this.properties == null || this.server == null) {return;}String prefix = this.server.getPrefix();if (StringUtils.hasText(prefix)) {this.properties.getTags().add("configPath="+prefix);}}}

@Configuration
@ConditionalOnBean(AutoServiceRegistrationProperties.class)
@ConditionalOnMissingBean(type = "org.springframework.cloud.consul.discovery.ConsulLifecycle")
@ConditionalOnConsulEnabled
@ConditionalOnProperty(value = "spring.cloud.service-registry.auto-registration.enabled", matchIfMissing = true)
@AutoConfigureAfter(ConsulServiceRegistryAutoConfiguration.class)
public class ConsulAutoServiceRegistrationAutoConfiguration {@Bean@ConditionalOnMissingBeanpublic ConsulAutoServiceRegistration consulAutoServiceRegistration(ConsulServiceRegistry registry, ConsulDiscoveryProperties properties, ConsulAutoRegistration consulRegistration) {return new ConsulAutoServiceRegistration(registry, properties, consulRegistration);}@Bean@ConditionalOnMissingBeanpublic ConsulAutoRegistration consulRegistration(ConsulDiscoveryProperties properties, ApplicationContext applicationContext,ServletContext servletContext, HeartbeatProperties heartbeatProperties) {return ConsulAutoRegistration.registration(properties, applicationContext, servletContext, heartbeatProperties);}}

@Configuration
@ConditionalOnConsulEnabled
@ConditionalOnProperty(value = "spring.cloud.service-registry.enabled", matchIfMissing = true)
@AutoConfigureBefore(ServiceRegistryAutoConfiguration.class)
public class ConsulServiceRegistryAutoConfiguration {@Autowired(required = false)private TtlScheduler ttlScheduler;@Bean@ConditionalOnMissingBeanpublic ConsulServiceRegistry consulServiceRegistry(ConsulClient consulClient, ConsulDiscoveryProperties properties,HeartbeatProperties heartbeatProperties) {return new ConsulServiceRegistry(consulClient, properties, ttlScheduler, heartbeatProperties);}@Bean@ConditionalOnMissingBean@ConditionalOnProperty("spring.cloud.consul.discovery.heartbeat.enabled")public TtlScheduler ttlScheduler(ConsulClient consulClient, HeartbeatProperties heartbeatProperties) {return new TtlScheduler(heartbeatProperties, consulClient);}@Bean@ConditionalOnMissingBeanpublic HeartbeatProperties heartbeatProperties() {return new HeartbeatProperties();}@Bean@ConditionalOnMissingBeanpublic ConsulDiscoveryProperties consulDiscoveryProperties(InetUtils inetUtils) {return new ConsulDiscoveryProperties(inetUtils);}}

@Configuration
@ConditionalOnConsulEnabled
@ConditionalOnProperty(value = "spring.cloud.consul.discovery.enabled", matchIfMissing = true)
@EnableConfigurationProperties
public class ConsulDiscoveryClientConfiguration {@Autowiredprivate ConsulClient consulClient;@Autowired(required = false)private ServerProperties serverProperties;@Bean@ConditionalOnMissingBean@ConditionalOnProperty("spring.cloud.consul.discovery.heartbeat.enabled")//TODO: move to service-registry for Edgwarepublic TtlScheduler ttlScheduler(HeartbeatProperties heartbeatProperties) {return new TtlScheduler(heartbeatProperties, consulClient);}@Bean//TODO: move to service-registry for Edgwarepublic HeartbeatProperties heartbeatProperties() {return new HeartbeatProperties();}@Bean//TODO: Split appropriate values to service-registry for Edgwarepublic ConsulDiscoveryProperties consulDiscoveryProperties(InetUtils inetUtils) {return new ConsulDiscoveryProperties(inetUtils);}@Bean@ConditionalOnMissingBeanpublic ConsulDiscoveryClient consulDiscoveryClient(ConsulDiscoveryProperties discoveryProperties, final ApplicationContext context) {ConsulDiscoveryClient discoveryClient = new ConsulDiscoveryClient(consulClient,discoveryProperties, new LifecycleRegistrationResolver(context));discoveryClient.setServerProperties(serverProperties); //null okreturn discoveryClient;}class LifecycleRegistrationResolver implements ConsulDiscoveryClient.LocalResolver {private ApplicationContext context;public LifecycleRegistrationResolver(ApplicationContext context) {this.context = context;}@Overridepublic String getInstanceId() {ConsulRegistration registration = getBean(ConsulRegistration.class);if (registration != null) {return registration.getInstanceId();}ConsulLifecycle lifecycle = getBean(ConsulLifecycle.class);if (lifecycle != null) {return lifecycle.getInstanceId();}throw new IllegalStateException("Must have one of ConsulRegistration or ConsulLifecycle");}@Overridepublic Integer getPort() {ConsulRegistration registration = getBean(ConsulRegistration.class);if (registration != null) {return registration.getService().getPort();}ConsulLifecycle lifecycle = getBean(ConsulLifecycle.class);if (lifecycle != null) {return lifecycle.getConfiguredPort();}throw new IllegalStateException("Must have one of ConsulRegistration or ConsulLifecycle");}<T> T getBean(Class<T> type) {try {return context.getBean(type);} catch (NoSuchBeanDefinitionException e) {}return null;}}@Bean@ConditionalOnMissingBean@ConditionalOnProperty(name = "spring.cloud.consul.discovery.catalogServicesWatch.enabled", matchIfMissing = true)public ConsulCatalogWatch consulCatalogWatch(ConsulDiscoveryProperties discoveryProperties) {return new ConsulCatalogWatch(discoveryProperties, consulClient);}
}

/*** Helper for config client that wants to lookup the config server via discovery.** @author Spencer Gibb*/
@ConditionalOnClass(ConfigServicePropertySourceLocator.class)
@ConditionalOnProperty(value = "spring.cloud.config.discovery.enabled", matchIfMissing = false)
@Configuration
@Import({ ConsulAutoConfiguration.class, ConsulDiscoveryClientConfiguration.class})
public class ConsulDiscoveryClientConfigServiceBootstrapConfiguration {@Beanpublic ConsulDiscoveryProperties consulDiscoveryProperties(InetUtils inetUtils) {ConsulDiscoveryProperties properties = new ConsulDiscoveryProperties(inetUtils);// for bootstrap, lifecycle (and hence registration) is not needed, just discovery clientproperties.getLifecycle().setEnabled(false);return properties;}
}