Use new RibbonProperties consistently.

spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/feign/ribbon/FeignLoadBalancer.java

@@ -28,6 +28,8 @@ import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+
+import org.springframework.cloud.netflix.ribbon.RibbonProperties;
 import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
@@ -38,7 +40,6 @@ import com.netflix.client.ClientRequest;
 import com.netflix.client.IResponse;
 import com.netflix.client.RequestSpecificRetryHandler;
 import com.netflix.client.RetryHandler;
-import com.netflix.client.config.CommonClientConfigKey;
 import com.netflix.client.config.IClientConfig;
 import com.netflix.loadbalancer.ILoadBalancer;
 import com.netflix.loadbalancer.Server;
@@ -54,6 +55,7 @@ import static org.springframework.cloud.netflix.ribbon.RibbonUtils.updateToSecur
 public class FeignLoadBalancer extends
 		AbstractLoadBalancerAwareClient<FeignLoadBalancer.RibbonRequest, FeignLoadBalancer.RibbonResponse> {
 
+	private final RibbonProperties ribbon;
 	protected int connectTimeout;
 	protected int readTimeout;
 	protected IClientConfig clientConfig;
@@ -64,8 +66,10 @@ public class FeignLoadBalancer extends
 		super(lb, clientConfig);
 		this.setRetryHandler(RetryHandler.DEFAULT);
 		this.clientConfig = clientConfig;
-		this.connectTimeout = clientConfig.get(CommonClientConfigKey.ConnectTimeout);
-		this.readTimeout = clientConfig.get(CommonClientConfigKey.ReadTimeout);
+		this.ribbon = RibbonProperties.from(clientConfig);
+		RibbonProperties ribbon = this.ribbon;
+		this.connectTimeout = ribbon.getConnectTimeout();
+		this.readTimeout = ribbon.getReadTimeout();
 		this.serverIntrospector = serverIntrospector;
 	}
 
