Merge remote-tracking branch 'Upstream/master' into error-handle-invalid-hostnames-159

# Conflicts:
#	spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancerInterceptor.java

Author: Ryan Baxter

docs/src/main/asciidoc/spring-cloud-commons.adoc

@@ -217,10 +217,10 @@ application that includes that jar on its classpath.
 
 === Environment Changes
 
-The application will listen for an `EnvironmentChangedEvent` and react
+The application will listen for an `EnvironmentChangeEvent` and react
 to the change in a couple of standard ways (additional
 `ApplicationListeners` can be added as `@Beans` by the user in the
-normal way). When an `EnvironmentChangedEvent` is observed it will
+normal way). When an `EnvironmentChangeEvent` is observed it will
 have a list of key values that have changed, and the application will
 use those to:
 
@@ -231,12 +231,12 @@ Note that the Config Client does not by default poll for changes in
 the `Environment`, and generally we would not recommend that approach
 for detecting changes (although you could set it up with a
 `@Scheduled` annotation). If you have a scaled-out client application
-then it is better to broadcast the `EnvironmentChangedEvent` to all
+then it is better to broadcast the `EnvironmentChangeEvent` to all
 the instances instead of having them polling for changes (e.g. using
 the https://github.com/spring-cloud/spring-cloud-bus[Spring Cloud
 Bus]).
 
-The `EnvironmentChangedEvent` covers a large class of refresh use
+The `EnvironmentChangeEvent` covers a large class of refresh use
 cases, as long as you can actually make a change to the `Environment`
 and publish the event (those APIs are public and part of core
 Spring). You can verify the changes are bound to
@@ -363,7 +363,7 @@ for details of how the `RestTemplate` is set up.
 
 A load balanced `RestTemplate` can be configured to retry failed requests.
 By default this logic is disabled, you can enable it by setting
-`spring.cloud.loadbalancer.retry=true`.  The load balanced `RestTemplate` will
+`spring.cloud.loadbalancer.retry.enabled=true`.  The load balanced `RestTemplate` will
 honor some of the Ribbon configuration values related to retrying failed requests.
 The properties you can use are `client.ribbon.MaxAutoRetries`,
 `client.ribbon.MaxAutoRetriesNextServer`, and `client.ribbon.OkToRetryOnAllOperations`.

spring-cloud-commons/src/main/java/org/springframework/cloud/client/discovery/DiscoveryClient.java

@@ -31,23 +31,25 @@ public interface DiscoveryClient {
 	 * A human readable description of the implementation, used in HealthIndicator
 	 * @return the description
 	 */
-	public String description();
+	String description();
 
 	/**
+	 * @deprecated use the {@link org.springframework.cloud.client.serviceregistry.Registration} bean instead
+	 *
 	 * @return ServiceInstance with information used to register the local service
 	 */
-	public ServiceInstance getLocalServiceInstance();
+	ServiceInstance getLocalServiceInstance();
 
 	/**
 	 * Get all ServiceInstances associated with a particular serviceId
 	 * @param serviceId the serviceId to query
 	 * @return a List of ServiceInstance
 	 */
-	public List<ServiceInstance> getInstances(String serviceId);
+	List<ServiceInstance> getInstances(String serviceId);
 
 	/**
 	 * @return all known service ids
 	 */
-	public List<String> getServices();
+	List<String> getServices();
 
 }

spring-cloud-commons/src/main/java/org/springframework/cloud/client/discovery/DiscoveryLifecycle.java

@@ -21,6 +21,8 @@
 
 /**
  * @author Spencer Gibb
+ * @deprecated  use {@link org.springframework.cloud.client.serviceregistry.AutoServiceRegistration} instead. This class will be removed in the next release train.
  */
+@Deprecated
 public interface DiscoveryLifecycle extends SmartLifecycle, Ordered {
 }

spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancerAutoConfiguration.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2015 the original author or authors.
+ * Copyright 2013-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,7 +26,6 @@
 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.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -39,6 +38,7 @@
  *
  * @author Spencer Gibb
  * @author Dave Syer
+ * @author Will Tran
  */
 @Configuration
 @ConditionalOnClass(RestTemplate.class)
@@ -65,12 +65,24 @@ public void afterSingletonsInstantiated() {
 		};
 	}
 
