From af0b24d1a213bef7f481a247b705846eb358c195 Mon Sep 17 00:00:00 2001 From: Spencer Gibb Date: Wed, 28 Jan 2015 12:33:32 -0700 Subject: [PATCH] use LoadBalancerBuilder so all parts of the LoadBalancer can be injected via Spring. This includes support for: ServerList, ServerListFilter, IRule, IPing and IClientConfig. Eliminates custom wrapping of ServerList. fixes gh-185 --- .../ribbon/RibbonClientConfiguration.java | 41 +++++- .../eureka/DomainExtractingServerList.java | 29 ++--- .../EurekaRibbonClientConfiguration.java | 75 ++++------- ...bonClientPreprocessorIntegrationTests.java | 50 +++----- ...PreprocessorOverridesIntegrationTests.java | 120 ++++++++++++++++++ ...onClientsPreprocessorIntegrationTests.java | 24 +--- .../DomainExtractingServerListTests.java | 12 +- .../EurekaRibbonClientConfigurationTests.java | 8 +- ...bonClientPreprocessorIntegrationTests.java | 20 ++- 9 files changed, 245 insertions(+), 134 deletions(-) create mode 100644 spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonClientPreprocessorOverridesIntegrationTests.java diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonClientConfiguration.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonClientConfiguration.java index 77b86e4e..37101b99 100644 --- a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonClientConfiguration.java +++ b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonClientConfiguration.java @@ -24,10 +24,7 @@ import org.springframework.context.annotation.Configuration; import com.netflix.client.config.DefaultClientConfigImpl; import com.netflix.client.config.IClientConfig; -import com.netflix.loadbalancer.ILoadBalancer; -import com.netflix.loadbalancer.Server; -import com.netflix.loadbalancer.ServerListFilter; -import com.netflix.loadbalancer.ZoneAwareLoadBalancer; +import com.netflix.loadbalancer.*; import com.netflix.niws.client.http.RestClient; import com.netflix.servo.monitor.Monitors; @@ -53,6 +50,29 @@ public class RibbonClientConfiguration { return config; } + @Bean + @ConditionalOnMissingBean + public IRule ribbonRule(IClientConfig config) { + ZoneAvoidanceRule rule = new ZoneAvoidanceRule(); + rule.initWithNiwsConfig(config); + return rule; + } + + @Bean + @ConditionalOnMissingBean + public IPing ribbonPing(IClientConfig config) { + // TODO: use PingUrl + return new NoOpPing(); + } + + @Bean + @ConditionalOnMissingBean + public ServerList ribbonServerList(IClientConfig config) { + ConfigurationBasedServerList serverList = new ConfigurationBasedServerList(); + serverList.initWithNiwsConfig(config); + return serverList; + } + @Bean @ConditionalOnMissingBean public RestClient ribbonRestClient(IClientConfig config, ILoadBalancer loadBalancer) { @@ -65,9 +85,16 @@ public class RibbonClientConfiguration { @Bean @ConditionalOnMissingBean public ILoadBalancer ribbonLoadBalancer(IClientConfig config, - ServerListFilter filter) { - ZoneAwareLoadBalancer balancer = new ZoneAwareLoadBalancer<>(config); - balancer.setFilter(filter); + ServerList serverList, + ServerListFilter serverListFilter, + IRule rule, IPing ping) { + ZoneAwareLoadBalancer balancer = LoadBalancerBuilder.newBuilder() + .withClientConfig(config) + .withRule(rule) + .withPing(ping) + .withServerListFilter(serverListFilter) + .withDynamicServerList(serverList) + .buildDynamicServerListLoadBalancer(); return balancer; } diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/eureka/DomainExtractingServerList.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/eureka/DomainExtractingServerList.java index c0edd5a6..30d7dcf8 100644 --- a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/eureka/DomainExtractingServerList.java +++ b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/eureka/DomainExtractingServerList.java @@ -34,15 +34,15 @@ import com.netflix.niws.loadbalancer.DiscoveryEnabledServer; /** * @author Dave Syer */ -public class DomainExtractingServerList implements ServerList { +public class DomainExtractingServerList implements ServerList { - private ServerList list; + private ServerList list; private IClientConfig clientConfig; private boolean approximateZoneFromHostname; - public DomainExtractingServerList(ServerList list, + public DomainExtractingServerList(ServerList list, IClientConfig clientConfig, boolean approximateZoneFromHostname) { this.list = list; this.clientConfig = clientConfig; @@ -50,31 +50,26 @@ public class DomainExtractingServerList implements ServerList { } @Override - public List getInitialListOfServers() { - List servers = setZones(this.list.getInitialListOfServers()); + public List getInitialListOfServers() { + List servers = setZones(this.list.getInitialListOfServers()); return servers; } @Override - public List getUpdatedListOfServers() { - List servers = setZones(this.list.getUpdatedListOfServers()); + public List getUpdatedListOfServers() { + List servers = setZones(this.list.getUpdatedListOfServers()); return servers; } - private List setZones(List servers) { - List result = new ArrayList<>(); + private List setZones(List servers) { + List result = new ArrayList<>(); boolean isSecure = this.clientConfig.getPropertyAsBoolean( CommonClientConfigKey.IsSecure, Boolean.TRUE); boolean shouldUseIpAddr = this.clientConfig.getPropertyAsBoolean( CommonClientConfigKey.UseIPAddrForServer, Boolean.FALSE); - for (Server server : servers) { - if (server instanceof DiscoveryEnabledServer) { - result.add(new DomainExtractingServer((DiscoveryEnabledServer) server, - isSecure, shouldUseIpAddr, this.approximateZoneFromHostname)); - } - else { - result.add(server); - } + for (DiscoveryEnabledServer server : servers) { + result.add(new DomainExtractingServer(server, + isSecure, shouldUseIpAddr, this.approximateZoneFromHostname)); } return result; } diff --git a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/eureka/EurekaRibbonClientConfiguration.java b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/eureka/EurekaRibbonClientConfiguration.java index 28fcf51c..5c57e4df 100644 --- a/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/eureka/EurekaRibbonClientConfiguration.java +++ b/spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/ribbon/eureka/EurekaRibbonClientConfiguration.java @@ -16,31 +16,27 @@ package org.springframework.cloud.netflix.ribbon.eureka; +import static com.netflix.client.config.CommonClientConfigKey.DeploymentContextBasedVipAddresses; +import static com.netflix.client.config.CommonClientConfigKey.EnableZoneAffinity; + import javax.annotation.PostConstruct; -import org.springframework.beans.BeansException; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; -import org.springframework.beans.factory.config.BeanPostProcessor; -import org.springframework.cloud.netflix.ribbon.ZonePreferenceServerListFilter; +import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; +import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; +import com.netflix.client.config.IClientConfig; import com.netflix.config.ConfigurationManager; import com.netflix.config.DeploymentContext.ContextKey; import com.netflix.config.DynamicPropertyFactory; import com.netflix.config.DynamicStringProperty; import com.netflix.discovery.EurekaClientConfig; -import com.netflix.loadbalancer.DynamicServerListLoadBalancer; -import com.netflix.loadbalancer.Server; +import com.netflix.loadbalancer.IPing; import com.netflix.loadbalancer.ServerList; -import com.netflix.loadbalancer.ZoneAvoidanceRule; import com.netflix.niws.loadbalancer.DiscoveryEnabledNIWSServerList; - -import static com.netflix.client.config.CommonClientConfigKey.DeploymentContextBasedVipAddresses; -import static com.netflix.client.config.CommonClientConfigKey.EnableZoneAffinity; -import static com.netflix.client.config.CommonClientConfigKey.NFLoadBalancerRuleClassName; -import static com.netflix.client.config.CommonClientConfigKey.NIWSServerListClassName; -import static com.netflix.client.config.CommonClientConfigKey.NIWSServerListFilterClassName; +import com.netflix.niws.loadbalancer.NIWSDiscoveryPing; /** * Preprocessor that configures defaults for eureka-discovered ribbon clients. Such as: @@ -51,7 +47,7 @@ import static com.netflix.client.config.CommonClientConfigKey.NIWSServerListFilt * @author Dave Syer */ @Configuration -public class EurekaRibbonClientConfiguration implements BeanPostProcessor { +public class EurekaRibbonClientConfiguration { @Value("${ribbon.eureka.approximateZoneFromHostname:false}") private boolean approximateZoneFromHostname = false; @@ -75,6 +71,22 @@ public class EurekaRibbonClientConfiguration implements BeanPostProcessor { this.serviceId = serviceId; } + @Bean + @ConditionalOnMissingBean + public IPing ribbonPing(IClientConfig config) { + NIWSDiscoveryPing ping = new NIWSDiscoveryPing(); + ping.initWithNiwsConfig(config); + return ping; + } + + @Bean + @ConditionalOnMissingBean + public ServerList ribbonServerList(IClientConfig config) { + DiscoveryEnabledNIWSServerList discoveryServerList = new DiscoveryEnabledNIWSServerList(config); + DomainExtractingServerList serverList = new DomainExtractingServerList(discoveryServerList, config, this.approximateZoneFromHostname); + return serverList; + } + @PostConstruct public void preprocess() { if (this.clientConfig != null @@ -89,47 +101,10 @@ public class EurekaRibbonClientConfiguration implements BeanPostProcessor { zone); } } - // TODO: should this look more like hibernate spring boot props? - setProp(this.serviceId, NIWSServerListClassName.key(), - DiscoveryEnabledNIWSServerList.class.getName()); - // FIXME: what should this be? setProp(this.serviceId, DeploymentContextBasedVipAddresses.key(), this.serviceId); - setProp(this.serviceId, NFLoadBalancerRuleClassName.key(), - ZoneAvoidanceRule.class.getName()); - setProp(this.serviceId, NIWSServerListFilterClassName.key(), - ZonePreferenceServerListFilter.class.getName()); setProp(this.serviceId, EnableZoneAffinity.key(), "true"); } - @Override - public Object postProcessBeforeInitialization(Object bean, String beanName) - throws BeansException { - return bean; - } - - @Override - public Object postProcessAfterInitialization(Object bean, String beanName) - throws BeansException { - if (bean instanceof DynamicServerListLoadBalancer) { - wrapServerList((DynamicServerListLoadBalancer) bean); - } - return bean; - } - - private void wrapServerList(DynamicServerListLoadBalancer balancer) { - @SuppressWarnings("unchecked") - DynamicServerListLoadBalancer dynamic = (DynamicServerListLoadBalancer) balancer; - ServerList list = dynamic.getServerListImpl(); - if (!(list instanceof DomainExtractingServerList)) { - // This is optional: you can use the native Eureka AWS features as long as - // the server zone is populated. TODO: verify that we back off if AWS - // metadata *is* available. - // @see com.netflix.appinfo.AmazonInfo.Builder - dynamic.setServerListImpl(new DomainExtractingServerList(list, dynamic - .getClientConfig(), this.approximateZoneFromHostname)); - } - } - protected void setProp(String serviceId, String suffix, String value) { // how to set the namespace properly? String key = getKey(serviceId, suffix); diff --git a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonClientPreprocessorIntegrationTests.java b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonClientPreprocessorIntegrationTests.java index 0df53fa1..3fa09fd5 100644 --- a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonClientPreprocessorIntegrationTests.java +++ b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonClientPreprocessorIntegrationTests.java @@ -16,8 +16,6 @@ package org.springframework.cloud.netflix.ribbon; -import static org.junit.Assert.assertEquals; - import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; @@ -25,15 +23,12 @@ import org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfigurati import org.springframework.boot.test.SpringApplicationConfiguration; import org.springframework.cloud.netflix.archaius.ArchaiusAutoConfiguration; import org.springframework.cloud.netflix.ribbon.RibbonClientPreprocessorIntegrationTests.PlainConfiguration; -import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import; import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import com.netflix.loadbalancer.AvailabilityFilteringRule; -import com.netflix.loadbalancer.Server; -import com.netflix.loadbalancer.ZoneAwareLoadBalancer; +import com.netflix.loadbalancer.*; /** * @author Dave Syer @@ -47,38 +42,35 @@ public class RibbonClientPreprocessorIntegrationTests { private SpringClientFactory factory; @Test - public void ruleDefaultsToAvailability() throws Exception { - @SuppressWarnings("unchecked") - ZoneAwareLoadBalancer loadBalancer = (ZoneAwareLoadBalancer) this.factory - .getLoadBalancer("foo"); - AvailabilityFilteringRule.class.cast(loadBalancer.getRule()); + public void ruleDefaultsToZoneAvoidance() throws Exception { + ZoneAvoidanceRule.class.cast(getLoadBalancer().getRule()); } @Test - public void serverListFilterOverride() throws Exception { - @SuppressWarnings("unchecked") - ZoneAwareLoadBalancer loadBalancer = (ZoneAwareLoadBalancer) this.factory - .getLoadBalancer("foo"); - assertEquals("myTestZone", - ZonePreferenceServerListFilter.class.cast(loadBalancer.getFilter()) - .getZone()); + public void serverListFilterDefaultsToZonePreference() throws Exception { + ZonePreferenceServerListFilter.class.cast(getLoadBalancer().getFilter()); + } + + @Test + public void pingDefaultsToNoOp() throws Exception { + NoOpPing.class.cast(getLoadBalancer().getPing()); + } + + @Test + public void serverListDefaultsToConfigurationBased() throws Exception { + ConfigurationBasedServerList.class.cast(getLoadBalancer().getServerListImpl()); + } + + @SuppressWarnings("unchecked") + private ZoneAwareLoadBalancer getLoadBalancer() { + return (ZoneAwareLoadBalancer) this.factory.getLoadBalancer("foo"); } @Configuration - @RibbonClient(name = "foo", configuration = FooConfiguration.class) + @RibbonClient(name = "foo") @Import({ PropertyPlaceholderAutoConfiguration.class, ArchaiusAutoConfiguration.class, RibbonAutoConfiguration.class }) protected static class PlainConfiguration { } - @Configuration - protected static class FooConfiguration { - @Bean - public ZonePreferenceServerListFilter serverListFilter() { - ZonePreferenceServerListFilter filter = new ZonePreferenceServerListFilter(); - filter.setZone("myTestZone"); - return filter; - } - } - } diff --git a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonClientPreprocessorOverridesIntegrationTests.java b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonClientPreprocessorOverridesIntegrationTests.java new file mode 100644 index 00000000..40ce9c0a --- /dev/null +++ b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonClientPreprocessorOverridesIntegrationTests.java @@ -0,0 +1,120 @@ +/* + * 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.netflix.ribbon; + +import static org.junit.Assert.assertEquals; + +import com.netflix.client.config.IClientConfig; +import com.netflix.loadbalancer.*; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfiguration; +import org.springframework.boot.test.SpringApplicationConfiguration; +import org.springframework.cloud.netflix.archaius.ArchaiusAutoConfiguration; +import org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Import; +import org.springframework.test.annotation.DirtiesContext; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +/** + * @author Dave Syer + */ +@RunWith(SpringJUnit4ClassRunner.class) +@SpringApplicationConfiguration(classes = RibbonClientPreprocessorOverridesIntegrationTests.TestConfiguration.class) +@DirtiesContext +public class RibbonClientPreprocessorOverridesIntegrationTests { + + @Autowired + private SpringClientFactory factory; + + @Test + public void ruleOverridesToRandom() throws Exception { + RandomRule.class.cast(getLoadBalancer().getRule()); + } + + @Test + public void pingOverridesToDummy() throws Exception { + DummyPing.class.cast(getLoadBalancer().getPing()); + } + + @Test + public void serverListOverridesToMy() throws Exception { + MyServiceList.class.cast(getLoadBalancer().getServerListImpl()); + } + + @SuppressWarnings("unchecked") + private ZoneAwareLoadBalancer getLoadBalancer() { + return (ZoneAwareLoadBalancer) this.factory + .getLoadBalancer("foo"); + } + + @Test + public void serverListFilterOverride() throws Exception { + ServerListFilter filter = getLoadBalancer().getFilter(); + assertEquals("MyTestZone", + ZonePreferenceServerListFilter.class.cast(filter) + .getZone()); + } + + @Configuration + @RibbonClient(name = "foo", configuration = FooConfiguration.class) + @Import({ PropertyPlaceholderAutoConfiguration.class, + ArchaiusAutoConfiguration.class, EurekaClientAutoConfiguration.class, + RibbonAutoConfiguration.class}) + protected static class TestConfiguration { + } + + @Configuration + public static class FooConfiguration { + + public FooConfiguration() { + System.out.println("here"); + } + + @Bean + public IRule ribbonRule() { + return new RandomRule(); + } + + @Bean + public IPing ribbonPing() { + return new DummyPing(); + } + + @Bean + public ServerList ribbonServerList(IClientConfig config) { + return new MyServiceList(config); + } + + @Bean + public ZonePreferenceServerListFilter serverListFilter() { + ZonePreferenceServerListFilter filter = new ZonePreferenceServerListFilter(); + filter.setZone("MyTestZone"); + return filter; + } + } + + public static class MyServiceList extends ConfigurationBasedServerList { + public MyServiceList(IClientConfig config) { + super.initWithNiwsConfig(config); + } + } + +} diff --git a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonClientsPreprocessorIntegrationTests.java b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonClientsPreprocessorIntegrationTests.java index 67daf0ed..2108fb08 100644 --- a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonClientsPreprocessorIntegrationTests.java +++ b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/RibbonClientsPreprocessorIntegrationTests.java @@ -24,8 +24,6 @@ import org.springframework.boot.test.SpringApplicationConfiguration; import org.springframework.cloud.netflix.archaius.ArchaiusAutoConfiguration; import org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration; import org.springframework.cloud.netflix.ribbon.RibbonClientsPreprocessorIntegrationTests.TestConfiguration; -import org.springframework.cloud.netflix.ribbon.eureka.DomainExtractingServerList; -import org.springframework.cloud.netflix.ribbon.eureka.RibbonEurekaAutoConfiguration; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import; @@ -50,28 +48,20 @@ public class RibbonClientsPreprocessorIntegrationTests { private SpringClientFactory factory; @Test - public void serverListIsWrapped() throws Exception { - @SuppressWarnings("unchecked") - ZoneAwareLoadBalancer loadBalancer = (ZoneAwareLoadBalancer) this.factory - .getLoadBalancer("foo"); - DomainExtractingServerList.class.cast(loadBalancer.getServerListImpl()); + public void ruleDefaultsToZoneAvoidance() throws Exception { + ZoneAvoidanceRule.class.cast(getLoadBalancer().getRule()); } - @Test - public void ruleDefaultsToZoneAvoidance() throws Exception { - @SuppressWarnings("unchecked") - ZoneAwareLoadBalancer loadBalancer = (ZoneAwareLoadBalancer) this.factory + @SuppressWarnings("unchecked") + private ZoneAwareLoadBalancer getLoadBalancer() { + return (ZoneAwareLoadBalancer) this.factory .getLoadBalancer("foo"); - ZoneAvoidanceRule.class.cast(loadBalancer.getRule()); } @Test public void serverListFilterOverride() throws Exception { - @SuppressWarnings("unchecked") - ZoneAwareLoadBalancer loadBalancer = (ZoneAwareLoadBalancer) this.factory - .getLoadBalancer("foo"); assertEquals("myTestZone", - ZonePreferenceServerListFilter.class.cast(loadBalancer.getFilter()) + ZonePreferenceServerListFilter.class.cast(getLoadBalancer().getFilter()) .getZone()); } @@ -79,7 +69,7 @@ public class RibbonClientsPreprocessorIntegrationTests { @RibbonClients(@RibbonClient(name = "foo", configuration = FooConfiguration.class)) @Import({ PropertyPlaceholderAutoConfiguration.class, ArchaiusAutoConfiguration.class, EurekaClientAutoConfiguration.class, - RibbonAutoConfiguration.class, RibbonEurekaAutoConfiguration.class }) + RibbonAutoConfiguration.class}) protected static class TestConfiguration { } diff --git a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/eureka/DomainExtractingServerListTests.java b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/eureka/DomainExtractingServerListTests.java index 9cd532d8..5bd0a67c 100644 --- a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/eureka/DomainExtractingServerListTests.java +++ b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/eureka/DomainExtractingServerListTests.java @@ -54,7 +54,7 @@ public class DomainExtractingServerListTests { public void testDomainExtractingServer() { DomainExtractingServerList serverList = getDomainExtractingServerList( new DefaultClientConfigImpl(), true); - List servers = serverList.getInitialListOfServers(); + List servers = serverList.getInitialListOfServers(); assertNotNull("servers was null", servers); assertEquals("servers was not size 1", 1, servers.size()); DomainExtractingServer des = assertDomainExtractingServer(servers, ZONE); @@ -65,14 +65,14 @@ public class DomainExtractingServerListTests { public void testDomainExtractingServerDontApproximateZone() { DomainExtractingServerList serverList = getDomainExtractingServerList( new DefaultClientConfigImpl(), false); - List servers = serverList.getInitialListOfServers(); + List servers = serverList.getInitialListOfServers(); assertNotNull("servers was null", servers); assertEquals("servers was not size 1", 1, servers.size()); DomainExtractingServer des = assertDomainExtractingServer(servers, null); assertEquals("hostPort was wrong", HOST_NAME + ":" + PORT, des.getHostPort()); } - protected DomainExtractingServer assertDomainExtractingServer(List servers, + protected DomainExtractingServer assertDomainExtractingServer(List servers, String zone) { Server actualServer = servers.get(0); assertTrue("server was not a DomainExtractingServer", @@ -89,7 +89,7 @@ public class DomainExtractingServerListTests { config.setProperty(CommonClientConfigKey.UseIPAddrForServer, true); DomainExtractingServerList serverList = getDomainExtractingServerList(config, true); - List servers = serverList.getInitialListOfServers(); + List servers = serverList.getInitialListOfServers(); assertNotNull("servers was null", servers); assertEquals("servers was not size 1", 1, servers.size()); DomainExtractingServer des = assertDomainExtractingServer(servers, ZONE); @@ -100,7 +100,7 @@ public class DomainExtractingServerListTests { DefaultClientConfigImpl config, boolean approximateZoneFromHostname) { DiscoveryEnabledServer server = mock(DiscoveryEnabledServer.class); @SuppressWarnings("unchecked") - ServerList originalServerList = mock(ServerList.class); + ServerList originalServerList = mock(ServerList.class); InstanceInfo instanceInfo = mock(InstanceInfo.class); given(server.getInstanceInfo()).willReturn(instanceInfo); given(server.getHost()).willReturn(HOST_NAME); @@ -111,7 +111,7 @@ public class DomainExtractingServerListTests { given(instanceInfo.getIPAddr()).willReturn(IP_ADDR); given(instanceInfo.getPort()).willReturn(PORT); given(originalServerList.getInitialListOfServers()).willReturn( - Arrays. asList(server)); + Arrays.asList(server)); return new DomainExtractingServerList(originalServerList, config, approximateZoneFromHostname); } diff --git a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/eureka/EurekaRibbonClientConfigurationTests.java b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/eureka/EurekaRibbonClientConfigurationTests.java index 0aeaaed7..6c655a15 100644 --- a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/eureka/EurekaRibbonClientConfigurationTests.java +++ b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/eureka/EurekaRibbonClientConfigurationTests.java @@ -26,12 +26,10 @@ import com.netflix.config.ConfigurationManager; import com.netflix.config.DeploymentContext.ContextKey; import com.netflix.config.DynamicStringProperty; import com.netflix.loadbalancer.ILoadBalancer; -import com.netflix.loadbalancer.Server; import com.netflix.loadbalancer.ZoneAwareLoadBalancer; +import com.netflix.niws.loadbalancer.DiscoveryEnabledServer; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; +import static org.junit.Assert.*; import static org.springframework.cloud.netflix.ribbon.eureka.EurekaRibbonClientConfiguration.VALUE_NOT_SET; /** @@ -56,7 +54,7 @@ public class EurekaRibbonClientConfigurationTests { ILoadBalancer balancer = clientFactory.getLoadBalancer("service"); assertNotNull(balancer); @SuppressWarnings("unchecked") - ZoneAwareLoadBalancer aware = (ZoneAwareLoadBalancer) balancer; + ZoneAwareLoadBalancer aware = (ZoneAwareLoadBalancer) balancer; assertTrue(aware.getServerListImpl() instanceof DomainExtractingServerList); assertEquals("foo", ConfigurationManager.getDeploymentContext().getValue(ContextKey.zone)); diff --git a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/eureka/EurekaRibbonClientPreprocessorIntegrationTests.java b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/eureka/EurekaRibbonClientPreprocessorIntegrationTests.java index 1849c16f..4de08b6a 100644 --- a/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/eureka/EurekaRibbonClientPreprocessorIntegrationTests.java +++ b/spring-cloud-netflix-core/src/test/java/org/springframework/cloud/netflix/ribbon/eureka/EurekaRibbonClientPreprocessorIntegrationTests.java @@ -35,6 +35,7 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import com.netflix.loadbalancer.Server; import com.netflix.loadbalancer.ZoneAvoidanceRule; import com.netflix.loadbalancer.ZoneAwareLoadBalancer; +import com.netflix.niws.loadbalancer.NIWSDiscoveryPing; /** * @author Dave Syer @@ -47,12 +48,25 @@ public class EurekaRibbonClientPreprocessorIntegrationTests { @Autowired private SpringClientFactory factory; + @Test + public void serverListDefaultsToDomainExtracting() throws Exception { + DomainExtractingServerList.class.cast(getLoadBalancer().getServerListImpl()); + } + @Test public void ruleDefaultsToZoneAvoidance() throws Exception { - @SuppressWarnings("unchecked") - ZoneAwareLoadBalancer loadBalancer = (ZoneAwareLoadBalancer) this.factory + ZoneAvoidanceRule.class.cast(getLoadBalancer().getRule()); + } + + @Test + public void pingDefaultsToDiscoveryPing() throws Exception { + NIWSDiscoveryPing.class.cast(getLoadBalancer().getPing()); + } + + @SuppressWarnings("unchecked") + private ZoneAwareLoadBalancer getLoadBalancer() { + return (ZoneAwareLoadBalancer) this.factory .getLoadBalancer("foo"); - ZoneAvoidanceRule.class.cast(loadBalancer.getRule()); } @Configuration