@@ -74,11 +78,10 @@ public class FeignLoadBalancer extends
 			throws IOException {
 		Request.Options options;
 		if (configOverride != null) {
+			RibbonProperties override = RibbonProperties.from(configOverride);
 			options = new Request.Options(
-					configOverride.get(CommonClientConfigKey.ConnectTimeout,
-							this.connectTimeout),
-					(configOverride.get(CommonClientConfigKey.ReadTimeout,
-							this.readTimeout)));
+					override.connectTimeout(this.connectTimeout),
+					override.readTimeout(this.readTimeout));
 		}
 		else {
 			options = new Request.Options(this.connectTimeout, this.readTimeout);
@@ -90,8 +93,7 @@ public class FeignLoadBalancer extends
 	@Override
 	public RequestSpecificRetryHandler getRequestSpecificRetryHandler(
 			RibbonRequest request, IClientConfig requestConfig) {
-		if (this.clientConfig.get(CommonClientConfigKey.OkToRetryOnAllOperations,
-				false)) {
+		if (this.ribbon.isOkToRetryOnAllOperations()) {
 			return new RequestSpecificRetryHandler(true, true, this.getRetryHandler(),
 					requestConfig);
 		}

spring-cloud-netflix-core/src/main/java/org/springframework/cloud/netflix/feign/ribbon/RetryableFeignLoadBalancer.java

@@ -30,6 +30,7 @@ import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFact
 import org.springframework.cloud.client.loadbalancer.RetryableStatusCodeException;
 import org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser;
 import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient;
+import org.springframework.cloud.netflix.ribbon.RibbonProperties;
 import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
 import org.springframework.retry.RetryCallback;
 import org.springframework.retry.RetryContext;
@@ -39,7 +40,6 @@ import org.springframework.retry.policy.NeverRetryPolicy;
 import org.springframework.retry.support.RetryTemplate;
 import com.netflix.client.DefaultLoadBalancerRetryHandler;
 import com.netflix.client.RequestSpecificRetryHandler;
-import com.netflix.client.config.CommonClientConfigKey;
 import com.netflix.client.config.IClientConfig;
 import com.netflix.loadbalancer.ILoadBalancer;
 import com.netflix.loadbalancer.Server;
@@ -78,11 +78,10 @@ public class RetryableFeignLoadBalancer extends FeignLoadBalancer implements Ser
 			throws IOException {
 		final Request.Options options;
 		if (configOverride != null) {
+			RibbonProperties ribbon = RibbonProperties.from(configOverride);
 			options = new Request.Options(
-					configOverride.get(CommonClientConfigKey.ConnectTimeout,
-							this.connectTimeout),
-					(configOverride.get(CommonClientConfigKey.ReadTimeout,
-							this.readTimeout)));
+					ribbon.connectTimeout(this.connectTimeout),
+					ribbon.readTimeout(this.readTimeout));
 		}
 		else {
 			options = new Request.Options(this.connectTimeout, this.readTimeout);

spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/ribbon/eureka/DomainExtractingServerList.java

@@ -19,8 +19,9 @@ package org.springframework.cloud.netflix.ribbon.eureka;
 import java.util.ArrayList;
 import java.util.List;
 
+import org.springframework.cloud.netflix.ribbon.RibbonProperties;
+
 import com.netflix.appinfo.InstanceInfo;
-import com.netflix.client.config.CommonClientConfigKey;
 import com.netflix.client.config.IClientConfig;
 import com.netflix.loadbalancer.Server;
 import com.netflix.loadbalancer.ServerList;
@@ -32,15 +33,14 @@ import com.netflix.niws.loadbalancer.DiscoveryEnabledServer;
 public class DomainExtractingServerList implements ServerList<DiscoveryEnabledServer> {
 
 	private ServerList<DiscoveryEnabledServer> list;
-
-	private IClientConfig clientConfig;
+	private final RibbonProperties ribbon;
 
 	private boolean approximateZoneFromHostname;
 
 	public DomainExtractingServerList(ServerList<DiscoveryEnabledServer> list,
 			IClientConfig clientConfig, boolean approximateZoneFromHostname) {
 		this.list = list;
-		this.clientConfig = clientConfig;
+		this.ribbon = RibbonProperties.from(clientConfig);
 		this.approximateZoneFromHostname = approximateZoneFromHostname;
 	}
 
@@ -60,10 +60,8 @@ public class DomainExtractingServerList implements ServerList<DiscoveryEnabledSe
 
 	private List<DiscoveryEnabledServer> setZones(List<DiscoveryEnabledServer> servers) {
 		List<DiscoveryEnabledServer> result = new ArrayList<>();
-		boolean isSecure = this.clientConfig.getPropertyAsBoolean(
-				CommonClientConfigKey.IsSecure, Boolean.TRUE);
-		boolean shouldUseIpAddr = this.clientConfig.getPropertyAsBoolean(
-				CommonClientConfigKey.UseIPAddrForServer, Boolean.FALSE);
+		boolean isSecure = this.ribbon.isSecure(true);
+		boolean shouldUseIpAddr = this.ribbon.isUseIPAddrForServer();
 		for (DiscoveryEnabledServer server : servers) {
 			result.add(new DomainExtractingServer(server, isSecure, shouldUseIpAddr,
 					this.approximateZoneFromHostname));

spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonProperties.java

+package org.springframework.cloud.netflix.ribbon;
+
+import com.netflix.client.config.CommonClientConfigKey;
+import com.netflix.client.config.IClientConfig;
+import com.netflix.client.config.IClientConfigKey;
+
+import java.util.concurrent.TimeUnit;
+
+import static com.netflix.client.config.CommonClientConfigKey.PoolKeepAliveTime;
+import static com.netflix.client.config.CommonClientConfigKey.PoolKeepAliveTimeUnits;
+import static com.netflix.client.config.CommonClientConfigKey.Port;
+import static com.netflix.client.config.CommonClientConfigKey.SecurePort;
+import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_CONNECTION_IDLE_TIMERTASK_REPEAT_IN_MSECS;
+import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_CONNECT_TIMEOUT;
+import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_FOLLOW_REDIRECTS;
+import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_MAX_CONNECTIONS_PER_HOST;
+import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_MAX_TOTAL_CONNECTIONS;
+import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_OK_TO_RETRY_ON_ALL_OPERATIONS;
+import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_POOL_KEEP_ALIVE_TIME;
+import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_POOL_KEEP_ALIVE_TIME_UNITS;
+import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_PORT;
+import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_READ_TIMEOUT;
+
+public class RibbonProperties {
+    private final IClientConfig config;
+
+    public static RibbonProperties from(IClientConfig config) {
+        return new RibbonProperties(config);
+    }
+
+    RibbonProperties(IClientConfig config) {
+        this.config = config;
+    }
+
+    public Integer getConnectionCleanerRepeatInterval() {
+        return get(CommonClientConfigKey.ConnectionCleanerRepeatInterval);
+    }
+
+    public int connectionCleanerRepeatInterval() {
+        return get(CommonClientConfigKey.ConnectionCleanerRepeatInterval,
+                DEFAULT_CONNECTION_IDLE_TIMERTASK_REPEAT_IN_MSECS);
+    }
+
+    public Integer getConnectTimeout() {
+        return get(CommonClientConfigKey.ConnectTimeout);
+    }
+
+    public int connectTimeout() {
+        return connectTimeout(DEFAULT_CONNECT_TIMEOUT);
+    }
+
+    public int connectTimeout(int defaultValue) {
+        return get(CommonClientConfigKey.ConnectTimeout, defaultValue);
+    }
+
+    public Boolean getFollowRedirects() {
+        return get(CommonClientConfigKey.FollowRedirects);
+    }
+
+    public boolean isFollowRedirects() {
+        return isFollowRedirects(DEFAULT_FOLLOW_REDIRECTS);
+    }
+
+    public boolean isFollowRedirects(boolean defaultValue) {
+        return get(CommonClientConfigKey.FollowRedirects, defaultValue);
+    }
+
+    public Integer getMaxConnectionsPerHost() {
+        return get(CommonClientConfigKey.MaxConnectionsPerHost);
+    }
+
+    public int maxConnectionsPerHost() {
+        return maxConnectionsPerHost(DEFAULT_MAX_CONNECTIONS_PER_HOST);
+    }
+
+    public int maxConnectionsPerHost(int defaultValue) {
+        return get(CommonClientConfigKey.MaxConnectionsPerHost, defaultValue);
+    }
+
+    public Integer getMaxTotalConnections() {
+        return get(CommonClientConfigKey.MaxTotalConnections);
+    }
+
+    public int maxTotalConnections() {
+        return maxTotalConnections(DEFAULT_MAX_TOTAL_CONNECTIONS);
+    }
+
+    public int maxTotalConnections(int defaultValue) {
+        return get(CommonClientConfigKey.MaxTotalConnections, defaultValue);
+    }
+
+    public Boolean getOkToRetryOnAllOperations() {
+        return get(CommonClientConfigKey.OkToRetryOnAllOperations);
+    }
+
+    public boolean isOkToRetryOnAllOperations() {
+        return get(CommonClientConfigKey.OkToRetryOnAllOperations,
+                DEFAULT_OK_TO_RETRY_ON_ALL_OPERATIONS);
+    }
+
+    @SuppressWarnings("deprecation")
+    public Long getPoolKeepAliveTime() {
+        Object property = this.config.getProperty(PoolKeepAliveTime);
+        if (property instanceof Long) {
+            return (Long) property;
+        }
+        return null;
+    }
+
+    @SuppressWarnings("deprecation")
+    public long poolKeepAliveTime() {
+        Object property = this.config.getProperty(PoolKeepAliveTime);
+        if (property instanceof Long) {
+            return (Long) property;
+        }
+        return DEFAULT_POOL_KEEP_ALIVE_TIME;
+    }
+
+    @SuppressWarnings("deprecation")
+    public TimeUnit getPoolKeepAliveTimeUnits() {
+        Object property = this.config.getProperty(PoolKeepAliveTimeUnits);
+        if (property instanceof TimeUnit) {
+            return (TimeUnit) property;
+        }
+        return DEFAULT_POOL_KEEP_ALIVE_TIME_UNITS;
+    }
+
+    public Integer getPort() {
+        return get(Port);
+    }
+
+    public int port() {
+        return get(Port, DEFAULT_PORT);
+    }
+
+    public Integer getReadTimeout() {
+        return get(CommonClientConfigKey.ReadTimeout);
+    }
+
+    public int readTimeout() {
+        return readTimeout(DEFAULT_READ_TIMEOUT);
+    }
+
+    public int readTimeout(int defaultValue) {
+        return get(CommonClientConfigKey.ReadTimeout, defaultValue);
+    }
+
+    public Boolean getSecure() {
+        return get(CommonClientConfigKey.IsSecure);
+    }
+
+    public boolean isSecure() {
+        return isSecure(false);
+    }
+
+    public boolean isSecure(boolean defaultValue) {
+        return get(CommonClientConfigKey.IsSecure, defaultValue);
+    }
+
+    public Integer getSecurePort() {
+        return this.config.get(SecurePort);
+    }
+
+    public Boolean getUseIPAddrForServer() {
+        return get(CommonClientConfigKey.UseIPAddrForServer);
+    }
+
+    public boolean isUseIPAddrForServer() {
+        return isUseIPAddrForServer(false);
+    }
+
+    public boolean isUseIPAddrForServer(boolean defaultValue) {
+        return get(CommonClientConfigKey.UseIPAddrForServer, defaultValue);
+    }
+
+    public <T> boolean has(IClientConfigKey<T> key) {
+        return this.config.containsProperty(key);
+    }
+
+    public <T> T get(IClientConfigKey<T> key) {
+        return this.config.get(key);
+    }
+
+    public <T> T get(IClientConfigKey<T> key, T defaultValue) {
+        return this.config.get(key, defaultValue);
+    }
+}

spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/RibbonUtils.java

@@ -2,7 +2,6 @@ package org.springframework.cloud.netflix.ribbon;
 
 import java.net.URI;
 
-import com.netflix.client.config.IClientConfigKey;
 import org.springframework.util.StringUtils;
 import org.springframework.web.util.UriComponentsBuilder;
 import com.netflix.client.config.CommonClientConfigKey;
@@ -17,14 +16,6 @@ import java.util.Map;
 
 import static com.netflix.client.config.CommonClientConfigKey.DeploymentContextBasedVipAddresses;
 import static com.netflix.client.config.CommonClientConfigKey.EnableZoneAffinity;
-import static com.netflix.client.config.CommonClientConfigKey.Port;
-import static com.netflix.client.config.CommonClientConfigKey.SecurePort;
-import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_CONNECT_TIMEOUT;
-import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_FOLLOW_REDIRECTS;
-import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_MAX_TOTAL_CONNECTIONS;
-import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_OK_TO_RETRY_ON_ALL_OPERATIONS;
-import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_PORT;
-import static com.netflix.client.config.DefaultClientConfigImpl.DEFAULT_READ_TIMEOUT;
 
 /**
  * @author Spencer Gibb
@@ -50,94 +41,6 @@ public class RibbonUtils {
 		setRibbonProperty(serviceId, EnableZoneAffinity.key(), "true");
 	}
 
-	public static RibbonProperties from(IClientConfig config) {
-		return new RibbonProperties(config);
-	}
-
-	//TODO: add more commonly used properties
-	//TODO: refactor s-c-netflix to use this class where possible
-	public static class RibbonProperties {
-		private final IClientConfig config;
-
-		RibbonProperties(IClientConfig config) {
-			this.config = config;
-		}
-
-		public Integer getPort() {
-			return get(Port);
-		}
-
-		public int port() {
-			return get(Port, DEFAULT_PORT);
-		}
-
-		public Integer getSecurePort() {
-			return this.config.get(SecurePort);
-		}
-
-		public Boolean getSecure() {
-			return get(CommonClientConfigKey.IsSecure);
-		}
-
-		public boolean isSecure() {
-			return get(CommonClientConfigKey.IsSecure, false);
-		}
-
-		public Integer getReadTimeout() {
-			return get(CommonClientConfigKey.ReadTimeout);
-		}
-
-		public int readTimeout() {
-			return get(CommonClientConfigKey.ReadTimeout, DEFAULT_READ_TIMEOUT);
-		}
-
-		public Integer getConnectTimeout() {
-			return get(CommonClientConfigKey.ConnectTimeout);
-		}
-
-		public int connectTimeout() {
-			return get(CommonClientConfigKey.ConnectTimeout, DEFAULT_CONNECT_TIMEOUT);
-		}
-
-		public Boolean getOkToRetryOnAllOperations() {
-			return get(CommonClientConfigKey.OkToRetryOnAllOperations);
-		}
-
-		public boolean isOkToRetryOnAllOperations() {
-			return get(CommonClientConfigKey.OkToRetryOnAllOperations,
-					DEFAULT_OK_TO_RETRY_ON_ALL_OPERATIONS);
-		}
-
-		public Boolean getFollowRedirects() {
-			return get(CommonClientConfigKey.FollowRedirects);
-		}
-
-		public boolean isFollowRedirects() {
-			return get(CommonClientConfigKey.FollowRedirects,
-					DEFAULT_FOLLOW_REDIRECTS);
-		}
-
-		public Integer getMaxTotalConnections() {
-			return get(CommonClientConfigKey.MaxTotalConnections);
-		}
-
-		public int maxTotalConnections() {
-			return get(CommonClientConfigKey.MaxTotalConnections, DEFAULT_MAX_TOTAL_CONNECTIONS);
-		}
-
-		public <T> boolean has(IClientConfigKey<T> key) {
-			return this.config.containsProperty(key);
-		}
-
-		public <T> T get(IClientConfigKey<T> key) {
-			return this.config.get(key);
-		}
-
-		public <T> T get(IClientConfigKey<T> key, T defaultValue) {
-			return this.config.get(key, defaultValue);
-		}
-	}
-
 	public static void setRibbonProperty(String serviceId, String suffix, String value) {
 		// how to set the namespace properly?
 		String key = getRibbonKey(serviceId, suffix);

spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/apache/HttpClientRibbonConfiguration.java

@@ -37,14 +37,13 @@ import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFact
 import org.springframework.cloud.commons.httpclient.ApacheHttpClientConnectionManagerFactory;
 import org.springframework.cloud.commons.httpclient.ApacheHttpClientFactory;
 import org.springframework.cloud.netflix.ribbon.RibbonClientName;
+import org.springframework.cloud.netflix.ribbon.RibbonProperties;
 import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 import com.netflix.client.AbstractLoadBalancerAwareClient;
 import com.netflix.client.RetryHandler;
-import com.netflix.client.config.CommonClientConfigKey;
-import com.netflix.client.config.DefaultClientConfigImpl;
 import com.netflix.client.config.IClientConfig;
 import com.netflix.loadbalancer.ILoadBalancer;
 import com.netflix.servo.monitor.Monitors;
@@ -73,27 +72,12 @@ public class HttpClientRibbonConfiguration {
 		public HttpClientConnectionManager httpClientConnectionManager(
 				IClientConfig config,
 				ApacheHttpClientConnectionManagerFactory connectionManagerFactory) {
-			Integer maxTotalConnections = config.getPropertyAsInteger(
-					CommonClientConfigKey.MaxTotalConnections,
-					DefaultClientConfigImpl.DEFAULT_MAX_TOTAL_CONNECTIONS);
-			Integer maxConnectionsPerHost = config.getPropertyAsInteger(
-					CommonClientConfigKey.MaxConnectionsPerHost,
-					DefaultClientConfigImpl.DEFAULT_MAX_CONNECTIONS_PER_HOST);
-			Integer timerRepeat = config.getPropertyAsInteger(
-					CommonClientConfigKey.ConnectionCleanerRepeatInterval,
-					DefaultClientConfigImpl.DEFAULT_CONNECTION_IDLE_TIMERTASK_REPEAT_IN_MSECS);
-			Object timeToLiveObj = config
-					.getProperty(CommonClientConfigKey.PoolKeepAliveTime);
-			Long timeToLive = DefaultClientConfigImpl.DEFAULT_POOL_KEEP_ALIVE_TIME;
-			Object ttlUnitObj = config
-					.getProperty(CommonClientConfigKey.PoolKeepAliveTimeUnits);
-			TimeUnit ttlUnit = DefaultClientConfigImpl.DEFAULT_POOL_KEEP_ALIVE_TIME_UNITS;
-			if (timeToLiveObj instanceof Long) {
-				timeToLive = (Long) timeToLiveObj;
-			}
-			if (ttlUnitObj instanceof TimeUnit) {
-				ttlUnit = (TimeUnit) ttlUnitObj;
-			}
+			RibbonProperties ribbon = RibbonProperties.from(config);
+			int maxTotalConnections = ribbon.maxTotalConnections();
+			int maxConnectionsPerHost = ribbon.maxConnectionsPerHost();
+			int timerRepeat = ribbon.connectionCleanerRepeatInterval();
+			long timeToLive = ribbon.poolKeepAliveTime();
+			TimeUnit ttlUnit = ribbon.getPoolKeepAliveTimeUnits();
 			final HttpClientConnectionManager connectionManager = connectionManagerFactory
 					.newConnectionManager(false, maxTotalConnections,
 							maxConnectionsPerHost, timeToLive, ttlUnit, registryBuilder);
@@ -110,12 +94,9 @@ public class HttpClientRibbonConfiguration {
 		@ConditionalOnMissingBean(CloseableHttpClient.class)
 		public CloseableHttpClient httpClient(ApacheHttpClientFactory httpClientFactory,
 											  HttpClientConnectionManager connectionManager, IClientConfig config) {
-			Boolean followRedirects = config.getPropertyAsBoolean(
-					CommonClientConfigKey.FollowRedirects,
-					DefaultClientConfigImpl.DEFAULT_FOLLOW_REDIRECTS);
-			Integer connectTimeout = config.getPropertyAsInteger(
-					CommonClientConfigKey.ConnectTimeout,
-					DefaultClientConfigImpl.DEFAULT_CONNECT_TIMEOUT);
+			RibbonProperties ribbon = RibbonProperties.from(config);
+			Boolean followRedirects = ribbon.isFollowRedirects();
+			Integer connectTimeout = ribbon.connectTimeout();
 			RequestConfig defaultRequestConfig = RequestConfig.custom()
 					.setConnectTimeout(connectTimeout)
 					.setRedirectsEnabled(followRedirects).build();

spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/apache/RetryableRibbonLoadBalancingHttpClient.java

@@ -30,10 +30,10 @@ import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy;
 import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFactory;
 import org.springframework.cloud.client.loadbalancer.RetryableStatusCodeException;
 import org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser;
+import org.springframework.cloud.netflix.ribbon.RibbonProperties;
 import org.springframework.cloud.netflix.ribbon.support.RibbonRetryPolicy;
 import org.springframework.http.HttpRequest;
 import org.springframework.retry.RetryCallback;
-import org.springframework.retry.RetryContext;
 import org.springframework.retry.backoff.BackOffPolicy;
 import org.springframework.retry.backoff.NoBackOffPolicy;
 import org.springframework.retry.policy.NeverRetryPolicy;
@@ -42,7 +42,6 @@ import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient;
 import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
 import com.netflix.client.RequestSpecificRetryHandler;
 import com.netflix.client.RetryHandler;
-import com.netflix.client.config.CommonClientConfigKey;
 import com.netflix.client.config.IClientConfig;
 import com.netflix.loadbalancer.Server;
 
@@ -87,44 +86,39 @@ public class RetryableRibbonLoadBalancingHttpClient extends RibbonLoadBalancingH
 	public RibbonApacheHttpResponse execute(final RibbonApacheHttpRequest request, final IClientConfig configOverride) throws Exception {
 		final RequestConfig.Builder builder = RequestConfig.custom();
 		IClientConfig config = configOverride != null ? configOverride : this.config;
-		builder.setConnectTimeout(config.get(
-				CommonClientConfigKey.ConnectTimeout, this.connectTimeout));
-		builder.setSocketTimeout(config.get(
-				CommonClientConfigKey.ReadTimeout, this.readTimeout));
-		builder.setRedirectsEnabled(config.get(
-				CommonClientConfigKey.FollowRedirects, this.followRedirects));
+		RibbonProperties ribbon = RibbonProperties.from(config);
+		builder.setConnectTimeout(ribbon.connectTimeout(this.connectTimeout));
+		builder.setSocketTimeout(ribbon.readTimeout(this.readTimeout));
+		builder.setRedirectsEnabled(ribbon.isFollowRedirects(this.followRedirects));
 
 		final RequestConfig requestConfig = builder.build();
 		final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryPolicyFactory.create(this.getClientName(), this);
-		RetryCallback retryCallback = new RetryCallback() {
-			@Override
-			public RibbonApacheHttpResponse doWithRetry(RetryContext context) throws Exception {
-				//on retries the policy will choose the server and set it in the context
-				//extract the server and update the request being made
-				RibbonApacheHttpRequest newRequest = request;
-				if(context instanceof LoadBalancedRetryContext) {
-					ServiceInstance service = ((LoadBalancedRetryContext)context).getServiceInstance();
-					if(service != null) {
-						//Reconstruct the request URI using the host and port set in the retry context
-						newRequest = newRequest.withNewUri(new URI(service.getUri().getScheme(),
-								newRequest.getURI().getUserInfo(), service.getHost(), service.getPort(),
-								newRequest.getURI().getPath(), newRequest.getURI().getQuery(),
-								newRequest.getURI().getFragment()));
-					}
-				}
-				newRequest = getSecureRequest(request, configOverride);
-				HttpUriRequest httpUriRequest = newRequest.toRequest(requestConfig);
-				final HttpResponse httpResponse = RetryableRibbonLoadBalancingHttpClient.this.delegate.execute(httpUriRequest);
-				if(retryPolicy.retryableStatusCode(httpResponse.getStatusLine().getStatusCode())) {
-					if(CloseableHttpResponse.class.isInstance(httpResponse)) {
-						((CloseableHttpResponse)httpResponse).close();
-					}
-					throw new RetryableStatusCodeException(RetryableRibbonLoadBalancingHttpClient.this.clientName,
-							httpResponse.getStatusLine().getStatusCode());
-				}
-				return new RibbonApacheHttpResponse(httpResponse, httpUriRequest.getURI());
-			}
-		};
+		RetryCallback retryCallback = context -> {
+            //on retries the policy will choose the server and set it in the context
+            //extract the server and update the request being made
+            RibbonApacheHttpRequest newRequest = request;
+            if(context instanceof LoadBalancedRetryContext) {
+                ServiceInstance service = ((LoadBalancedRetryContext)context).getServiceInstance();
+                if(service != null) {
+                    //Reconstruct the request URI using the host and port set in the retry context
+                    newRequest = newRequest.withNewUri(new URI(service.getUri().getScheme(),
+                            newRequest.getURI().getUserInfo(), service.getHost(), service.getPort(),
+                            newRequest.getURI().getPath(), newRequest.getURI().getQuery(),
+                            newRequest.getURI().getFragment()));
+                }
+            }
+            newRequest = getSecureRequest(request, configOverride);
+            HttpUriRequest httpUriRequest = newRequest.toRequest(requestConfig);
+            final HttpResponse httpResponse = RetryableRibbonLoadBalancingHttpClient.this.delegate.execute(httpUriRequest);
+            if(retryPolicy.retryableStatusCode(httpResponse.getStatusLine().getStatusCode())) {
+                if(CloseableHttpResponse.class.isInstance(httpResponse)) {
+                    ((CloseableHttpResponse)httpResponse).close();
+                }
+                throw new RetryableStatusCodeException(RetryableRibbonLoadBalancingHttpClient.this.clientName,
+                        httpResponse.getStatusLine().getStatusCode());
+            }
+            return new RibbonApacheHttpResponse(httpResponse, httpUriRequest.getURI());
+        };
 		return this.executeWithRetry(request, retryPolicy, retryCallback);
 	}
 

spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/apache/RibbonLoadBalancingHttpClient.java

@@ -17,18 +17,19 @@
 package org.springframework.cloud.netflix.ribbon.apache;
 
 import java.net.URI;
+
 import org.apache.http.HttpResponse;
 import org.apache.http.client.config.RequestConfig;
 import org.apache.http.client.methods.HttpUriRequest;
 import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.impl.client.HttpClientBuilder;
+import org.springframework.cloud.netflix.ribbon.RibbonProperties;
 import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
 import org.springframework.cloud.netflix.ribbon.support.AbstractLoadBalancingClient;
 import org.springframework.web.util.UriComponentsBuilder;
-import org.springframework.cloud.netflix.ribbon.RibbonUtils;
+
 import com.netflix.client.RequestSpecificRetryHandler;
 import com.netflix.client.RetryHandler;
-import com.netflix.client.config.CommonClientConfigKey;
 import com.netflix.client.config.IClientConfig;
 import com.netflix.loadbalancer.Server;
 
@@ -54,13 +55,12 @@ public class RibbonLoadBalancingHttpClient extends
 	}
 
 	protected CloseableHttpClient createDelegate(IClientConfig config) {
+		RibbonProperties ribbon = RibbonProperties.from(config);
 		return HttpClientBuilder.create()
 				// already defaults to 0 in builder, so resetting to 0 won't hurt
-				.setMaxConnTotal(config.getPropertyAsInteger(
-						CommonClientConfigKey.MaxTotalConnections, 0))
+				.setMaxConnTotal(ribbon.maxTotalConnections(0))
 				// already defaults to 0 in builder, so resetting to 0 won't hurt
-				.setMaxConnPerRoute(config.getPropertyAsInteger(
-						CommonClientConfigKey.MaxConnectionsPerHost, 0))
+				.setMaxConnPerRoute(ribbon.maxConnectionsPerHost(0))
 				.disableCookieManagement().useSystemProperties() // for proxy
 				.build();
 	}
@@ -68,16 +68,14 @@ public class RibbonLoadBalancingHttpClient extends
 	@Override
 	public RibbonApacheHttpResponse execute(RibbonApacheHttpRequest request,
 											final IClientConfig configOverride) throws Exception {
-		final RequestConfig.Builder builder = RequestConfig.custom();
 		IClientConfig config = configOverride != null ? configOverride : this.config;
-		builder.setConnectTimeout(
-				config.get(CommonClientConfigKey.ConnectTimeout, this.connectTimeout));
-		builder.setSocketTimeout(
-				config.get(CommonClientConfigKey.ReadTimeout, this.readTimeout));
-		builder.setRedirectsEnabled(
-				config.get(CommonClientConfigKey.FollowRedirects, this.followRedirects));
+		RibbonProperties ribbon = RibbonProperties.from(config);
+		RequestConfig requestConfig = RequestConfig.custom()
+				.setConnectTimeout(ribbon.connectTimeout(this.connectTimeout))
+				.setSocketTimeout(ribbon.readTimeout(this.readTimeout))
+				.setRedirectsEnabled(ribbon.isFollowRedirects(this.followRedirects))
+				.build();
 
-		final RequestConfig requestConfig = builder.build();
 		request = getSecureRequest(request, configOverride);
 		final HttpUriRequest httpUriRequest = request.toRequest(requestConfig);
 		final HttpResponse httpResponse = this.delegate.execute(httpUriRequest);

spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/okhttp/OkHttpLoadBalancingClient.java

@@ -16,21 +16,23 @@
 
 package org.springframework.cloud.netflix.ribbon.okhttp;
 
-import okhttp3.OkHttpClient;
-import okhttp3.Request;
-import okhttp3.Response;
-
 import java.net.URI;
 import java.util.concurrent.TimeUnit;
+
+import org.springframework.cloud.netflix.ribbon.RibbonProperties;
+import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
 import org.springframework.cloud.netflix.ribbon.support.AbstractLoadBalancingClient;
 import org.springframework.web.util.UriComponentsBuilder;
-import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
-import com.netflix.client.config.CommonClientConfigKey;
+
 import com.netflix.client.config.IClientConfig;
 import com.netflix.loadbalancer.Server;
 
 import static org.springframework.cloud.netflix.ribbon.RibbonUtils.updateToSecureConnectionIfNeeded;
 
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+
 /**
  * @author Spencer Gibb
  * @author Ryan Baxter
@@ -71,17 +73,14 @@ public class OkHttpLoadBalancingClient
 	}
 
 	OkHttpClient getOkHttpClient(IClientConfig configOverride, boolean secure) {
-		OkHttpClient.Builder builder = this.delegate.newBuilder();
 		IClientConfig config = configOverride != null ? configOverride : this.config;
-		builder.connectTimeout(config.get(
-				CommonClientConfigKey.ConnectTimeout, this.connectTimeout), TimeUnit.MILLISECONDS);
-		builder.readTimeout(config.get(
-				CommonClientConfigKey.ReadTimeout, this.readTimeout), TimeUnit.MILLISECONDS);
-		builder.followRedirects(config.get(
-				CommonClientConfigKey.FollowRedirects, this.followRedirects));
+		RibbonProperties ribbon = RibbonProperties.from(config);
+		OkHttpClient.Builder builder = this.delegate.newBuilder()
+				.connectTimeout(ribbon.connectTimeout(this.connectTimeout), TimeUnit.MILLISECONDS)
+				.readTimeout(ribbon.readTimeout(this.readTimeout), TimeUnit.MILLISECONDS)
+				.followRedirects(ribbon.isFollowRedirects(this.followRedirects));
 		if (secure) {
-			builder.followSslRedirects(configOverride.get(
-					CommonClientConfigKey.FollowRedirects, this.followRedirects));
+			builder.followSslRedirects(ribbon.isFollowRedirects(this.followRedirects));
 		}
 
 		return builder.build();

spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/okhttp/OkHttpRibbonConfiguration.java

@@ -30,14 +30,13 @@ import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicyFact
 import org.springframework.cloud.commons.httpclient.OkHttpClientConnectionPoolFactory;
 import org.springframework.cloud.commons.httpclient.OkHttpClientFactory;
 import org.springframework.cloud.netflix.ribbon.RibbonClientName;
+import org.springframework.cloud.netflix.ribbon.RibbonProperties;
 import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 import com.netflix.client.AbstractLoadBalancerAwareClient;
 import com.netflix.client.RetryHandler;
-import com.netflix.client.config.CommonClientConfigKey;
-import com.netflix.client.config.DefaultClientConfigImpl;
 import com.netflix.client.config.IClientConfig;
 import com.netflix.loadbalancer.ILoadBalancer;
 import com.netflix.servo.monitor.Monitors;
@@ -63,21 +62,10 @@ public class OkHttpRibbonConfiguration {
 		@ConditionalOnMissingBean(ConnectionPool.class)
 		public ConnectionPool httpClientConnectionPool(IClientConfig config,
 													   OkHttpClientConnectionPoolFactory connectionPoolFactory) {
-			Integer maxTotalConnections = config.getPropertyAsInteger(
-					CommonClientConfigKey.MaxTotalConnections,
-					DefaultClientConfigImpl.DEFAULT_MAX_TOTAL_CONNECTIONS);
-			Object timeToLiveObj = config
-					.getProperty(CommonClientConfigKey.PoolKeepAliveTime);
-			Long timeToLive = DefaultClientConfigImpl.DEFAULT_POOL_KEEP_ALIVE_TIME;
-			Object ttlUnitObj = config
-					.getProperty(CommonClientConfigKey.PoolKeepAliveTimeUnits);
-			TimeUnit ttlUnit = DefaultClientConfigImpl.DEFAULT_POOL_KEEP_ALIVE_TIME_UNITS;
-			if (timeToLiveObj instanceof Long) {
-				timeToLive = (Long) timeToLiveObj;
-			}
-			if (ttlUnitObj instanceof TimeUnit) {
-				ttlUnit = (TimeUnit) ttlUnitObj;
-			}
+			RibbonProperties ribbon = RibbonProperties.from(config);
+			int maxTotalConnections = ribbon.maxTotalConnections();
+			long timeToLive = ribbon.poolKeepAliveTime();
+			TimeUnit ttlUnit = ribbon.getPoolKeepAliveTimeUnits();
 			return connectionPoolFactory.create(maxTotalConnections, timeToLive, ttlUnit);
 		}
 
@@ -85,19 +73,13 @@ public class OkHttpRibbonConfiguration {
 		@ConditionalOnMissingBean(OkHttpClient.class)
 		public OkHttpClient client(OkHttpClientFactory httpClientFactory,
 								   ConnectionPool connectionPool, IClientConfig config) {
-			Boolean followRedirects = config.getPropertyAsBoolean(
-					CommonClientConfigKey.FollowRedirects,
-					DefaultClientConfigImpl.DEFAULT_FOLLOW_REDIRECTS);
-			Integer connectTimeout = config.getPropertyAsInteger(
-					CommonClientConfigKey.ConnectTimeout,
-					DefaultClientConfigImpl.DEFAULT_CONNECT_TIMEOUT);
-			Integer readTimeout = config.getPropertyAsInteger(CommonClientConfigKey.ReadTimeout,
-					DefaultClientConfigImpl.DEFAULT_READ_TIMEOUT);
-			this.httpClient = httpClientFactory.createBuilder(false).
-					connectTimeout(connectTimeout, TimeUnit.MILLISECONDS).
-					readTimeout(readTimeout, TimeUnit.MILLISECONDS).
-					followRedirects(followRedirects).
-					connectionPool(connectionPool).build();
+			RibbonProperties ribbon = RibbonProperties.from(config);
+			this.httpClient = httpClientFactory.createBuilder(false)
+					.connectTimeout(ribbon.connectTimeout(), TimeUnit.MILLISECONDS)
+					.readTimeout(ribbon.readTimeout(), TimeUnit.MILLISECONDS)
+					.followRedirects(ribbon.isFollowRedirects())
+					.connectionPool(connectionPool)
+					.build();
 			return this.httpClient;
 		}
 

spring-cloud-netflix-ribbon/src/main/java/org/springframework/cloud/netflix/ribbon/support/AbstractLoadBalancingClient.java

@@ -18,18 +18,21 @@
 package org.springframework.cloud.netflix.ribbon.support;
 
 import org.springframework.cloud.netflix.ribbon.DefaultServerIntrospector;
-import org.springframework.cloud.netflix.ribbon.RibbonClientConfiguration;
+import org.springframework.cloud.netflix.ribbon.RibbonProperties;
 import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
+
 import com.netflix.client.AbstractLoadBalancerAwareClient;
 import com.netflix.client.IResponse;
 import com.netflix.client.RequestSpecificRetryHandler;
 import com.netflix.client.RetryHandler;
-import com.netflix.client.config.CommonClientConfigKey;
 import com.netflix.client.config.DefaultClientConfigImpl;
 import com.netflix.client.config.IClientConfig;
 import com.netflix.loadbalancer.ILoadBalancer;
 import com.netflix.loadbalancer.reactive.LoadBalancerCommand;
 
+import static org.springframework.cloud.netflix.ribbon.RibbonClientConfiguration.DEFAULT_CONNECT_TIMEOUT;
+import static org.springframework.cloud.netflix.ribbon.RibbonClientConfiguration.DEFAULT_READ_TIMEOUT;
+
 /**
  * @author Spencer Gibb
  */
@@ -91,20 +94,12 @@ public abstract class AbstractLoadBalancingClient<S extends ContextAwareRequest,
 	@Override
 	public void initWithNiwsConfig(IClientConfig clientConfig) {
 		super.initWithNiwsConfig(clientConfig);
-		this.connectTimeout = clientConfig.getPropertyAsInteger(
-				CommonClientConfigKey.ConnectTimeout,
-				RibbonClientConfiguration.DEFAULT_CONNECT_TIMEOUT);
-		this.readTimeout = clientConfig.getPropertyAsInteger(
-				CommonClientConfigKey.ReadTimeout,
-				RibbonClientConfiguration.DEFAULT_READ_TIMEOUT);
-		this.secure = clientConfig.getPropertyAsBoolean(CommonClientConfigKey.IsSecure,
-				false);
-		this.followRedirects = clientConfig.getPropertyAsBoolean(
-				CommonClientConfigKey.FollowRedirects,
-				DefaultClientConfigImpl.DEFAULT_FOLLOW_REDIRECTS);
-		this.okToRetryOnAllOperations = clientConfig.getPropertyAsBoolean(
-				CommonClientConfigKey.OkToRetryOnAllOperations,
-				DefaultClientConfigImpl.DEFAULT_OK_TO_RETRY_ON_ALL_OPERATIONS);
+		RibbonProperties ribbon = RibbonProperties.from(clientConfig);
+		this.connectTimeout = ribbon.connectTimeout(DEFAULT_CONNECT_TIMEOUT);
+		this.readTimeout = ribbon.readTimeout(DEFAULT_READ_TIMEOUT);
+		this.secure = ribbon.isSecure();
+		this.followRedirects = ribbon.isFollowRedirects();
+		this.okToRetryOnAllOperations = ribbon.isOkToRetryOnAllOperations();
 	}
 
 	protected abstract D createDelegate(IClientConfig config);
@@ -133,10 +128,7 @@ public abstract class AbstractLoadBalancingClient<S extends ContextAwareRequest,
 
 	protected boolean isSecure(final IClientConfig config) {
 		if(config != null) {
-			Boolean result = config.get(CommonClientConfigKey.IsSecure);
-			if(result != null) {
-				return result;
-			}
+			return RibbonProperties.from(config).isSecure(this.secure);
 		}
 		return this.secure;
 	}