From b001fea325b443ac18a1a5daa6ed7dc1e2982bd7 Mon Sep 17 00:00:00 2001 From: Dave Syer Date: Tue, 10 Nov 2015 14:38:50 +0000 Subject: [PATCH] Re-order configs and add refresh scope for lazy loading so that Eureka InstanceInfo (which is designed to be immutable) can effectively be mutated (by using a different instance) after the dynamic port is available. --- ...ntConfigServiceBootstrapConfiguration.java | 4 +- .../eureka/DiscoveryClientConfiguration.java | 145 ------------------ .../eureka/EurekaClientAutoConfiguration.java | 132 ++++++++++++++-- .../EurekaDiscoveryClientConfiguration.java | 40 ++--- .../eureka/EurekaInstanceConfigBean.java | 33 ++-- ...ntConfigServiceAutoConfigurationTests.java | 17 +- .../ConditionalOnRefreshScopeTests.java | 15 +- .../EurekaClientAutoConfigurationTests.java | 28 +++- 8 files changed, 192 insertions(+), 222 deletions(-) delete mode 100644 spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/DiscoveryClientConfiguration.java diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/config/DiscoveryClientConfigServiceBootstrapConfiguration.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/config/DiscoveryClientConfigServiceBootstrapConfiguration.java index d57e4f24..056f1bd5 100644 --- a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/config/DiscoveryClientConfigServiceBootstrapConfiguration.java +++ b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/config/DiscoveryClientConfigServiceBootstrapConfiguration.java @@ -25,9 +25,7 @@ import org.springframework.cloud.client.ServiceInstance; import org.springframework.cloud.client.discovery.DiscoveryClient; import org.springframework.cloud.config.client.ConfigClientProperties; import org.springframework.cloud.config.client.ConfigServicePropertySourceLocator; -import org.springframework.cloud.netflix.eureka.DiscoveryClientConfiguration; import org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration; -import org.springframework.cloud.netflix.eureka.EurekaDiscoveryClientConfiguration; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import; import org.springframework.context.event.ContextRefreshedEvent; @@ -47,7 +45,7 @@ import lombok.extern.apachecommons.CommonsLog; @ConditionalOnClass({ EurekaClient.class, ConfigServicePropertySourceLocator.class }) @ConditionalOnProperty(value = "spring.cloud.config.discovery.enabled", matchIfMissing = false) @Configuration -@Import({EurekaClientAutoConfiguration.class, DiscoveryClientConfiguration.class}) +@Import(EurekaClientAutoConfiguration.class) @CommonsLog public class DiscoveryClientConfigServiceBootstrapConfiguration { diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/DiscoveryClientConfiguration.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/DiscoveryClientConfiguration.java deleted file mode 100644 index dc8bf1a1..00000000 --- a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/DiscoveryClientConfiguration.java +++ /dev/null @@ -1,145 +0,0 @@ -/* - * 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.netflix.eureka; - -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -import lombok.SneakyThrows; - -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.autoconfigure.condition.AllNestedConditions; -import org.springframework.boot.autoconfigure.condition.AnyNestedCondition; -import org.springframework.boot.autoconfigure.condition.ConditionalOnBean; -import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; -import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; -import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass; -import org.springframework.boot.autoconfigure.condition.SearchStrategy; -import org.springframework.cloud.client.discovery.DiscoveryClient; -import org.springframework.cloud.context.scope.refresh.RefreshScope; -import org.springframework.context.ApplicationContext; -import org.springframework.context.annotation.Bean; -import org.springframework.context.annotation.Conditional; -import org.springframework.context.annotation.Configuration; - -import com.netflix.appinfo.ApplicationInfoManager; -import com.netflix.appinfo.EurekaInstanceConfig; -import com.netflix.discovery.DiscoveryClient.DiscoveryClientOptionalArgs; -import com.netflix.discovery.EurekaClient; -import com.netflix.discovery.EurekaClientConfig; - -/** - * @author Spencer Gibb - */ -@Configuration -public class DiscoveryClientConfiguration { - - @Bean - public DiscoveryClient discoveryClient(EurekaInstanceConfig config, - EurekaClient client) { - return new EurekaDiscoveryClient(config, client); - } - - @Configuration - @ConditionalOnMissingRefreshScope - protected static class EurekaClientConfiguration { - - @Autowired - private ApplicationContext context; - - @Autowired(required = false) - private DiscoveryClientOptionalArgs optionalArgs; - - @Bean(destroyMethod = "shutdown") - @ConditionalOnMissingBean(value = EurekaClient.class, search = SearchStrategy.CURRENT) - @SneakyThrows - public EurekaClient eurekaClient(ApplicationInfoManager applicationInfoManager, - EurekaClientConfig config) { - return new CloudEurekaClient(applicationInfoManager, config, optionalArgs, this.context); - } - } - - @Configuration - @ConditionalOnRefreshScope - protected static class RefreshableEurekaClientConfiguration { - - @Autowired - private ApplicationContext context; - - @Autowired(required = false) - private DiscoveryClientOptionalArgs optionalArgs; - - @Bean(destroyMethod = "shutdown") - @ConditionalOnMissingBean(value = EurekaClient.class, search = SearchStrategy.CURRENT) - @SneakyThrows - @org.springframework.cloud.context.config.annotation.RefreshScope - public EurekaClient eurekaClient(ApplicationInfoManager applicationInfoManager, - EurekaClientConfig config, EurekaInstanceConfig instance) { - return new CloudEurekaClient(applicationInfoManager, config, optionalArgs, this.context); - } - - } - - @Target({ElementType.TYPE, ElementType.METHOD}) - @Retention(RetentionPolicy.RUNTIME) - @Documented - @Conditional(OnMissingRefreshScopeCondition.class) - @interface ConditionalOnMissingRefreshScope { - - } - - @Target({ElementType.TYPE, ElementType.METHOD}) - @Retention(RetentionPolicy.RUNTIME) - @Documented - @Conditional(OnRefreshScopeCondition.class) - @interface ConditionalOnRefreshScope { - - } - - private static class OnMissingRefreshScopeCondition extends AnyNestedCondition { - - public OnMissingRefreshScopeCondition() { - super(ConfigurationPhase.REGISTER_BEAN); - } - - @ConditionalOnMissingClass("org.springframework.cloud.context.scope.refresh.RefreshScope") - static class MissingClass { - } - - @ConditionalOnMissingBean(RefreshScope.class) - static class MissingScope { - } - - } - - private static class OnRefreshScopeCondition extends AllNestedConditions { - - public OnRefreshScopeCondition() { - super(ConfigurationPhase.REGISTER_BEAN); - } - - @ConditionalOnClass(RefreshScope.class) - @ConditionalOnBean(RefreshScope.class) - static class FoundScope { - } - - } - -} diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/EurekaClientAutoConfiguration.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/EurekaClientAutoConfiguration.java index a8841115..0e72f4fe 100644 --- a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/EurekaClientAutoConfiguration.java +++ b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/EurekaClientAutoConfiguration.java @@ -16,31 +16,46 @@ package org.springframework.cloud.netflix.eureka; -import static org.springframework.cloud.util.IdUtils.getDefaultInstanceId; +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.autoconfigure.AutoConfigureAfter; import org.springframework.boot.autoconfigure.AutoConfigureBefore; +import org.springframework.boot.autoconfigure.condition.AllNestedConditions; +import org.springframework.boot.autoconfigure.condition.AnyNestedCondition; +import org.springframework.boot.autoconfigure.condition.ConditionalOnBean; import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; +import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.boot.autoconfigure.condition.SearchStrategy; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.cloud.autoconfigure.RefreshAutoConfiguration; import org.springframework.cloud.client.CommonsClientAutoConfiguration; import org.springframework.cloud.client.actuator.HasFeatures; +import org.springframework.cloud.client.discovery.DiscoveryClient; import org.springframework.cloud.client.discovery.noop.NoopDiscoveryClientAutoConfiguration; +import org.springframework.cloud.context.scope.refresh.RefreshScope; +import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Conditional; import org.springframework.context.annotation.Configuration; import org.springframework.core.env.ConfigurableEnvironment; import com.netflix.appinfo.ApplicationInfoManager; import com.netflix.appinfo.EurekaInstanceConfig; import com.netflix.appinfo.InstanceInfo; +import com.netflix.discovery.DiscoveryClient.DiscoveryClientOptionalArgs; import com.netflix.discovery.EurekaClient; import com.netflix.discovery.EurekaClientConfig; +import static org.springframework.cloud.util.IdUtils.getDefaultInstanceId; + /** * @author Dave Syer * @author Spencer Gibb @@ -77,21 +92,118 @@ public class EurekaClientAutoConfiguration { public EurekaInstanceConfigBean eurekaInstanceConfigBean() { EurekaInstanceConfigBean instance = new EurekaInstanceConfigBean(); instance.setNonSecurePort(this.nonSecurePort); - instance.setInstanceId(getDefaultInstanceId(env)); + instance.setInstanceId(getDefaultInstanceId(this.env)); return instance; } @Bean - @ConditionalOnMissingBean(ApplicationInfoManager.class) - public ApplicationInfoManager applicationInfoManager(EurekaInstanceConfig config, - InstanceInfo instanceInfo) { - return new ApplicationInfoManager(config, instanceInfo); + public DiscoveryClient discoveryClient(EurekaInstanceConfig config, + EurekaClient client) { + return new EurekaDiscoveryClient(config, client); } - @Bean - @ConditionalOnMissingBean(InstanceInfo.class) - public InstanceInfo instanceInfo(EurekaInstanceConfig config) { - return new InstanceInfoFactory().create(config); + @Configuration + @ConditionalOnMissingRefreshScope + protected static class EurekaClientConfiguration { + + @Autowired + private ApplicationContext context; + + @Autowired(required = false) + private DiscoveryClientOptionalArgs optionalArgs; + + @Bean(destroyMethod = "shutdown") + @ConditionalOnMissingBean(value = EurekaClient.class, search = SearchStrategy.CURRENT) + public EurekaClient eurekaClient(ApplicationInfoManager applicationInfoManager, + EurekaClientConfig config) { + return new CloudEurekaClient(applicationInfoManager, config, + this.optionalArgs, this.context); + } + + @Bean + @ConditionalOnMissingBean(value = ApplicationInfoManager.class, search = SearchStrategy.CURRENT) + public ApplicationInfoManager eurekaApplicationInfoManager( + EurekaInstanceConfig config) { + InstanceInfo instanceInfo = new InstanceInfoFactory().create(config); + return new ApplicationInfoManager(config, instanceInfo); + } + + } + + @Configuration + @ConditionalOnRefreshScope + protected static class RefreshableEurekaClientConfiguration { + + @Autowired + private ApplicationContext context; + + @Autowired(required = false) + private DiscoveryClientOptionalArgs optionalArgs; + + @Bean(destroyMethod = "shutdown") + @ConditionalOnMissingBean(value = EurekaClient.class, search = SearchStrategy.CURRENT) + @org.springframework.cloud.context.config.annotation.RefreshScope + public EurekaClient eurekaClient(ApplicationInfoManager applicationInfoManager, + EurekaClientConfig config, EurekaInstanceConfig instance) { + applicationInfoManager.getInfo(); // force initialization + return new CloudEurekaClient(applicationInfoManager, config, + this.optionalArgs, this.context); + } + + @Bean + @ConditionalOnMissingBean(value = ApplicationInfoManager.class, search = SearchStrategy.CURRENT) + @org.springframework.cloud.context.config.annotation.RefreshScope + public ApplicationInfoManager eurekaApplicationInfoManager( + EurekaInstanceConfig config) { + InstanceInfo instanceInfo = new InstanceInfoFactory().create(config); + return new ApplicationInfoManager(config, instanceInfo); + } + + } + + @Target({ ElementType.TYPE, ElementType.METHOD }) + @Retention(RetentionPolicy.RUNTIME) + @Documented + @Conditional(OnMissingRefreshScopeCondition.class) + @interface ConditionalOnMissingRefreshScope { + + } + + @Target({ ElementType.TYPE, ElementType.METHOD }) + @Retention(RetentionPolicy.RUNTIME) + @Documented + @Conditional(OnRefreshScopeCondition.class) + @interface ConditionalOnRefreshScope { + + } + + private static class OnMissingRefreshScopeCondition extends AnyNestedCondition { + + public OnMissingRefreshScopeCondition() { + super(ConfigurationPhase.REGISTER_BEAN); + } + + @ConditionalOnMissingClass("org.springframework.cloud.context.scope.refresh.RefreshScope") + static class MissingClass { + } + + @ConditionalOnMissingBean(RefreshAutoConfiguration.class) + static class MissingScope { + } + + } + + private static class OnRefreshScopeCondition extends AllNestedConditions { + + public OnRefreshScopeCondition() { + super(ConfigurationPhase.REGISTER_BEAN); + } + + @ConditionalOnClass(RefreshScope.class) + @ConditionalOnBean(RefreshAutoConfiguration.class) + static class FoundScope { + } + } } diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/EurekaDiscoveryClientConfiguration.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/EurekaDiscoveryClientConfiguration.java index 04ec557d..65127ebd 100644 --- a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/EurekaDiscoveryClientConfiguration.java +++ b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/EurekaDiscoveryClientConfiguration.java @@ -16,13 +16,9 @@ package org.springframework.cloud.netflix.eureka; -import java.lang.reflect.Field; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; -import lombok.SneakyThrows; -import lombok.extern.apachecommons.CommonsLog; - import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.actuate.endpoint.Endpoint; import org.springframework.boot.actuate.health.HealthAggregator; @@ -40,7 +36,6 @@ import org.springframework.context.ApplicationContext; import org.springframework.context.SmartLifecycle; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; -import org.springframework.context.annotation.Import; import org.springframework.context.event.ContextClosedEvent; import org.springframework.context.event.EventListener; import org.springframework.core.Ordered; @@ -48,11 +43,11 @@ import org.springframework.core.Ordered; import com.netflix.appinfo.ApplicationInfoManager; import com.netflix.appinfo.EurekaInstanceConfig; import com.netflix.appinfo.HealthCheckHandler; -import com.netflix.appinfo.InstanceInfo; import com.netflix.appinfo.InstanceInfo.InstanceStatus; import com.netflix.discovery.EurekaClient; import com.netflix.discovery.EurekaClientConfig; -import org.springframework.util.ReflectionUtils; + +import lombok.extern.apachecommons.CommonsLog; /** * @author Dave Syer @@ -64,7 +59,6 @@ import org.springframework.util.ReflectionUtils; @EnableConfigurationProperties @ConditionalOnClass(EurekaClientConfig.class) @ConditionalOnProperty(value = "eureka.client.enabled", matchIfMissing = true) -@Import(DiscoveryClientConfiguration.class) @CommonsLog public class EurekaDiscoveryClientConfiguration implements SmartLifecycle, Ordered { @@ -89,23 +83,19 @@ public class EurekaDiscoveryClientConfiguration implements SmartLifecycle, Order @Autowired private EurekaClient eurekaClient; - @Autowired - private InstanceInfo instanceInfo; - @Override public void start() { // only set the port if the nonSecurePort is 0 and this.port != 0 if (this.port.get() != 0 && this.instanceConfig.getNonSecurePort() == 0) { this.instanceConfig.setNonSecurePort(this.port.get()); - setInstanceInfoPort(); } // only initialize if nonSecurePort is greater than 0 and it isn't already running // because of containerPortInitializer below if (!this.running.get() && this.instanceConfig.getNonSecurePort() > 0) { - this.eurekaClient.getApplications(); // force initialization - + maybeInitializeClient(); + if (log.isInfoEnabled()) { log.info("Registering application " + this.instanceConfig.getAppname() + " with eureka with status " @@ -124,22 +114,21 @@ public class EurekaDiscoveryClientConfiguration implements SmartLifecycle, Order } } - @SneakyThrows - private void setInstanceInfoPort() { - Field port = ReflectionUtils.findField(InstanceInfo.class, "port"); - ReflectionUtils.makeAccessible(port); - port.setInt(this.instanceInfo, this.port.get()); + private void maybeInitializeClient() { + // force initialization of possibly scoped proxies + this.applicationInfoManager.getInfo(); + this.eurekaClient.getApplications(); } @Override public void stop() { if (this.applicationInfoManager.getInfo() != null) { - + if (log.isInfoEnabled()) { log.info("Unregistering application " + this.instanceConfig.getAppname() + " with eureka with status DOWN"); } - + this.applicationInfoManager.setInstanceStatus(InstanceStatus.DOWN); } this.running.set(false); @@ -174,9 +163,12 @@ public class EurekaDiscoveryClientConfiguration implements SmartLifecycle, Order @EventListener(EmbeddedServletContainerInitializedEvent.class) public void onApplicationEvent(EmbeddedServletContainerInitializedEvent event) { // TODO: take SSL into account when Spring Boot 1.2 is available - EurekaDiscoveryClientConfiguration.this.port.compareAndSet(0, - event.getEmbeddedServletContainer().getPort()); - EurekaDiscoveryClientConfiguration.this.start(); + int localPort = event.getEmbeddedServletContainer().getPort(); + if (this.port.get() == 0) { + log.info("Updating port to " + localPort); + this.port.compareAndSet(0, localPort); + start(); + } } @Configuration diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/EurekaInstanceConfigBean.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/EurekaInstanceConfigBean.java index 92b2b3a9..bf65fd99 100644 --- a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/EurekaInstanceConfigBean.java +++ b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/eureka/EurekaInstanceConfigBean.java @@ -16,18 +16,9 @@ package org.springframework.cloud.netflix.eureka; -import static org.springframework.cloud.util.InetUtils.getFirstNonLoopbackHostInfo; - import java.util.HashMap; import java.util.Map; -import lombok.AccessLevel; -import lombok.Data; -import lombok.Getter; -import lombok.Setter; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.cloud.util.InetUtils.HostInfo; @@ -36,6 +27,13 @@ import com.netflix.appinfo.DataCenterInfo; import com.netflix.appinfo.InstanceInfo.InstanceStatus; import com.netflix.appinfo.MyDataCenterInfo; +import static org.springframework.cloud.util.InetUtils.getFirstNonLoopbackHostInfo; + +import lombok.AccessLevel; +import lombok.Data; +import lombok.Getter; +import lombok.Setter; + /** * @author Dave Syer * @author Spencer Gibb @@ -44,8 +42,6 @@ import com.netflix.appinfo.MyDataCenterInfo; @ConfigurationProperties("eureka.instance") public class EurekaInstanceConfigBean implements CloudEurekaInstanceConfig { - private static final Log logger = LogFactory.getLog(EurekaInstanceConfigBean.class); - @Getter(AccessLevel.PRIVATE) @Setter(AccessLevel.PRIVATE) private HostInfo hostInfo = getFirstNonLoopbackHostInfo(); @@ -72,7 +68,7 @@ public class EurekaInstanceConfigBean implements CloudEurekaInstanceConfig { @Value("${spring.application.name:unknown}") private String virtualHostName; - private String instanceId; + private String instanceId; private String secureVirtualHostName; @@ -80,7 +76,8 @@ public class EurekaInstanceConfigBean implements CloudEurekaInstanceConfig { private Map metadataMap = new HashMap<>(); - private DataCenterInfo dataCenterInfo = new MyDataCenterInfo(DataCenterInfo.Name.MyOwn); + private DataCenterInfo dataCenterInfo = new MyDataCenterInfo( + DataCenterInfo.Name.MyOwn); private String ipAddress = this.hostInfo.getIpAddress(); @@ -110,15 +107,15 @@ public class EurekaInstanceConfigBean implements CloudEurekaInstanceConfig { return getHostName(false); } - @Override - public String getInstanceId() { + @Override + public String getInstanceId() { if (this.instanceId == null && this.metadataMap != null) { return this.metadataMap.get("instanceId"); } - return instanceId; - } + return this.instanceId; + } - @Override + @Override public boolean getSecurePortEnabled() { return this.securePortEnabled; } diff --git a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/config/DiscoveryClientConfigServiceAutoConfigurationTests.java b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/config/DiscoveryClientConfigServiceAutoConfigurationTests.java index 2f1d94e0..fd9ef9b3 100644 --- a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/config/DiscoveryClientConfigServiceAutoConfigurationTests.java +++ b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/config/DiscoveryClientConfigServiceAutoConfigurationTests.java @@ -16,10 +16,6 @@ package org.springframework.cloud.netflix.config; -import static org.junit.Assert.assertEquals; -import static org.mockito.BDDMockito.given; -import static org.mockito.Mockito.times; - import org.junit.After; import org.junit.Test; import org.mockito.Mockito; @@ -36,6 +32,10 @@ import com.netflix.appinfo.ApplicationInfoManager; import com.netflix.appinfo.InstanceInfo; import com.netflix.discovery.EurekaClient; +import static org.junit.Assert.assertEquals; +import static org.mockito.BDDMockito.given; +import static org.mockito.Mockito.times; + /** * @author Dave Syer */ @@ -57,8 +57,7 @@ public class DiscoveryClientConfigServiceAutoConfigurationTests { public void onWhenRequested() throws Exception { setup("spring.cloud.config.discovery.enabled=true", "eureka.instance.metadataMap.foo:bar", - "eureka.instance.nonSecurePort:7001", - "eureka.instance.hostname:foo"); + "eureka.instance.nonSecurePort:7001", "eureka.instance.hostname:foo"); assertEquals(1, this.context.getBeanNamesForType( DiscoveryClientConfigServiceAutoConfiguration.class).length); EurekaClient eurekaClient = this.context.getParent().getBean(EurekaClient.class); @@ -93,10 +92,10 @@ public class DiscoveryClientConfigServiceAutoConfigurationTests { protected static class EnvironmentKnobbler { @Bean - public EurekaClient eurekaClient(InstanceInfo info) { + public EurekaClient eurekaClient(ApplicationInfoManager manager) { + InstanceInfo info = manager.getInfo(); EurekaClient client = Mockito.mock(EurekaClient.class); - given(client.getNextServerFromEureka("CONFIGSERVER", false)) - .willReturn(info); + given(client.getNextServerFromEureka("CONFIGSERVER", false)).willReturn(info); return client; } diff --git a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/eureka/ConditionalOnRefreshScopeTests.java b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/eureka/ConditionalOnRefreshScopeTests.java index cd653304..a1f70560 100644 --- a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/eureka/ConditionalOnRefreshScopeTests.java +++ b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/eureka/ConditionalOnRefreshScopeTests.java @@ -16,19 +16,20 @@ package org.springframework.cloud.netflix.eureka; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; - import org.junit.After; import org.junit.Test; +import org.springframework.boot.Banner.Mode; import org.springframework.boot.builder.SpringApplicationBuilder; import org.springframework.cloud.autoconfigure.RefreshAutoConfiguration; -import org.springframework.cloud.netflix.eureka.DiscoveryClientConfiguration.ConditionalOnRefreshScope; +import org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration.ConditionalOnRefreshScope; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; + /** * @author Dave Syer * @@ -47,7 +48,7 @@ public class ConditionalOnRefreshScopeTests { @Test public void refreshScopeIncluded() { this.context = new SpringApplicationBuilder(RefreshAutoConfiguration.class, - Beans.class).web(false).showBanner(false).run(); + Beans.class).web(false).bannerMode(Mode.OFF).run(); assertNotNull(this.context.getBean( org.springframework.cloud.context.scope.refresh.RefreshScope.class)); assertEquals("foo", this.context.getBean("foo")); @@ -56,7 +57,7 @@ public class ConditionalOnRefreshScopeTests { @Test public void refreshScopeNotIncluded() { this.context = new SpringApplicationBuilder(Beans.class).web(false) - .showBanner(false).run(); + .bannerMode(Mode.OFF).run(); assertFalse(this.context.containsBean("foo")); } diff --git a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/eureka/EurekaClientAutoConfigurationTests.java b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/eureka/EurekaClientAutoConfigurationTests.java index d4a04c0e..6493e829 100644 --- a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/eureka/EurekaClientAutoConfigurationTests.java +++ b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/eureka/EurekaClientAutoConfigurationTests.java @@ -18,8 +18,10 @@ package org.springframework.cloud.netflix.eureka; import org.junit.After; import org.junit.Test; +import org.springframework.aop.scope.ScopedProxyFactoryBean; import org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfiguration; import org.springframework.boot.context.properties.EnableConfigurationProperties; +import org.springframework.cloud.autoconfigure.RefreshAutoConfiguration; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import; @@ -40,25 +42,39 @@ public class EurekaClientAutoConfigurationTests { } } - private void setupContext() { - this.context.register(PropertyPlaceholderAutoConfiguration.class, - TestConfiguration.class); + private void setupContext(Class... config) { + this.context.register(PropertyPlaceholderAutoConfiguration.class); + for (Class value : config) { + this.context.register(value); + } + this.context.register(TestConfiguration.class); this.context.refresh(); } @Test - public void nonSecurePort2() { + public void nonSecurePortPeriods() { testNonSecurePort("server.port"); } @Test - public void nonSecurePort3() { + public void nonSecurePortUnderscores() { testNonSecurePort("SERVER_PORT"); } @Test - public void nonSecurePort4() { + public void nonSecurePort() { testNonSecurePort("PORT"); + assertEquals("eurekaClient", + this.context.getBeanDefinition("eurekaClient").getFactoryMethodName()); + } + + @Test + public void refreshScopedBeans() { + setupContext(RefreshAutoConfiguration.class); + assertEquals(ScopedProxyFactoryBean.class.getName(), + this.context.getBeanDefinition("eurekaClient").getBeanClassName()); + assertEquals(ScopedProxyFactoryBean.class.getName(), this.context + .getBeanDefinition("eurekaApplicationInfoManager").getBeanClassName()); } private void testNonSecurePort(String propName) {