+	@Autowired(required = false)
+	private List<LoadBalancerRequestTransformer> transformers = Collections.emptyList();
+
+	@Bean
+	@ConditionalOnMissingBean
+	public LoadBalancerRequestFactory loadBalancerRequestFactory(
+			LoadBalancerClient loadBalancerClient) {
+		return new LoadBalancerRequestFactory(loadBalancerClient, transformers);
+	}
+
 	@Configuration
 	@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
 	static class LoadBalancerInterceptorConfig {
 		@Bean
-		public LoadBalancerInterceptor ribbonInterceptor(LoadBalancerClient loadBalancerClient) {
-			return new LoadBalancerInterceptor(loadBalancerClient);
+		public LoadBalancerInterceptor ribbonInterceptor(
+				LoadBalancerClient loadBalancerClient,
+				LoadBalancerRequestFactory requestFactory) {
+			return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
 		}
 
 		@Bean
@@ -108,8 +120,10 @@ public LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory() {
 		@Bean
 		public RetryLoadBalancerInterceptor ribbonInterceptor(
 				LoadBalancerClient loadBalancerClient, LoadBalancerRetryProperties properties,
-				LoadBalancedRetryPolicyFactory lbRetryPolicyFactory) {
-			return new RetryLoadBalancerInterceptor(loadBalancerClient, retryTemplate(), properties, lbRetryPolicyFactory);
+				LoadBalancedRetryPolicyFactory lbRetryPolicyFactory,
+				LoadBalancerRequestFactory requestFactory) {
+			return new RetryLoadBalancerInterceptor(loadBalancerClient, retryTemplate(), properties,
+					lbRetryPolicyFactory, requestFactory);
 		}
 
 		@Bean

spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancerInterceptor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2015 the original author or authors.
+ * Copyright 2013-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,7 +18,7 @@
 
 import java.io.IOException;
 import java.net.URI;
-import org.springframework.cloud.client.ServiceInstance;
+
 import org.springframework.http.HttpRequest;
 import org.springframework.http.client.ClientHttpRequestExecution;
 import org.springframework.http.client.ClientHttpRequestInterceptor;
@@ -29,13 +29,21 @@
  * @author Spencer Gibb
  * @author Dave Syer
  * @author Ryan Baxter
+ * @author William Tran
  */
 public class LoadBalancerInterceptor implements ClientHttpRequestInterceptor {
 
 	private LoadBalancerClient loadBalancer;
+	private LoadBalancerRequestFactory requestFactory;
 
-	public LoadBalancerInterceptor(LoadBalancerClient loadBalancer) {
+	public LoadBalancerInterceptor(LoadBalancerClient loadBalancer, LoadBalancerRequestFactory requestFactory) {
 		this.loadBalancer = loadBalancer;
+		this.requestFactory = requestFactory;
+	}
+
+	public LoadBalancerInterceptor(LoadBalancerClient loadBalancer) {
+		// for backwards compatibility
+		this(loadBalancer, new LoadBalancerRequestFactory(loadBalancer));
 	}
 
 	@Override
@@ -44,16 +52,6 @@ public ClientHttpResponse intercept(final HttpRequest request, final byte[] body
 		final URI originalUri = request.getURI();
 		String serviceName = originalUri.getHost();
 		Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
-		return this.loadBalancer.execute(serviceName,
-				new LoadBalancerRequest<ClientHttpResponse>() {
-					@Override
-					public ClientHttpResponse apply(final ServiceInstance instance)
-							throws Exception {
-						HttpRequest serviceRequest = new ServiceRequestWrapper(request,
-								instance, loadBalancer);
-						return execution.execute(serviceRequest, body);
-					}
-
-				});
+		return this.loadBalancer.execute(serviceName, requestFactory.createRequest(request, body, execution));
 	}
 }

spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancerRequestFactory.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.client.loadbalancer;
+
+import java.util.List;
+
+import org.springframework.cloud.client.ServiceInstance;
+import org.springframework.http.HttpRequest;
+import org.springframework.http.client.ClientHttpRequestExecution;
+import org.springframework.http.client.ClientHttpResponse;
+
+/**
+ * Creates {@link LoadBalancerRequest}s for {@link LoadBalancerInterceptor} and
+ * {@link RetryLoadBalancerInterceptor}. Applies
+ * {@link LoadBalancerRequestTransformer}s to the intercepted
+ * {@link HttpRequest}.
+ * 
+ * @author William Tran
+ *
+ */
+public class LoadBalancerRequestFactory {
+
+	private LoadBalancerClient loadBalancer;
+	private List<LoadBalancerRequestTransformer> transformers;
+
+	public LoadBalancerRequestFactory(LoadBalancerClient loadBalancer,
+			List<LoadBalancerRequestTransformer> transformers) {
+		this.loadBalancer = loadBalancer;
+		this.transformers = transformers;
+	}
+
+	public LoadBalancerRequestFactory(LoadBalancerClient loadBalancer) {
+		this.loadBalancer = loadBalancer;
+	}
+
+	public LoadBalancerRequest<ClientHttpResponse> createRequest(final HttpRequest request,
+			final byte[] body, final ClientHttpRequestExecution execution) {
+		return new LoadBalancerRequest<ClientHttpResponse>() {
+
+			@Override
+			public ClientHttpResponse apply(final ServiceInstance instance)
+					throws Exception {
+				HttpRequest serviceRequest = new ServiceRequestWrapper(request, instance, loadBalancer);
+				if (transformers != null) {
+					for (LoadBalancerRequestTransformer transformer : transformers) {
+						serviceRequest = transformer.transformRequest(serviceRequest, instance);
+					}
+				}
+				return execution.execute(serviceRequest, body);
+			}
+
+		};
+	}
+
+}

spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/LoadBalancerRequestTransformer.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.cloud.client.loadbalancer;
+
+import org.springframework.cloud.client.ServiceInstance;
+import org.springframework.core.annotation.Order;
+import org.springframework.http.HttpRequest;
+
+/**
+ * Allows applications to transform the load balanced {@link HttpRequest} given
+ * the chosen {@link ServiceInstance}
+ * 
+ * @author Will Tran
+ */
+@Order(LoadBalancerRequestTransformer.DEFAULT_ORDER)
+public interface LoadBalancerRequestTransformer {
+	public static final int DEFAULT_ORDER = 0;
+
+	HttpRequest transformRequest(HttpRequest request, ServiceInstance instance);
+}

spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/RetryLoadBalancerInterceptor.java

@@ -1,3 +1,19 @@
+/*
+ * Copyright 2016-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package org.springframework.cloud.client.loadbalancer;
 
 import java.io.IOException;
@@ -16,22 +32,34 @@
 
 /**
  * @author Ryan Baxter
+ * @author Will Tran
  */
 public class RetryLoadBalancerInterceptor implements ClientHttpRequestInterceptor {
 
 	private LoadBalancedRetryPolicyFactory lbRetryPolicyFactory;
 	private RetryTemplate retryTemplate;
 	private LoadBalancerClient loadBalancer;
 	private LoadBalancerRetryProperties lbProperties;
+	private LoadBalancerRequestFactory requestFactory;
 
 
 	public RetryLoadBalancerInterceptor(LoadBalancerClient loadBalancer, RetryTemplate retryTemplate,
 										LoadBalancerRetryProperties lbProperties,
-										LoadBalancedRetryPolicyFactory lbRetryPolicyFactory) {
+										LoadBalancedRetryPolicyFactory lbRetryPolicyFactory,
+										LoadBalancerRequestFactory requestFactory) {
 		this.loadBalancer = loadBalancer;
 		this.lbRetryPolicyFactory = lbRetryPolicyFactory;
 		this.retryTemplate = retryTemplate;
 		this.lbProperties = lbProperties;
+		this.requestFactory = requestFactory;
+	}
+	
+	public RetryLoadBalancerInterceptor(LoadBalancerClient loadBalancer, RetryTemplate retryTemplate,
+										LoadBalancerRetryProperties lbProperties,
+										LoadBalancedRetryPolicyFactory lbRetryPolicyFactory) {
+		// for backwards compatibility
+		this(loadBalancer, retryTemplate, lbProperties, lbRetryPolicyFactory, 
+				new LoadBalancerRequestFactory(loadBalancer));
 	}
 
 	@Override
@@ -61,18 +89,7 @@ public ClientHttpResponse doWithRetry(RetryContext context)
 						}
 						return RetryLoadBalancerInterceptor.this.loadBalancer.execute(
 								serviceName, serviceInstance,
-								new LoadBalancerRequest<ClientHttpResponse>() {
-
-									@Override
-									public ClientHttpResponse apply(
-											final ServiceInstance instance)
-											throws Exception {
-										HttpRequest serviceRequest = new ServiceRequestWrapper(
-												request, instance, loadBalancer);
-										return execution.execute(serviceRequest, body);
-									}
-
-								});
+								requestFactory.createRequest(request, body, execution));
 					}
 				});
 	}