From a1fddaf1391ae14485a98e211d6da963c82ab026 Mon Sep 17 00:00:00 2001 From: Olga Maciaszek-Sharma Date: Thu, 9 Oct 2025 20:55:03 +0200 Subject: [PATCH] Remove RestTemplate support. (#4504) Signed-off-by: Olga Maciaszek-Sharma --- .../ROOT/pages/spring-cloud-netflix.adoc | 10 +- docs/modules/ROOT/partials/_configprops.adoc | 10 +- .../netflix/eureka/EurekaClientSuite.java | 2 +- .../netflix/eureka/EurekaClientTests.java | 20 +- .../eureka/RestClientEurekaClientTests.java | 8 + .../eureka/RestTemplateEurekaClientTests.java | 106 -------- .../eureka/RestClientTimeoutProperties.java | 37 --- .../eureka/RestTemplateTimeoutProperties.java | 43 --- .../netflix/eureka/TimeoutProperties.java | 10 +- ...coveryClientOptionalArgsConfiguration.java | 115 +------- ...ekaConfigServerBootstrapConfiguration.java | 80 +----- .../EurekaConfigServerBootstrapper.java | 4 +- ...urekaClientHttpRequestFactorySupplier.java | 32 +-- ...stTemplateDiscoveryClientOptionalArgs.java | 52 ---- .../http/RestTemplateEurekaHttpClient.java | 252 ------------------ .../RestTemplateTransportClientFactories.java | 63 ----- .../RestTemplateTransportClientFactory.java | 177 ------------ ...itional-spring-configuration-metadata.json | 6 - ...rverBootstrapConfigurationClientTests.java | 33 +-- ...nfigurationRestClientIntegrationTests.java | 6 +- ...BootstrapConfigurationRestClientTests.java | 20 +- ...nfigServerBootstrapConfigurationTests.java | 4 +- ...rBootstrapConfigurationWebClientTests.java | 4 +- ...ClientsOptionalArgsConfigurationTests.java | 43 +-- ...yClientOptionalArgsConfigurationTests.java | 9 +- .../http/RestClientEurekaHttpClientTests.java | 4 +- ...RestClientTransportClientFactoryTests.java | 5 +- .../RestTemplateEurekaHttpClientTests.java | 85 ------ ...stTemplateTransportClientFactoryTests.java | 94 ------- 29 files changed, 72 insertions(+), 1262 deletions(-) delete mode 100644 spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/RestTemplateEurekaClientTests.java delete mode 100644 spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/RestClientTimeoutProperties.java delete mode 100644 spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/RestTemplateTimeoutProperties.java delete mode 100644 spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateDiscoveryClientOptionalArgs.java delete mode 100644 spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateEurekaHttpClient.java delete mode 100644 spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateTransportClientFactories.java delete mode 100644 spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateTransportClientFactory.java delete mode 100644 spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestTemplateEurekaHttpClientTests.java delete mode 100644 spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestTemplateTransportClientFactoryTests.java diff --git a/docs/modules/ROOT/pages/spring-cloud-netflix.adoc b/docs/modules/ROOT/pages/spring-cloud-netflix.adoc index f0edd7152..6da7f5ca9 100755 --- a/docs/modules/ROOT/pages/spring-cloud-netflix.adoc +++ b/docs/modules/ROOT/pages/spring-cloud-netflix.adoc @@ -96,9 +96,9 @@ The `eureka.client.tls.enabled` needs to be true to enable Eureka client side TL NOTE: Because of a limitation in Eureka, it is not possible to support per-server basic auth credentials, so only the first set that are found is used. -If you want to customize the RestTemplate used by the Eureka HTTP Client you may want to create a bean of `EurekaClientHttpRequestFactorySupplier` and provide your own logic for generating a `ClientHttpRequestFactory` instance. +If you want to customize the `RestClient` used by the Eureka HTTP Client you may want to create a bean of `EurekaClientHttpRequestFactorySupplier` and provide your own logic for generating a `ClientHttpRequestFactory` instance. -All default timeout-related properties for RestTemplate and RestClient used by the Eureka HTTP Client are set to 3 minutes (in keeping with Apache HC5 default `RequestConfig` and `SocketConfig`). Therefore, to specify the timeout values, you must specify the value directly with the properties in `eureka.client.rest-template-timeout` or `eureka.client.restclient.timeout`. All timeout properties are in milliseconds. +All default timeout-related properties for `RestClient` used by the Eureka HTTP Client are set to 3 minutes (in keeping with Apache HC5 default `RequestConfig` and `SocketConfig`). Therefore, to specify the timeout values, you must specify the value directly with the properties in `eureka.client.timeout`. All timeout properties are in milliseconds. .application.yml [source,yaml] @@ -290,11 +290,11 @@ It is initialized in a `SmartLifecycle` (with `phase=0`), so the earliest you ca ==== Underlying HTTP clients -`EurekaClient` uses either `RestClient`, `RestTemplate`, `WebClient` or `JerseyClient` under the hood. In order to use the `EurekaClient`, you need to have one of the supported HTTP clients on your classpath. +`EurekaClient` uses either `RestClient`, `WebClient` or `JerseyClient` under the hood. In order to use the `EurekaClient`, you need to have one of the supported HTTP clients on your classpath. -To use `RestTemplate` or `RestClient`, add `spring-boot-restclient` to your dependencies. To use `WebClient`, add `spring-boot-webclient` to your dependencies. If both `spring-boot-restclient` +To use `RestClient`, add `spring-boot-restclient` to your dependencies. To use `WebClient`, add `spring-boot-webclient` to your dependencies. If both `spring-boot-restclient` and `spring-boot-webclient` are included in the dependencies and the `eureka.client.webclient.enabled` flag is set to `true`, -then `WebClient` will be used. If that's not the case and `eureka.client.restclient.enabled` is set to `true`, `RestClient` will be used. Otherwise, `RestTemplate` will be used. +then `WebClient` will be used. If that's not the case, `RestClient` will be used. NOTE: For any of those client implementations, if there's a builder bean available, it will be used to create the underlying client. diff --git a/docs/modules/ROOT/partials/_configprops.adoc b/docs/modules/ROOT/partials/_configprops.adoc index 04f75e278..fb86143fc 100644 --- a/docs/modules/ROOT/partials/_configprops.adoc +++ b/docs/modules/ROOT/partials/_configprops.adoc @@ -46,16 +46,12 @@ |eureka.client.register-with-eureka | `+++true+++` | Indicates whether or not this instance should register its information with eureka server for discovery by others. In some cases, you do not want your instances to be discovered whereas you just want do discover other instances. |eureka.client.registry-fetch-interval-seconds | `+++30+++` | Indicates how often(in seconds) to fetch the registry information from the eureka server. |eureka.client.registry-refresh-single-vip-address | | Indicates whether the client is only interested in the registry information for a single VIP. -|eureka.client.rest-template-timeout.connect-request-timeout | `+++180000+++` | -|eureka.client.rest-template-timeout.connect-timeout | `+++180000+++` | Default values are set to 180000, in keeping with {@link RequestConfig} and {@link SocketConfig} defaults. -|eureka.client.rest-template-timeout.socket-timeout | `+++180000+++` | -|eureka.client.restclient.enabled | `+++false+++` | Enables the use of RestClient for Eureka HTTP Client. -|eureka.client.restclient.timeout.connect-request-timeout | `+++180000+++` | -|eureka.client.restclient.timeout.connect-timeout | `+++180000+++` | Default values are set to 180000, in keeping with {@link RequestConfig} and {@link SocketConfig} defaults. -|eureka.client.restclient.timeout.socket-timeout | `+++180000+++` | |eureka.client.service-url | | Map of availability zone to list of fully qualified URLs to communicate with eureka server. Each value can be a single URL or a comma separated list of alternative locations. Typically the eureka server URLs carry protocol,host,port,context and version information if any. Example: https://ec2-256-156-243-129.compute-1.amazonaws.com:7001/eureka/ The changes are effective at runtime at the next service url refresh cycle as specified by eurekaServiceUrlPollIntervalSeconds. |eureka.client.should-enforce-registration-at-init | `+++false+++` | Indicates whether the client should enforce registration during initialization. Defaults to false. |eureka.client.should-unregister-on-shutdown | `+++true+++` | Indicates whether the client should explicitly unregister itself from the remote server on client shutdown. +|eureka.client.timeout.connect-request-timeout | `+++180000+++` | +|eureka.client.timeout.connect-timeout | `+++180000+++` | Default values are set to 180000, in keeping with {@link RequestConfig} and {@link SocketConfig} defaults. +|eureka.client.timeout.socket-timeout | `+++180000+++` | |eureka.client.tls.enabled | | |eureka.client.tls.key-password | | |eureka.client.tls.key-store | | diff --git a/spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/EurekaClientSuite.java b/spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/EurekaClientSuite.java index a5a22a131..87e96437e 100644 --- a/spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/EurekaClientSuite.java +++ b/spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/EurekaClientSuite.java @@ -26,7 +26,7 @@ import org.junit.platform.suite.api.Suite; * That means that when the new context starts we will fail cause the executor service is * already shutdown. */ -@SelectClasses({ EurekaClientTests.class, RestTemplateEurekaClientTests.class }) +@SelectClasses({ EurekaClientTests.class, RestClientEurekaClientTests.class }) @Suite public class EurekaClientSuite { diff --git a/spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/EurekaClientTests.java b/spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/EurekaClientTests.java index ddd482eb8..408a77074 100644 --- a/spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/EurekaClientTests.java +++ b/spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/EurekaClientTests.java @@ -25,10 +25,11 @@ import org.junit.jupiter.api.BeforeAll; import org.springframework.boot.SpringBootConfiguration; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.cloud.netflix.eureka.http.DefaultEurekaClientHttpRequestFactorySupplier; -import org.springframework.cloud.netflix.eureka.http.RestTemplateDiscoveryClientOptionalArgs; -import org.springframework.cloud.netflix.eureka.http.RestTemplateTransportClientFactories; +import org.springframework.cloud.netflix.eureka.http.RestClientDiscoveryClientOptionalArgs; +import org.springframework.cloud.netflix.eureka.http.RestClientTransportClientFactories; import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer; import org.springframework.context.annotation.Bean; +import org.springframework.web.client.RestClient; import static org.assertj.core.api.Assertions.assertThat; @@ -44,7 +45,7 @@ public class EurekaClientTests extends BaseCertTests { public static void setupAll() { server = startEurekaServer(EurekaClientTests.TestEurekaServer.class); service = startService(server, EurekaClientTests.TestApp.class); - assertThat(service.discoveryClientOptionalArgs()).isInstanceOf(RestTemplateDiscoveryClientOptionalArgs.class); + assertThat(service.discoveryClientOptionalArgs()).isInstanceOf(RestClientDiscoveryClientOptionalArgs.class); LOG.info("Successfully asserted that Jersey will be used"); waitForRegistration(() -> new EurekaClientTests().createEurekaClient()); } @@ -59,15 +60,16 @@ public class EurekaClientTests extends BaseCertTests { public static class TestApp { @Bean - public RestTemplateTransportClientFactories forceRestTemplateTransportClientFactories( - RestTemplateDiscoveryClientOptionalArgs discoveryClientOptionalArgs) { - return new RestTemplateTransportClientFactories(discoveryClientOptionalArgs); + public RestClientTransportClientFactories forceRestClientTransportClientFactories( + RestClientDiscoveryClientOptionalArgs discoveryClientOptionalArgs) { + return new RestClientTransportClientFactories(discoveryClientOptionalArgs); } @Bean - public RestTemplateDiscoveryClientOptionalArgs discoveryClientOptionalArgs() { - return new RestTemplateDiscoveryClientOptionalArgs(new DefaultEurekaClientHttpRequestFactorySupplier( - new RestTemplateTimeoutProperties(), Collections.emptySet())); + public RestClientDiscoveryClientOptionalArgs discoveryClientOptionalArgs() { + return new RestClientDiscoveryClientOptionalArgs( + new DefaultEurekaClientHttpRequestFactorySupplier(new TimeoutProperties(), Collections.emptySet()), + RestClient::builder); } } diff --git a/spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/RestClientEurekaClientTests.java b/spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/RestClientEurekaClientTests.java index 63a793dad..9e20b3777 100644 --- a/spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/RestClientEurekaClientTests.java +++ b/spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/RestClientEurekaClientTests.java @@ -18,6 +18,7 @@ package org.springframework.cloud.netflix.eureka; import java.io.IOException; import java.security.GeneralSecurityException; +import java.util.Collections; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; @@ -27,6 +28,7 @@ import org.junit.jupiter.api.BeforeAll; import org.springframework.boot.SpringBootConfiguration; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.cloud.configuration.TlsProperties; +import org.springframework.cloud.netflix.eureka.http.DefaultEurekaClientHttpRequestFactorySupplier; import org.springframework.cloud.netflix.eureka.http.EurekaClientHttpRequestFactorySupplier; import org.springframework.cloud.netflix.eureka.http.RestClientDiscoveryClientOptionalArgs; import org.springframework.cloud.netflix.eureka.http.RestClientTransportClientFactories; @@ -94,6 +96,12 @@ public class RestClientEurekaClientTests extends BaseCertTests { return new RestClientTransportClientFactories(discoveryClientOptionalArgs); } + @Bean + EurekaClientHttpRequestFactorySupplier defaultEurekaClientHttpRequestFactorySupplier( + TimeoutProperties timeoutProperties) { + return new DefaultEurekaClientHttpRequestFactorySupplier(timeoutProperties, Collections.emptySet()); + } + } @SpringBootConfiguration diff --git a/spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/RestTemplateEurekaClientTests.java b/spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/RestTemplateEurekaClientTests.java deleted file mode 100644 index a8749c6e1..000000000 --- a/spring-cloud-netflix-eureka-client-tls-tests/src/test/java/org/springframework/cloud/netflix/eureka/RestTemplateEurekaClientTests.java +++ /dev/null @@ -1,106 +0,0 @@ -/* - * Copyright 2018-present 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 - * - * https://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.io.IOException; -import java.security.GeneralSecurityException; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.junit.jupiter.api.AfterAll; -import org.junit.jupiter.api.BeforeAll; - -import org.springframework.boot.SpringBootConfiguration; -import org.springframework.boot.autoconfigure.EnableAutoConfiguration; -import org.springframework.boot.restclient.RestTemplateBuilder; -import org.springframework.cloud.configuration.TlsProperties; -import org.springframework.cloud.netflix.eureka.http.DefaultEurekaClientHttpRequestFactorySupplier; -import org.springframework.cloud.netflix.eureka.http.EurekaClientHttpRequestFactorySupplier; -import org.springframework.cloud.netflix.eureka.http.RestTemplateDiscoveryClientOptionalArgs; -import org.springframework.cloud.netflix.eureka.http.RestTemplateTransportClientFactories; -import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer; -import org.springframework.context.annotation.Bean; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.springframework.cloud.netflix.eureka.config.DiscoveryClientOptionalArgsConfiguration.setupTLS; - -public class RestTemplateEurekaClientTests extends BaseCertTests { - - private static final Log log = LogFactory.getLog(RestTemplateEurekaClientTests.class); - - private static EurekaServerRunner server; - - private static EurekaClientRunner service; - - @BeforeAll - public static void setupAll() { - server = startEurekaServer(TestEurekaServer.class); - service = startService(server, RestTemplateEurekaClientTests.RestTemplateTestApp.class); - // Will use RestTemplate - assertThat(service.discoveryClientOptionalArgs()).isInstanceOf(RestTemplateDiscoveryClientOptionalArgs.class); - log.info("Successfully asserted that RestTemplate will be used"); - waitForRegistration(() -> new RestTemplateEurekaClientTests().createEurekaClient()); - } - - @AfterAll - public static void tearDownAll() { - stopService(service); - stopEurekaServer(server); - } - - @Override - EurekaClientRunner createEurekaClient() { - return new EurekaClientRunner(RestTemplateTestApp.class, server); - } - - @SpringBootConfiguration - @EnableAutoConfiguration - public static class RestTemplateTestApp { - - @Bean - public RestTemplateDiscoveryClientOptionalArgs forceRestTemplateDiscoveryClientOptionalArgs( - TlsProperties tlsProperties, - EurekaClientHttpRequestFactorySupplier eurekaClientHttpRequestFactorySupplier) - throws GeneralSecurityException, IOException { - RestTemplateDiscoveryClientOptionalArgs result = new RestTemplateDiscoveryClientOptionalArgs( - eurekaClientHttpRequestFactorySupplier, RestTemplateBuilder::new); - setupTLS(result, tlsProperties); - return result; - } - - @Bean - public RestTemplateTransportClientFactories forceRestTemplateTransportClientFactories( - RestTemplateDiscoveryClientOptionalArgs discoveryClientOptionalArgs) { - return new RestTemplateTransportClientFactories(discoveryClientOptionalArgs); - } - - @Bean - EurekaClientHttpRequestFactorySupplier defaultEurekaClientHttpRequestFactorySupplier( - RestTemplateTimeoutProperties restTemplateTimeoutProperties) { - return new DefaultEurekaClientHttpRequestFactorySupplier(restTemplateTimeoutProperties); - } - - } - - @SpringBootConfiguration - @EnableAutoConfiguration - @EnableEurekaServer - public static class TestEurekaServer { - - } - -} diff --git a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/RestClientTimeoutProperties.java b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/RestClientTimeoutProperties.java deleted file mode 100644 index 520a0d52e..000000000 --- a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/RestClientTimeoutProperties.java +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright 2013-present 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 - * - * https://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 org.springframework.boot.context.properties.ConfigurationProperties; -import org.springframework.web.client.RestClient; - -/** - * A {@link RestClient}-specific {@link TimeoutProperties} implementation. - * - * @author Olga Maciaszek-Sharma - * @since 4.2.0 - */ -@ConfigurationProperties("eureka.client.restclient.timeout") -public class RestClientTimeoutProperties extends TimeoutProperties { - - @Override - public String toString() { - return "RestClientTimeoutProperties{" + ", connectTimeout=" + connectTimeout + ", connectRequestTimeout=" - + connectRequestTimeout + ", socketTimeout=" + socketTimeout + '}'; - } - -} diff --git a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/RestTemplateTimeoutProperties.java b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/RestTemplateTimeoutProperties.java deleted file mode 100644 index 94bb8fdb2..000000000 --- a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/RestTemplateTimeoutProperties.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright 2013-present 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 - * - * https://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 org.springframework.boot.context.properties.ConfigurationProperties; -import org.springframework.web.client.RestClient; -import org.springframework.web.client.RestTemplate; - -/** - * A {@link RestTemplate}-specific {@link TimeoutProperties} implementation. - * - * @author Jiwon Jeon - * @author Mooyong Lee - * @author Olga Maciaszek-Sharma - * @since 3.1.6 - * @deprecated {@link RestTemplate}-based implementation to be removed in favour of - * {@link RestClient}-based implementation. - */ -@Deprecated(forRemoval = true) -@ConfigurationProperties("eureka.client.rest-template-timeout") -public class RestTemplateTimeoutProperties extends TimeoutProperties { - - @Override - public String toString() { - return "RestTemplateTimeoutProperties{" + ", connectTimeout=" + connectTimeout + ", connectRequestTimeout=" - + connectRequestTimeout + ", socketTimeout=" + socketTimeout + '}'; - } - -} diff --git a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/TimeoutProperties.java b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/TimeoutProperties.java index 9fa205a9a..50603f026 100644 --- a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/TimeoutProperties.java +++ b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/TimeoutProperties.java @@ -22,10 +22,11 @@ import com.netflix.discovery.shared.transport.EurekaHttpClient; import org.apache.hc.client5.http.config.RequestConfig; import org.apache.hc.core5.http.io.SocketConfig; -import org.springframework.web.client.RestTemplate; +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.web.client.RestClient; /** - * Properties for configuring timeouts used in {@link RestTemplate} required by + * Properties for configuring timeouts used in {@link RestClient} required by * {@link EurekaHttpClient}. * * @author Jiwon Jeon @@ -33,7 +34,8 @@ import org.springframework.web.client.RestTemplate; * @author Olga Maciaszek-Sharma * @since 4.2.0 */ -public abstract class TimeoutProperties { +@ConfigurationProperties("eureka.client.timeout") +public class TimeoutProperties { /** * Default values are set to 180000, in keeping with {@link RequestConfig} and @@ -78,7 +80,7 @@ public abstract class TimeoutProperties { return false; } - RestTemplateTimeoutProperties that = (RestTemplateTimeoutProperties) o; + TimeoutProperties that = (TimeoutProperties) o; return connectTimeout == that.connectTimeout && connectRequestTimeout == that.connectRequestTimeout && socketTimeout == that.socketTimeout; diff --git a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/config/DiscoveryClientOptionalArgsConfiguration.java b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/config/DiscoveryClientOptionalArgsConfiguration.java index fd44eaab3..7bac533cc 100644 --- a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/config/DiscoveryClientOptionalArgsConfiguration.java +++ b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/config/DiscoveryClientOptionalArgsConfiguration.java @@ -36,24 +36,19 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.boot.autoconfigure.condition.SearchStrategy; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.context.properties.EnableConfigurationProperties; -import org.springframework.boot.restclient.RestTemplateBuilder; import org.springframework.cloud.configuration.SSLContextFactory; import org.springframework.cloud.configuration.TlsProperties; -import org.springframework.cloud.netflix.eureka.RestClientTimeoutProperties; -import org.springframework.cloud.netflix.eureka.RestTemplateTimeoutProperties; +import org.springframework.cloud.netflix.eureka.TimeoutProperties; import org.springframework.cloud.netflix.eureka.http.DefaultEurekaClientHttpRequestFactorySupplier; import org.springframework.cloud.netflix.eureka.http.EurekaClientHttpRequestFactorySupplier; import org.springframework.cloud.netflix.eureka.http.RestClientDiscoveryClientOptionalArgs; import org.springframework.cloud.netflix.eureka.http.RestClientTransportClientFactories; -import org.springframework.cloud.netflix.eureka.http.RestTemplateDiscoveryClientOptionalArgs; -import org.springframework.cloud.netflix.eureka.http.RestTemplateTransportClientFactories; import org.springframework.cloud.netflix.eureka.http.WebClientDiscoveryClientOptionalArgs; import org.springframework.cloud.netflix.eureka.http.WebClientTransportClientFactories; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Conditional; import org.springframework.context.annotation.Configuration; import org.springframework.web.client.RestClient; -import org.springframework.web.client.RestTemplate; import org.springframework.web.reactive.function.client.WebClient; /** @@ -63,10 +58,10 @@ import org.springframework.web.reactive.function.client.WebClient; * @author Wonchul Heo */ @Configuration(proxyBeanMethods = false) -@EnableConfigurationProperties({ RestTemplateTimeoutProperties.class, RestClientTimeoutProperties.class }) +@EnableConfigurationProperties({ TimeoutProperties.class }) public class DiscoveryClientOptionalArgsConfiguration { - protected static final Log logger = LogFactory.getLog(DiscoveryClientOptionalArgsConfiguration.class); + protected static final Log LOG = LogFactory.getLog(DiscoveryClientOptionalArgsConfiguration.class); @Bean @ConfigurationProperties("eureka.client.tls") @@ -83,49 +78,6 @@ public class DiscoveryClientOptionalArgsConfiguration { } } - /** - * @deprecated {@link RestTemplate}-based implementation to be removed in favour of - * {@link RestClient}-based implementation. - */ - @Configuration(proxyBeanMethods = false) - @Conditional(OnRestTemplatePresentAndEnabledCondition.class) - @Deprecated - static class RestTemplateConfiguration { - - @Bean - @ConditionalOnMissingBean - EurekaClientHttpRequestFactorySupplier defaultEurekaClientHttpRequestFactorySupplier( - RestTemplateTimeoutProperties restTemplateTimeoutProperties, - Set requestConfigCustomizers) { - return new DefaultEurekaClientHttpRequestFactorySupplier(restTemplateTimeoutProperties, - requestConfigCustomizers); - } - - @Bean - @ConditionalOnMissingBean(value = { AbstractDiscoveryClientOptionalArgs.class }, - search = SearchStrategy.CURRENT) - public RestTemplateDiscoveryClientOptionalArgs restTemplateDiscoveryClientOptionalArgs( - TlsProperties tlsProperties, - EurekaClientHttpRequestFactorySupplier eurekaClientHttpRequestFactorySupplier, - ObjectProvider restTemplateBuilders) throws GeneralSecurityException, IOException { - if (logger.isInfoEnabled()) { - logger.info("Eureka HTTP Client uses RestTemplate."); - } - RestTemplateDiscoveryClientOptionalArgs result = new RestTemplateDiscoveryClientOptionalArgs( - eurekaClientHttpRequestFactorySupplier, restTemplateBuilders::getIfAvailable); - setupTLS(result, tlsProperties); - return result; - } - - @Bean - @ConditionalOnMissingBean(value = { TransportClientFactories.class }, search = SearchStrategy.CURRENT) - public RestTemplateTransportClientFactories restTemplateTransportClientFactories( - RestTemplateDiscoveryClientOptionalArgs optionalArgs) { - return new RestTemplateTransportClientFactories(optionalArgs); - } - - } - @Configuration(proxyBeanMethods = false) @Conditional(OnJerseyClientPresentAndEnabledCondition.class) @ConditionalOnBean(value = AbstractDiscoveryClientOptionalArgs.class, search = SearchStrategy.CURRENT) @@ -133,8 +85,8 @@ public class DiscoveryClientOptionalArgsConfiguration { DiscoveryClientOptionalArgsTlsConfiguration(TlsProperties tlsProperties, AbstractDiscoveryClientOptionalArgs optionalArgs) throws GeneralSecurityException, IOException { - if (logger.isInfoEnabled()) { - logger.info("Eureka HTTP Client uses Jersey"); + if (LOG.isInfoEnabled()) { + LOG.info("Eureka HTTP Client uses Jersey"); } setupTLS(optionalArgs, tlsProperties); } @@ -149,12 +101,12 @@ public class DiscoveryClientOptionalArgsConfiguration { @Bean @ConditionalOnMissingBean( - value = { AbstractDiscoveryClientOptionalArgs.class, RestTemplateDiscoveryClientOptionalArgs.class }, + value = { AbstractDiscoveryClientOptionalArgs.class, RestClientDiscoveryClientOptionalArgs.class }, search = SearchStrategy.CURRENT) public WebClientDiscoveryClientOptionalArgs webClientDiscoveryClientOptionalArgs(TlsProperties tlsProperties, ObjectProvider builder) throws GeneralSecurityException, IOException { - if (logger.isInfoEnabled()) { - logger.info("Eureka HTTP Client uses WebClient."); + if (LOG.isInfoEnabled()) { + LOG.info("Eureka HTTP Client uses WebClient."); } WebClientDiscoveryClientOptionalArgs result = new WebClientDiscoveryClientOptionalArgs( builder::getIfAvailable); @@ -191,7 +143,7 @@ public class DiscoveryClientOptionalArgsConfiguration { @Bean @ConditionalOnMissingBean EurekaClientHttpRequestFactorySupplier defaultEurekaClientHttpRequestFactorySupplier( - RestClientTimeoutProperties restClientTimeoutProperties, + TimeoutProperties restClientTimeoutProperties, Set requestConfigCustomizers) { return new DefaultEurekaClientHttpRequestFactorySupplier(restClientTimeoutProperties, requestConfigCustomizers); @@ -204,8 +156,8 @@ public class DiscoveryClientOptionalArgsConfiguration { EurekaClientHttpRequestFactorySupplier eurekaClientHttpRequestFactorySupplier, ObjectProvider restClientBuilderProvider) throws GeneralSecurityException, IOException { - if (logger.isInfoEnabled()) { - logger.info("Eureka HTTP Client uses RestClient."); + if (LOG.isInfoEnabled()) { + LOG.info("Eureka HTTP Client uses RestClient."); } RestClientDiscoveryClientOptionalArgs result = new RestClientDiscoveryClientOptionalArgs( eurekaClientHttpRequestFactorySupplier, @@ -259,46 +211,6 @@ public class DiscoveryClientOptionalArgsConfiguration { } - /** - * @deprecated {@link RestTemplate}-based implementation to be removed in favour of - * {@link RestClient}-based implementation. - */ - @Deprecated(forRemoval = true) - static class OnRestTemplatePresentAndEnabledCondition extends AllNestedConditions { - - OnRestTemplatePresentAndEnabledCondition() { - super(ConfigurationPhase.REGISTER_BEAN); - } - - @ConditionalOnClass(name = "org.springframework.web.client.RestTemplate") - static class OnRestTemplatePresent { - - } - - @ConditionalOnClass(name = "org.springframework.boot.restclient.RestTemplateBuilder") - static class OnRestTemplateBuilderPresent { - - } - - @Conditional(OnJerseyClientNotPresentOrNotEnabledCondition.class) - static class OnJerseyClientNotPresentOrNotEnabled { - - } - - @ConditionalOnProperty(prefix = "eureka.client", name = "webclient.enabled", matchIfMissing = true, - havingValue = "false") - static class OnWebClientDisabled { - - } - - @ConditionalOnProperty(prefix = "eureka.client", name = "restclient.enabled", havingValue = "false", - matchIfMissing = true) - static class OnRestClientDisabled { - - } - - } - static class OnRestClientPresentAndEnabledCondition extends AllNestedConditions { OnRestClientPresentAndEnabledCondition() { @@ -321,11 +233,6 @@ public class DiscoveryClientOptionalArgsConfiguration { } - @ConditionalOnProperty(prefix = "eureka.client", name = "restclient.enabled", havingValue = "true") - static class OnRestClientEnabled { - - } - } } diff --git a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfiguration.java b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfiguration.java index 55af65045..c98a0f303 100644 --- a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfiguration.java +++ b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfiguration.java @@ -30,20 +30,16 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.boot.autoconfigure.condition.SearchStrategy; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.boot.http.codec.autoconfigure.CodecsAutoConfiguration; -import org.springframework.boot.restclient.RestTemplateBuilder; import org.springframework.boot.webclient.autoconfigure.WebClientAutoConfiguration; import org.springframework.cloud.config.client.ConfigServerInstanceProvider; import org.springframework.cloud.config.client.ConfigServicePropertySourceLocator; import org.springframework.cloud.configuration.TlsProperties; import org.springframework.cloud.netflix.eureka.EurekaClientConfigBean; -import org.springframework.cloud.netflix.eureka.RestClientTimeoutProperties; -import org.springframework.cloud.netflix.eureka.RestTemplateTimeoutProperties; +import org.springframework.cloud.netflix.eureka.TimeoutProperties; import org.springframework.cloud.netflix.eureka.http.DefaultEurekaClientHttpRequestFactorySupplier; import org.springframework.cloud.netflix.eureka.http.EurekaClientHttpRequestFactorySupplier; import org.springframework.cloud.netflix.eureka.http.RestClientEurekaHttpClient; import org.springframework.cloud.netflix.eureka.http.RestClientTransportClientFactory; -import org.springframework.cloud.netflix.eureka.http.RestTemplateEurekaHttpClient; -import org.springframework.cloud.netflix.eureka.http.RestTemplateTransportClientFactory; import org.springframework.cloud.netflix.eureka.http.WebClientEurekaHttpClient; import org.springframework.cloud.netflix.eureka.http.WebClientTransportClientFactory; import org.springframework.context.annotation.Bean; @@ -52,7 +48,6 @@ import org.springframework.context.annotation.Configuration; import org.springframework.core.env.Environment; import org.springframework.lang.Nullable; import org.springframework.web.client.RestClient; -import org.springframework.web.client.RestTemplate; import org.springframework.web.reactive.function.client.WebClient; /** @@ -67,7 +62,7 @@ import org.springframework.web.reactive.function.client.WebClient; @ConditionalOnClass(ConfigServicePropertySourceLocator.class) @Conditional(EurekaConfigServerBootstrapConfiguration.EurekaConfigServerBootstrapCondition.class) @Configuration(proxyBeanMethods = false) -@EnableConfigurationProperties({ RestTemplateTimeoutProperties.class, RestClientTimeoutProperties.class }) +@EnableConfigurationProperties({ TimeoutProperties.class }) public class EurekaConfigServerBootstrapConfiguration { @Bean @@ -82,67 +77,6 @@ public class EurekaConfigServerBootstrapConfiguration { return new EurekaConfigServerInstanceProvider(client, config)::getInstances; } - /** - * @deprecated {@link RestTemplate}-based implementation to be removed in favour of - * {@link RestClient}-based implementation. - */ - @Configuration(proxyBeanMethods = false) - @Conditional(RestTemplateConfiguration.OnRestTemplatePresentAndEnabledCondition.class) - @Deprecated - static class RestTemplateConfiguration { - - @Bean - @ConditionalOnMissingBean(EurekaHttpClient.class) - public RestTemplateEurekaHttpClient configDiscoveryRestTemplateEurekaHttpClient(EurekaClientConfigBean config, - Environment env, @Nullable TlsProperties properties, - EurekaClientHttpRequestFactorySupplier eurekaClientHttpRequestFactorySupplier, - ObjectProvider restTemplateBuilders) { - return (RestTemplateEurekaHttpClient) new RestTemplateTransportClientFactory(properties, - eurekaClientHttpRequestFactorySupplier, restTemplateBuilders::getIfAvailable) - .newClient(HostnameBasedUrlRandomizer.randomEndpoint(config, env)); - } - - @Bean - @ConditionalOnMissingBean - EurekaClientHttpRequestFactorySupplier defaultEurekaClientHttpRequestFactorySupplier( - RestTemplateTimeoutProperties restTemplateTimeoutProperties, - Set requestConfigCustomizers) { - return new DefaultEurekaClientHttpRequestFactorySupplier(restTemplateTimeoutProperties, - requestConfigCustomizers); - } - - /** - * @deprecated {@link RestTemplate}-based implementation to be removed in favour - * of {@link RestClient}-based implementation. - */ - @Deprecated(forRemoval = true) - static class OnRestTemplatePresentAndEnabledCondition extends AllNestedConditions { - - OnRestTemplatePresentAndEnabledCondition() { - super(ConfigurationPhase.REGISTER_BEAN); - } - - @ConditionalOnClass(name = "org.springframework.web.client.RestTemplate") - static class OnRestTemplatePresent { - - } - - @ConditionalOnProperty(prefix = "eureka.client", name = "webclient.enabled", matchIfMissing = true, - havingValue = "false") - static class OnWebClientDisabled { - - } - - @ConditionalOnProperty(prefix = "eureka.client", name = "restclient.enabled", havingValue = "false", - matchIfMissing = true) - static class OnRestClientDisabled { - - } - - } - - } - @Configuration(proxyBeanMethods = false) @ConditionalOnClass({ WebClient.class, WebClientAutoConfiguration.class, CodecsAutoConfiguration.class }) @ConditionalOnProperty(prefix = "eureka.client", name = "webclient.enabled", havingValue = "true") @@ -178,10 +112,9 @@ public class EurekaConfigServerBootstrapConfiguration { @Bean @ConditionalOnMissingBean EurekaClientHttpRequestFactorySupplier defaultEurekaClientHttpRequestFactorySupplier( - RestClientTimeoutProperties restClientTimeoutProperties, + TimeoutProperties timeoutProperties, Set requestConfigCustomizers) { - return new DefaultEurekaClientHttpRequestFactorySupplier(restClientTimeoutProperties, - requestConfigCustomizers); + return new DefaultEurekaClientHttpRequestFactorySupplier(timeoutProperties, requestConfigCustomizers); } static class OnRestClientPresentAndEnabledCondition extends AllNestedConditions { @@ -201,11 +134,6 @@ public class EurekaConfigServerBootstrapConfiguration { } - @ConditionalOnProperty(prefix = "eureka.client", name = "restclient.enabled", havingValue = "true") - static class OnRestClientEnabled { - - } - } } diff --git a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapper.java b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapper.java index 1366b9eb7..df4f07e60 100644 --- a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapper.java +++ b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapper.java @@ -30,7 +30,7 @@ import org.springframework.cloud.config.client.ConfigServerConfigDataLocationRes import org.springframework.cloud.config.client.ConfigServerInstanceProvider; import org.springframework.cloud.configuration.TlsProperties; import org.springframework.cloud.netflix.eureka.EurekaClientConfigBean; -import org.springframework.cloud.netflix.eureka.RestClientTimeoutProperties; +import org.springframework.cloud.netflix.eureka.TimeoutProperties; import org.springframework.cloud.netflix.eureka.http.DefaultEurekaClientHttpRequestFactorySupplier; import org.springframework.cloud.netflix.eureka.http.EurekaClientHttpRequestFactorySupplier; import org.springframework.cloud.netflix.eureka.http.RestClientTransportClientFactory; @@ -61,7 +61,7 @@ public class EurekaConfigServerBootstrapper implements BootstrapRegistryInitiali EurekaHttpClient httpClient = new RestClientTransportClientFactory( context.getOrElse(TlsProperties.class, null), context.getOrElse(EurekaClientHttpRequestFactorySupplier.class, - new DefaultEurekaClientHttpRequestFactorySupplier(new RestClientTimeoutProperties(), + new DefaultEurekaClientHttpRequestFactorySupplier(new TimeoutProperties(), Collections.emptySet()))) .newClient(HostnameBasedUrlRandomizer.randomEndpoint(config, getPropertyResolver(context))); return new EurekaConfigServerInstanceProvider(httpClient, config)::getInstances; diff --git a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/DefaultEurekaClientHttpRequestFactorySupplier.java b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/DefaultEurekaClientHttpRequestFactorySupplier.java index d9d046f0d..3db961365 100644 --- a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/DefaultEurekaClientHttpRequestFactorySupplier.java +++ b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/DefaultEurekaClientHttpRequestFactorySupplier.java @@ -16,7 +16,6 @@ package org.springframework.cloud.netflix.eureka.http; -import java.util.Collections; import java.util.Set; import java.util.concurrent.TimeUnit; @@ -34,7 +33,6 @@ import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactoryBuilder; import org.apache.hc.core5.http.io.SocketConfig; import org.apache.hc.core5.util.Timeout; -import org.springframework.cloud.netflix.eureka.RestTemplateTimeoutProperties; import org.springframework.cloud.netflix.eureka.TimeoutProperties; import org.springframework.http.client.ClientHttpRequestFactory; import org.springframework.http.client.HttpComponentsClientHttpRequestFactory; @@ -53,35 +51,7 @@ public class DefaultEurekaClientHttpRequestFactorySupplier implements EurekaClie private final TimeoutProperties timeoutProperties; - // TODO: switch to final after removing deprecated interfaces - private Set requestConfigCustomizers = Collections.emptySet(); - - /** - * @deprecated in favour of - * {@link DefaultEurekaClientHttpRequestFactorySupplier#DefaultEurekaClientHttpRequestFactorySupplier(TimeoutProperties, Set)} - */ - @Deprecated(forRemoval = true) - public DefaultEurekaClientHttpRequestFactorySupplier() { - this.timeoutProperties = new RestTemplateTimeoutProperties(); - } - - /** - * @deprecated in favour of - * {@link DefaultEurekaClientHttpRequestFactorySupplier#DefaultEurekaClientHttpRequestFactorySupplier(TimeoutProperties, Set)} - */ - @Deprecated(forRemoval = true) - public DefaultEurekaClientHttpRequestFactorySupplier(RestTemplateTimeoutProperties timeoutProperties) { - this.timeoutProperties = timeoutProperties; - } - - /** - * @deprecated in favour of - * {@link DefaultEurekaClientHttpRequestFactorySupplier#DefaultEurekaClientHttpRequestFactorySupplier(TimeoutProperties, Set)} - */ - @Deprecated(forRemoval = true) - public DefaultEurekaClientHttpRequestFactorySupplier(TimeoutProperties timeoutProperties) { - this.timeoutProperties = timeoutProperties; - } + private final Set requestConfigCustomizers; public DefaultEurekaClientHttpRequestFactorySupplier(TimeoutProperties timeoutProperties, Set requestConfigCustomizers) { diff --git a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateDiscoveryClientOptionalArgs.java b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateDiscoveryClientOptionalArgs.java deleted file mode 100644 index fb56d90e4..000000000 --- a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateDiscoveryClientOptionalArgs.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Copyright 2017-present 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 - * - * https://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.http; - -import java.util.function.Supplier; - -import com.netflix.discovery.AbstractDiscoveryClientOptionalArgs; - -import org.springframework.boot.restclient.RestTemplateBuilder; -import org.springframework.web.client.RestClient; -import org.springframework.web.client.RestTemplate; - -/** - * @author Daniel Lavoie - * @author Armin Krezovic - * @deprecated {@link RestTemplate}-based implementation to be removed in favour of - * {@link RestClient}-based implementation. - */ -@Deprecated -public class RestTemplateDiscoveryClientOptionalArgs extends AbstractDiscoveryClientOptionalArgs { - - protected final EurekaClientHttpRequestFactorySupplier eurekaClientHttpRequestFactorySupplier; - - protected final Supplier restTemplateBuilderSupplier; - - public RestTemplateDiscoveryClientOptionalArgs( - EurekaClientHttpRequestFactorySupplier eurekaClientHttpRequestFactorySupplier) { - this(eurekaClientHttpRequestFactorySupplier, RestTemplateBuilder::new); - } - - public RestTemplateDiscoveryClientOptionalArgs( - EurekaClientHttpRequestFactorySupplier eurekaClientHttpRequestFactorySupplier, - Supplier restTemplateBuilderSupplier) { - this.eurekaClientHttpRequestFactorySupplier = eurekaClientHttpRequestFactorySupplier; - this.restTemplateBuilderSupplier = restTemplateBuilderSupplier; - } - -} diff --git a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateEurekaHttpClient.java b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateEurekaHttpClient.java deleted file mode 100644 index 22ac00636..000000000 --- a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateEurekaHttpClient.java +++ /dev/null @@ -1,252 +0,0 @@ -/* - * Copyright 2017-present 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 - * - * https://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.http; - -import java.net.URI; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; - -import com.netflix.appinfo.InstanceInfo; -import com.netflix.appinfo.InstanceInfo.InstanceStatus; -import com.netflix.discovery.shared.Application; -import com.netflix.discovery.shared.Applications; -import com.netflix.discovery.shared.transport.EurekaHttpClient; -import com.netflix.discovery.shared.transport.EurekaHttpResponse; -import com.netflix.discovery.shared.transport.EurekaHttpResponse.EurekaHttpResponseBuilder; -import com.netflix.discovery.util.StringUtil; - -import org.springframework.http.HttpEntity; -import org.springframework.http.HttpHeaders; -import org.springframework.http.HttpMethod; -import org.springframework.http.HttpStatus; -import org.springframework.http.MediaType; -import org.springframework.http.ResponseEntity; -import org.springframework.web.client.RestClient; -import org.springframework.web.client.RestTemplate; -import org.springframework.web.util.UriComponentsBuilder; - -import static com.netflix.discovery.shared.transport.EurekaHttpResponse.anEurekaHttpResponse; - -/** - * @author Daniel Lavoie - * @author Václav Plic - * @deprecated {@link RestTemplate}-based implementation to be removed in favour of - * {@link RestClient}-based implementation. - */ -@Deprecated(forRemoval = true) -public class RestTemplateEurekaHttpClient implements EurekaHttpClient { - - private final RestTemplate restTemplate; - - private String serviceUrl; - - public RestTemplateEurekaHttpClient(RestTemplate restTemplate, String serviceUrl) { - this.restTemplate = restTemplate; - this.serviceUrl = serviceUrl; - if (!serviceUrl.endsWith("/")) { - this.serviceUrl = this.serviceUrl + "/"; - } - } - - public String getServiceUrl() { - return this.serviceUrl; - } - - public RestTemplate getRestTemplate() { - return restTemplate; - } - - @Override - public EurekaHttpResponse register(InstanceInfo info) { - URI uri = UriComponentsBuilder.fromUriString(serviceUrl) - .path("apps/{appName}") - .buildAndExpand(info.getAppName()) - .toUri(); - - HttpHeaders headers = new HttpHeaders(); - headers.add(HttpHeaders.ACCEPT_ENCODING, "gzip"); - headers.add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE); - - ResponseEntity response = restTemplate.exchange(uri, HttpMethod.POST, new HttpEntity<>(info, headers), - Void.class); - - return anEurekaHttpResponse(response.getStatusCode().value()).headers(headersOf(response)).build(); - } - - @Override - public EurekaHttpResponse cancel(String appName, String id) { - URI uri = UriComponentsBuilder.fromUriString(serviceUrl) - .path("apps/{appName}/{id}") - .buildAndExpand(appName, id) - .toUri(); - - ResponseEntity response = restTemplate.exchange(uri, HttpMethod.DELETE, null, Void.class); - - return anEurekaHttpResponse(response.getStatusCode().value()).headers(headersOf(response)).build(); - } - - @Override - public EurekaHttpResponse sendHeartBeat(String appName, String id, InstanceInfo info, - InstanceStatus overriddenStatus) { - UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromUriString(serviceUrl) - .path("apps/{appName}/{id}") - .queryParam("status", info.getStatus().toString()) - .queryParam("lastDirtyTimestamp", info.getLastDirtyTimestamp().toString()); - - if (overriddenStatus != null) { - uriBuilder = uriBuilder.queryParam("overriddenstatus", overriddenStatus.name()); - } - - URI uri = uriBuilder.buildAndExpand(appName, id).toUri(); - - ResponseEntity response = restTemplate.exchange(uri, HttpMethod.PUT, null, InstanceInfo.class); - - EurekaHttpResponseBuilder eurekaResponseBuilder = anEurekaHttpResponse( - response.getStatusCode().value(), InstanceInfo.class) - .headers(headersOf(response)); - - if (response.hasBody()) { - eurekaResponseBuilder.entity(response.getBody()); - } - - return eurekaResponseBuilder.build(); - } - - @Override - public EurekaHttpResponse statusUpdate(String appName, String id, InstanceStatus newStatus, - InstanceInfo info) { - URI uri = UriComponentsBuilder.fromUriString(serviceUrl) - .path("apps/{appName}/{id}/status") - .queryParam("value", newStatus.name()) - .queryParam("lastDirtyTimestamp", info.getLastDirtyTimestamp().toString()) - .buildAndExpand(appName, id) - .toUri(); - - ResponseEntity response = restTemplate.exchange(uri, HttpMethod.PUT, null, Void.class); - - return anEurekaHttpResponse(response.getStatusCode().value()).headers(headersOf(response)).build(); - } - - @Override - public EurekaHttpResponse deleteStatusOverride(String appName, String id, InstanceInfo info) { - URI uri = UriComponentsBuilder.fromUriString(serviceUrl) - .path("apps/{appName}/{id}/status") - .queryParam("lastDirtyTimestamp", info.getLastDirtyTimestamp().toString()) - .buildAndExpand(appName, id) - .toUri(); - - ResponseEntity response = restTemplate.exchange(uri, HttpMethod.DELETE, null, Void.class); - - return anEurekaHttpResponse(response.getStatusCode().value()).headers(headersOf(response)).build(); - } - - @Override - public EurekaHttpResponse getApplications(String... regions) { - return getApplicationsInternal("apps/", regions); - } - - private EurekaHttpResponse getApplicationsInternal(String urlPath, String[] regions) { - UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromUriString(serviceUrl).path(urlPath); - - if (regions != null && regions.length > 0) { - uriBuilder = uriBuilder.queryParam("regions", StringUtil.join(regions)); - } - - URI uri = uriBuilder.build().toUri(); - - ResponseEntity response = restTemplate.exchange(uri, HttpMethod.GET, null, - EurekaApplications.class); - - return anEurekaHttpResponse(response.getStatusCode().value(), - response.getStatusCode().value() == HttpStatus.OK.value() && response.hasBody() - ? (Applications) response.getBody() : null) - .headers(headersOf(response)) - .build(); - } - - @Override - public EurekaHttpResponse getDelta(String... regions) { - return getApplicationsInternal("apps/delta", regions); - } - - @Override - public EurekaHttpResponse getVip(String vipAddress, String... regions) { - return getApplicationsInternal("vips/" + vipAddress, regions); - } - - @Override - public EurekaHttpResponse getSecureVip(String secureVipAddress, String... regions) { - return getApplicationsInternal("svips/" + secureVipAddress, regions); - } - - @Override - public EurekaHttpResponse getApplication(String appName) { - URI uri = UriComponentsBuilder.fromUriString(serviceUrl).path("apps/{appName}").buildAndExpand(appName).toUri(); - - ResponseEntity response = restTemplate.exchange(uri, HttpMethod.GET, null, Application.class); - - Application application = response.getStatusCode().value() == HttpStatus.OK.value() && response.hasBody() - ? response.getBody() : null; - - return anEurekaHttpResponse(response.getStatusCode().value(), application).headers(headersOf(response)).build(); - } - - @Override - public EurekaHttpResponse getInstance(String appName, String id) { - return getInstanceInternal("apps", appName, id); - } - - @Override - public EurekaHttpResponse getInstance(String id) { - return getInstanceInternal("instances", id); - } - - private EurekaHttpResponse getInstanceInternal(String... pathSegments) { - URI uri = UriComponentsBuilder.fromUriString(serviceUrl).pathSegment(pathSegments).build().toUri(); - - ResponseEntity response = restTemplate.exchange(uri, HttpMethod.GET, null, InstanceInfo.class); - - return anEurekaHttpResponse(response.getStatusCode().value(), - response.getStatusCode().value() == HttpStatus.OK.value() && response.hasBody() ? response.getBody() - : null) - .headers(headersOf(response)) - .build(); - } - - @Override - public void shutdown() { - // Nothing to do - } - - private static Map headersOf(ResponseEntity response) { - HttpHeaders httpHeaders = response.getHeaders(); - if (httpHeaders == null || httpHeaders.isEmpty()) { - return Collections.emptyMap(); - } - Map headers = new HashMap<>(); - for (Entry> entry : httpHeaders.headerSet()) { - if (!entry.getValue().isEmpty()) { - headers.put(entry.getKey(), entry.getValue().get(0)); - } - } - return headers; - } - -} diff --git a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateTransportClientFactories.java b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateTransportClientFactories.java deleted file mode 100644 index 389031a7e..000000000 --- a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateTransportClientFactories.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Copyright 2017-present 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 - * - * https://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.http; - -import java.util.Collection; -import java.util.Optional; - -import javax.net.ssl.HostnameVerifier; -import javax.net.ssl.SSLContext; - -import com.netflix.appinfo.InstanceInfo; -import com.netflix.discovery.EurekaClientConfig; -import com.netflix.discovery.shared.transport.TransportClientFactory; -import com.netflix.discovery.shared.transport.jersey.TransportClientFactories; - -import org.springframework.web.client.RestClient; -import org.springframework.web.client.RestTemplate; - -/** - * @author Daniel Lavoie - * @author Armin Krezovic - * @deprecated {@link RestTemplate}-based implementation to be removed in favour of - * {@link RestClient}-based implementation. - */ -@Deprecated(forRemoval = true) -public class RestTemplateTransportClientFactories implements TransportClientFactories { - - private final RestTemplateDiscoveryClientOptionalArgs args; - - public RestTemplateTransportClientFactories(RestTemplateDiscoveryClientOptionalArgs args) { - this.args = args; - } - - @Override - public TransportClientFactory newTransportClientFactory(EurekaClientConfig clientConfig, - Collection additionalFilters, InstanceInfo myInstanceInfo) { - return new RestTemplateTransportClientFactory(args.getSSLContext(), args.getHostnameVerifier(), - args.eurekaClientHttpRequestFactorySupplier, args.restTemplateBuilderSupplier); - } - - @Override - public TransportClientFactory newTransportClientFactory(final EurekaClientConfig clientConfig, - final Collection additionalFilters, final InstanceInfo myInstanceInfo, - final Optional sslContext, final Optional hostnameVerifier) { - return new RestTemplateTransportClientFactory(args.getSSLContext(), args.getHostnameVerifier(), - args.eurekaClientHttpRequestFactorySupplier, args.restTemplateBuilderSupplier); - } - -} diff --git a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateTransportClientFactory.java b/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateTransportClientFactory.java deleted file mode 100644 index cbcef2837..000000000 --- a/spring-cloud-netflix-eureka-client/src/main/java/org/springframework/cloud/netflix/eureka/http/RestTemplateTransportClientFactory.java +++ /dev/null @@ -1,177 +0,0 @@ -/* - * Copyright 2017-present 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 - * - * https://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.http; - -import java.util.Optional; -import java.util.function.Supplier; - -import javax.net.ssl.HostnameVerifier; -import javax.net.ssl.SSLContext; - -import com.netflix.discovery.shared.resolver.EurekaEndpoint; -import com.netflix.discovery.shared.transport.EurekaHttpClient; -import com.netflix.discovery.shared.transport.TransportClientFactory; - -import org.springframework.boot.restclient.RestTemplateBuilder; -import org.springframework.cloud.configuration.TlsProperties; -import org.springframework.http.HttpStatus; -import org.springframework.http.HttpStatusCode; -import org.springframework.http.client.ClientHttpRequestFactory; -import org.springframework.http.client.ClientHttpResponse; -import org.springframework.http.client.support.BasicAuthenticationInterceptor; -import org.springframework.web.client.DefaultResponseErrorHandler; -import org.springframework.web.client.RestClient; -import org.springframework.web.client.RestTemplate; -import org.springframework.web.util.UriComponentsBuilder; - -import static org.springframework.cloud.netflix.eureka.http.EurekaHttpClientUtils.context; -import static org.springframework.cloud.netflix.eureka.http.EurekaHttpClientUtils.extractUserInfo; -import static org.springframework.cloud.netflix.eureka.http.EurekaHttpClientUtils.mappingJacksonHttpMessageConverter; - -/** - * Provides the custom {@link RestTemplate} required by the - * {@link RestTemplateEurekaHttpClient}. Relies on Jackson for serialization and - * deserialization. - * - * @author Daniel Lavoie - * @author Armin Krezovic - * @author Wonchul Heo - * @author Olga Maciaszek-Sharma - * @deprecated {@link RestTemplate}-based implementation to be removed in favour of - * {@link RestClient}-based implementation. - */ -@Deprecated(forRemoval = true) -public class RestTemplateTransportClientFactory implements TransportClientFactory { - - private final Optional sslContext; - - private final Optional hostnameVerifier; - - private final EurekaClientHttpRequestFactorySupplier eurekaClientHttpRequestFactorySupplier; - - private final Supplier restTemplateBuilderSupplier; - - public RestTemplateTransportClientFactory(Optional sslContext, - Optional hostnameVerifier, - EurekaClientHttpRequestFactorySupplier eurekaClientHttpRequestFactorySupplier, - Supplier restTemplateBuilderSupplier) { - this.sslContext = sslContext; - this.hostnameVerifier = hostnameVerifier; - this.eurekaClientHttpRequestFactorySupplier = eurekaClientHttpRequestFactorySupplier; - this.restTemplateBuilderSupplier = restTemplateBuilderSupplier; - } - - public RestTemplateTransportClientFactory(TlsProperties tlsProperties, - EurekaClientHttpRequestFactorySupplier eurekaClientHttpRequestFactorySupplier, - Supplier restTemplateBuilderSupplier) { - this(context(tlsProperties), Optional.empty(), eurekaClientHttpRequestFactorySupplier, - restTemplateBuilderSupplier); - } - - public RestTemplateTransportClientFactory(TlsProperties tlsProperties, - EurekaClientHttpRequestFactorySupplier eurekaClientHttpRequestFactorySupplier) { - this(tlsProperties, eurekaClientHttpRequestFactorySupplier, RestTemplateBuilder::new); - } - - public RestTemplateTransportClientFactory(Optional sslContext, - Optional hostnameVerifier, - EurekaClientHttpRequestFactorySupplier eurekaClientHttpRequestFactorySupplier) { - - this(sslContext, hostnameVerifier, eurekaClientHttpRequestFactorySupplier, RestTemplateBuilder::new); - } - - // Visible for testing - /** - * @deprecated pass the default values while initialising object in test classes. - */ - @Deprecated(forRemoval = true) - public RestTemplateTransportClientFactory() { - this(Optional.empty(), Optional.empty(), new DefaultEurekaClientHttpRequestFactorySupplier()); - } - - @Override - public EurekaHttpClient newClient(EurekaEndpoint serviceUrl) { - return new RestTemplateEurekaHttpClient(restTemplate(serviceUrl.getServiceUrl()), - stripUserInfo(serviceUrl.getServiceUrl())); - } - - // apache http client 5.2 fails with non-null userinfo - // basic auth added in restTemplate() below - private String stripUserInfo(String serviceUrl) { - return UriComponentsBuilder.fromUriString(serviceUrl).userInfo(null).toUriString(); - } - - private RestTemplate restTemplate(String serviceUrl) { - ClientHttpRequestFactory requestFactory = this.eurekaClientHttpRequestFactorySupplier - .get(this.sslContext.orElse(null), this.hostnameVerifier.orElse(null)); - - RestTemplate restTemplate; - - if (restTemplateBuilderSupplier != null && restTemplateBuilderSupplier.get() != null) { - // Avoid using RestTemplateBuilder.requestFactory(() -> requestFactory) - // when we have a concrete type, the reflective builder can throw errors if - // there is custom configuration (ie Redirects.DONT_FOLLOW) gh-4423 - restTemplate = restTemplateBuilderSupplier.get().build(); - restTemplate.setRequestFactory(requestFactory); - } - else { - restTemplate = new RestTemplate(requestFactory); - } - - final EurekaHttpClientUtils.UserInfo userInfo = extractUserInfo(serviceUrl); - if (userInfo != null) { - restTemplate.getInterceptors() - .add(new BasicAuthenticationInterceptor(userInfo.username(), userInfo.password())); - } - - restTemplate.getMessageConverters().add(0, mappingJacksonHttpMessageConverter()); - restTemplate.setErrorHandler(new ErrorHandler()); - - restTemplate.getInterceptors().add((request, body, execution) -> { - ClientHttpResponse response = execution.execute(request, body); - if (!response.getStatusCode().equals(HttpStatus.NOT_FOUND)) { - return response; - } - return new NotFoundHttpResponse(response); - }); - - return restTemplate; - } - - @Override - public void shutdown() { - } - - class ErrorHandler extends DefaultResponseErrorHandler { - - @Override - protected boolean hasError(HttpStatusCode statusCode) { - /** - * When the Eureka server restarts and a client tries to send a heartbeat the - * server will respond with a 404. By default, RestTemplate will throw an - * exception in this case. What we want is to return the 404 to the upstream - * code, so it will send another registration request to the server. - */ - if (statusCode.is4xxClientError()) { - return false; - } - return super.hasError(statusCode); - } - - } - -} diff --git a/spring-cloud-netflix-eureka-client/src/main/resources/META-INF/additional-spring-configuration-metadata.json b/spring-cloud-netflix-eureka-client/src/main/resources/META-INF/additional-spring-configuration-metadata.json index a04fc748d..ee8cfa643 100644 --- a/spring-cloud-netflix-eureka-client/src/main/resources/META-INF/additional-spring-configuration-metadata.json +++ b/spring-cloud-netflix-eureka-client/src/main/resources/META-INF/additional-spring-configuration-metadata.json @@ -12,12 +12,6 @@ "description": "Determines whether the EurekaClient instance can be refreshed or not(If disabled none of the Eureka client properties will be refreshable).", "type": "java.lang.Boolean" }, - { - "defaultValue": false, - "name": "eureka.client.restclient.enabled", - "description": "Enables the use of RestClient for Eureka HTTP Client.", - "type": "java.lang.Boolean" - }, { "defaultValue": false, "name": "eureka.client.webclient.enabled", diff --git a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationClientTests.java b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationClientTests.java index 0a908eac0..1d42d0984 100644 --- a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationClientTests.java +++ b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationClientTests.java @@ -24,7 +24,6 @@ import org.springframework.beans.factory.NoSuchBeanDefinitionException; import org.springframework.boot.autoconfigure.AutoConfigurations; import org.springframework.boot.test.context.runner.ApplicationContextRunner; import org.springframework.cloud.netflix.eureka.http.RestClientEurekaHttpClient; -import org.springframework.cloud.netflix.eureka.http.RestTemplateEurekaHttpClient; import org.springframework.cloud.netflix.eureka.http.WebClientEurekaHttpClient; import org.springframework.cloud.test.ClassPathExclusions; @@ -36,27 +35,12 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; */ class EurekaConfigServerBootstrapConfigurationClientTests { - @Test - void properBeansCreatedWhenRestTemplateEnabled() { - new ApplicationContextRunner() - .withConfiguration(AutoConfigurations.of(EurekaConfigServerBootstrapConfiguration.class)) - .withPropertyValues("spring.cloud.config.discovery.enabled=true") - .withPropertyValues("eureka.client.enabled=true") - .withPropertyValues("eureka.client.restclient.enabled=false") - .run(context -> { - assertThat(context).hasSingleBean(RestTemplateEurekaHttpClient.class); - assertThat(context).doesNotHaveBean(RestClientEurekaHttpClient.class); - assertThat(context).doesNotHaveBean(WebClientEurekaHttpClient.class); - }); - } - @Test void properBeansCreatedWhenRestClientEnabled() { new ApplicationContextRunner() .withConfiguration(AutoConfigurations.of(EurekaConfigServerBootstrapConfiguration.class)) .withPropertyValues("spring.cloud.config.discovery.enabled=true") .withPropertyValues("eureka.client.enabled=true") - .withPropertyValues("eureka.client.restclient.enabled=true") .run(context -> { assertThat(context).hasSingleBean(RestClientEurekaHttpClient.class); assertThat(context).doesNotHaveBean(WebClientEurekaHttpClient.class); @@ -80,21 +64,7 @@ class EurekaConfigServerBootstrapConfigurationClientTests { @Nested @ClassPathExclusions({ "spring-webflux-*" }) - static class NoWebFlux { - - @Test - void properBeansCreatedWhenRestTemplateEnabled() { - new ApplicationContextRunner() - .withConfiguration(AutoConfigurations.of(EurekaConfigServerBootstrapConfiguration.class)) - .withPropertyValues("spring.cloud.config.discovery.enabled=true") - .withPropertyValues("eureka.client.enabled=true") - .withPropertyValues("eureka.client.restclient.enabled=false") - .run(context -> { - assertThat(context).hasSingleBean(RestTemplateEurekaHttpClient.class); - assertThat(context).doesNotHaveBean(RestClientEurekaHttpClient.class); - assertThat(context).doesNotHaveBean(WebClientEurekaHttpClient.class); - }); - } + class NoWebFlux { @Test void properBeansCreatedWhenRestClientEnabled() { @@ -102,7 +72,6 @@ class EurekaConfigServerBootstrapConfigurationClientTests { .withConfiguration(AutoConfigurations.of(EurekaConfigServerBootstrapConfiguration.class)) .withPropertyValues("spring.cloud.config.discovery.enabled=true") .withPropertyValues("eureka.client.enabled=true") - .withPropertyValues("eureka.client.restclient.enabled=true") .run(context -> { assertThat(context).hasSingleBean(RestClientEurekaHttpClient.class); assertThat(context).doesNotHaveBean(WebClientEurekaHttpClient.class); diff --git a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationRestClientIntegrationTests.java b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationRestClientIntegrationTests.java index 7f71bb26e..88b62a551 100644 --- a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationRestClientIntegrationTests.java +++ b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationRestClientIntegrationTests.java @@ -40,10 +40,8 @@ import static org.springframework.boot.test.context.SpringBootTest.WebEnvironmen /** * @author Wonchul Heo */ -@SpringBootTest( - properties = { "spring.cloud.config.discovery.enabled=true", "eureka.client.enabled=true", - "spring.config.use-legacy-processing=true", "eureka.client.restclient.enabled=true" }, - webEnvironment = RANDOM_PORT) +@SpringBootTest(properties = { "spring.cloud.config.discovery.enabled=true", "eureka.client.enabled=true", + "spring.config.use-legacy-processing=true" }, webEnvironment = RANDOM_PORT) class EurekaConfigServerBootstrapConfigurationRestClientIntegrationTests { @LocalServerPort diff --git a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationRestClientTests.java b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationRestClientTests.java index 70b58d23e..444a7ec47 100644 --- a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationRestClientTests.java +++ b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationRestClientTests.java @@ -23,7 +23,6 @@ import org.springframework.boot.test.context.runner.ApplicationContextRunner; import org.springframework.cloud.config.client.ConfigServerInstanceProvider; import org.springframework.cloud.netflix.eureka.EurekaClientConfigBean; import org.springframework.cloud.netflix.eureka.http.RestClientEurekaHttpClient; -import org.springframework.cloud.netflix.eureka.http.RestTemplateEurekaHttpClient; import static org.assertj.core.api.Assertions.assertThat; @@ -33,11 +32,10 @@ import static org.assertj.core.api.Assertions.assertThat; class EurekaConfigServerBootstrapConfigurationRestClientTests { @Test - void properBeansCreatedWhenEnabled() { + void properBeansCreated() { new ApplicationContextRunner() .withConfiguration(AutoConfigurations.of(EurekaConfigServerBootstrapConfiguration.class)) - .withPropertyValues("spring.cloud.config.discovery.enabled=true", "eureka.client.enabled=true", - "eureka.client.restclient.enabled=true") + .withPropertyValues("spring.cloud.config.discovery.enabled=true", "eureka.client.enabled=true") .run(context -> { assertThat(context).hasSingleBean(EurekaClientConfigBean.class); assertThat(context).hasSingleBean(RestClientEurekaHttpClient.class); @@ -45,18 +43,4 @@ class EurekaConfigServerBootstrapConfigurationRestClientTests { }); } - @Test - void properBeansCreatedWhenEnabledRestClientDisabled() { - new ApplicationContextRunner() - .withConfiguration(AutoConfigurations.of(EurekaConfigServerBootstrapConfiguration.class)) - .withPropertyValues("spring.cloud.config.discovery.enabled=true", "eureka.client.enabled=true", - "eureka.client.restclient.enabled=false") - .run(context -> { - assertThat(context).hasSingleBean(EurekaClientConfigBean.class); - assertThat(context).doesNotHaveBean(RestClientEurekaHttpClient.class); - assertThat(context).hasSingleBean(RestTemplateEurekaHttpClient.class); - assertThat(context).hasSingleBean(ConfigServerInstanceProvider.Function.class); - }); - } - } diff --git a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationTests.java b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationTests.java index 940600d81..227828b6a 100644 --- a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationTests.java +++ b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationTests.java @@ -39,7 +39,7 @@ import org.springframework.boot.test.system.OutputCaptureRule; import org.springframework.cloud.config.client.ConfigServerInstanceProvider; import org.springframework.cloud.netflix.eureka.CloudEurekaClient; import org.springframework.cloud.netflix.eureka.EurekaClientConfigBean; -import org.springframework.cloud.netflix.eureka.http.RestTemplateEurekaHttpClient; +import org.springframework.cloud.netflix.eureka.http.RestClientEurekaHttpClient; import org.springframework.cloud.test.ClassPathExclusions; import org.springframework.cloud.test.ModifiedClassPathRunner; import org.springframework.context.annotation.Bean; @@ -206,7 +206,7 @@ public class EurekaConfigServerBootstrapConfigurationTests { private void assertEurekaBeansPresent(AssertableApplicationContext context) { assertThat(context).hasSingleBean(EurekaClientConfigBean.class); - assertThat(context).hasSingleBean(RestTemplateEurekaHttpClient.class); + assertThat(context).hasSingleBean(RestClientEurekaHttpClient.class); assertThat(context).hasSingleBean(ConfigServerInstanceProvider.Function.class); } diff --git a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationWebClientTests.java b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationWebClientTests.java index 648558d9a..9185381bb 100644 --- a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationWebClientTests.java +++ b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaConfigServerBootstrapConfigurationWebClientTests.java @@ -22,7 +22,7 @@ import org.springframework.boot.autoconfigure.AutoConfigurations; import org.springframework.boot.test.context.runner.ApplicationContextRunner; import org.springframework.cloud.config.client.ConfigServerInstanceProvider; import org.springframework.cloud.netflix.eureka.EurekaClientConfigBean; -import org.springframework.cloud.netflix.eureka.http.RestTemplateEurekaHttpClient; +import org.springframework.cloud.netflix.eureka.http.RestClientEurekaHttpClient; import org.springframework.cloud.netflix.eureka.http.WebClientEurekaHttpClient; import static org.assertj.core.api.Assertions.assertThat; @@ -54,7 +54,7 @@ class EurekaConfigServerBootstrapConfigurationWebClientTests { .run(context -> { assertThat(context).hasSingleBean(EurekaClientConfigBean.class); assertThat(context).doesNotHaveBean(WebClientEurekaHttpClient.class); - assertThat(context).hasSingleBean(RestTemplateEurekaHttpClient.class); + assertThat(context).hasSingleBean(RestClientEurekaHttpClient.class); assertThat(context).hasSingleBean(ConfigServerInstanceProvider.Function.class); }); } diff --git a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaHttpClientsOptionalArgsConfigurationTests.java b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaHttpClientsOptionalArgsConfigurationTests.java index 1a5c5d298..c48d75359 100644 --- a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaHttpClientsOptionalArgsConfigurationTests.java +++ b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/EurekaHttpClientsOptionalArgsConfigurationTests.java @@ -23,7 +23,6 @@ import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.context.SpringBootTest.WebEnvironment; import org.springframework.boot.test.context.runner.WebApplicationContextRunner; import org.springframework.cloud.netflix.eureka.http.RestClientDiscoveryClientOptionalArgs; -import org.springframework.cloud.netflix.eureka.http.RestTemplateDiscoveryClientOptionalArgs; import org.springframework.cloud.netflix.eureka.http.WebClientDiscoveryClientOptionalArgs; import org.springframework.cloud.netflix.eureka.sample.EurekaSampleApplication; import org.springframework.cloud.test.ClassPathExclusions; @@ -41,25 +40,12 @@ import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; public class EurekaHttpClientsOptionalArgsConfigurationTests { @Test - public void contextLoadsWithRestTemplateWhenWebClientDisabled() { + public void contextLoadsWithRestClientWhenWebClientDisabled() { new WebApplicationContextRunner().withUserConfiguration(EurekaSampleApplication.class) .withPropertyValues("eureka.client.webclient.enabled=false") - .withPropertyValues("eureka.client.restclient.enabled=false") .run(context -> { - assertThat(context).hasSingleBean(RestTemplateDiscoveryClientOptionalArgs.class); + assertThat(context).hasSingleBean(RestClientDiscoveryClientOptionalArgs.class); assertThat(context).doesNotHaveBean(WebClientDiscoveryClientOptionalArgs.class); - assertThat(context).doesNotHaveBean(RestClientDiscoveryClientOptionalArgs.class); - }); - } - - @Test - public void contextLoadsWithRestTemplateWhenRestClientDisabled() { - new WebApplicationContextRunner().withUserConfiguration(EurekaSampleApplication.class) - .withPropertyValues("eureka.client.restclient.enabled=false") - .run(context -> { - assertThat(context).hasSingleBean(RestTemplateDiscoveryClientOptionalArgs.class); - assertThat(context).doesNotHaveBean(WebClientDiscoveryClientOptionalArgs.class); - assertThat(context).doesNotHaveBean(RestClientDiscoveryClientOptionalArgs.class); }); } @@ -68,31 +54,8 @@ public class EurekaHttpClientsOptionalArgsConfigurationTests { new WebApplicationContextRunner().withUserConfiguration(EurekaSampleApplication.class) .withPropertyValues("eureka.client.webclient.enabled=true") .run(context -> { - assertThat(context).doesNotHaveBean(RestTemplateDiscoveryClientOptionalArgs.class); + assertThat(context).doesNotHaveBean(RestClientDiscoveryClientOptionalArgs.class); assertThat(context).hasSingleBean(WebClientDiscoveryClientOptionalArgs.class); - assertThat(context).doesNotHaveBean(RestClientDiscoveryClientOptionalArgs.class); - }); - } - - @Test - public void contextLoadsWithRestClient() { - new WebApplicationContextRunner().withUserConfiguration(EurekaSampleApplication.class) - .withPropertyValues("eureka.client.restclient.enabled=true") - .run(context -> { - assertThat(context).doesNotHaveBean(RestTemplateDiscoveryClientOptionalArgs.class); - assertThat(context).doesNotHaveBean(WebClientDiscoveryClientOptionalArgs.class); - assertThat(context).hasSingleBean(RestClientDiscoveryClientOptionalArgs.class); - }); - } - - @Test - public void contextLoadsWithRestTemplateAsDefault() { - new WebApplicationContextRunner().withUserConfiguration(EurekaSampleApplication.class) - .withPropertyValues("eureka.client.restclient.enabled=false") - .run(context -> { - assertThat(context).hasSingleBean(RestTemplateDiscoveryClientOptionalArgs.class); - assertThat(context).doesNotHaveBean(WebClientDiscoveryClientOptionalArgs.class); - assertThat(context).doesNotHaveBean(RestClientDiscoveryClientOptionalArgs.class); }); } diff --git a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/JerseyClientOptionalArgsConfigurationTests.java b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/JerseyClientOptionalArgsConfigurationTests.java index ced63bc13..6398a7bdd 100644 --- a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/JerseyClientOptionalArgsConfigurationTests.java +++ b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/config/JerseyClientOptionalArgsConfigurationTests.java @@ -21,7 +21,7 @@ import org.junit.jupiter.api.Test; import org.springframework.boot.autoconfigure.AutoConfigurations; import org.springframework.boot.test.context.runner.ApplicationContextRunner; -import org.springframework.cloud.netflix.eureka.http.RestTemplateDiscoveryClientOptionalArgs; +import org.springframework.cloud.netflix.eureka.http.RestClientDiscoveryClientOptionalArgs; import static org.assertj.core.api.Assertions.assertThat; @@ -30,12 +30,11 @@ import static org.assertj.core.api.Assertions.assertThat; * * @author Olga Maciaszek-Sharma */ -@SuppressWarnings("deprecation") public class JerseyClientOptionalArgsConfigurationTests { @SuppressWarnings("OptionalGetWithoutIsPresent") @Test - void shouldCreateRestTemplateDiscoveryClientOptionalArgsWhenJerseyClientDisabled() { + void shouldCreateRestClientDiscoveryClientOptionalArgsWhenJerseyClientDisabled() { new ApplicationContextRunner() .withConfiguration(AutoConfigurations.of(DiscoveryClientOptionalArgsConfiguration.class)) .withPropertyValues("eureka.client.jersey.enabled=false") @@ -45,8 +44,8 @@ public class JerseyClientOptionalArgsConfigurationTests { .values() .stream() .findFirst() - .get()).isInstanceOf(RestTemplateDiscoveryClientOptionalArgs.class); - assertThat(context).hasSingleBean(RestTemplateDiscoveryClientOptionalArgs.class); + .get()).isInstanceOf(RestClientDiscoveryClientOptionalArgs.class); + assertThat(context).hasSingleBean(RestClientDiscoveryClientOptionalArgs.class); }); } diff --git a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestClientEurekaHttpClientTests.java b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestClientEurekaHttpClientTests.java index f58ef83ea..dbb8031d1 100644 --- a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestClientEurekaHttpClientTests.java +++ b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestClientEurekaHttpClientTests.java @@ -32,7 +32,7 @@ import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.context.SpringBootTest.WebEnvironment; import org.springframework.cloud.commons.util.InetUtils; import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; -import org.springframework.cloud.netflix.eureka.RestClientTimeoutProperties; +import org.springframework.cloud.netflix.eureka.TimeoutProperties; import org.springframework.test.annotation.DirtiesContext; import org.springframework.web.client.RestClient; @@ -88,7 +88,7 @@ class RestClientEurekaHttpClientTests extends AbstractEurekaHttpClientTests { private EurekaHttpClient buildEurekaHttpClient( Set customizers) { return new RestClientTransportClientFactory(Optional.empty(), Optional.empty(), - new DefaultEurekaClientHttpRequestFactorySupplier(new RestClientTimeoutProperties(), customizers), + new DefaultEurekaClientHttpRequestFactorySupplier(new TimeoutProperties(), customizers), RestClient::builder) .newClient(new DefaultEndpoint(serviceUrl)); } diff --git a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestClientTransportClientFactoryTests.java b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestClientTransportClientFactoryTests.java index 9103663b1..48c04da3a 100644 --- a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestClientTransportClientFactoryTests.java +++ b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestClientTransportClientFactoryTests.java @@ -25,7 +25,7 @@ import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import org.springframework.cloud.netflix.eureka.RestClientTimeoutProperties; +import org.springframework.cloud.netflix.eureka.TimeoutProperties; import org.springframework.web.client.RestClient; import static org.assertj.core.api.Assertions.assertThat; @@ -43,8 +43,7 @@ class RestClientTransportClientFactoryTests { @BeforeEach void setup() { transportClientFactory = new RestClientTransportClientFactory(Optional.empty(), Optional.empty(), - new DefaultEurekaClientHttpRequestFactorySupplier(new RestClientTimeoutProperties(), - Collections.emptySet()), + new DefaultEurekaClientHttpRequestFactorySupplier(new TimeoutProperties(), Collections.emptySet()), RestClient::builder); } diff --git a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestTemplateEurekaHttpClientTests.java b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestTemplateEurekaHttpClientTests.java deleted file mode 100644 index 5080a75c1..000000000 --- a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestTemplateEurekaHttpClientTests.java +++ /dev/null @@ -1,85 +0,0 @@ -/* - * Copyright 2017-present 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 - * - * https://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.http; - -import java.util.List; - -import com.netflix.appinfo.providers.EurekaConfigBasedInstanceInfoProvider; -import com.netflix.discovery.shared.resolver.DefaultEndpoint; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.beans.factory.annotation.Value; -import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.boot.test.context.SpringBootTest.WebEnvironment; -import org.springframework.cloud.commons.util.InetUtils; -import org.springframework.cloud.netflix.eureka.EurekaInstanceConfigBean; -import org.springframework.http.client.ClientHttpRequestInterceptor; -import org.springframework.http.client.support.BasicAuthenticationInterceptor; -import org.springframework.test.annotation.DirtiesContext; -import org.springframework.web.client.RestTemplate; - -import static org.assertj.core.api.Assertions.assertThat; - -/** - * @author Daniel Lavoie - */ -@SpringBootTest(classes = EurekaServerMockApplication.class, - properties = { "debug=true", "security.basic.enabled=true", "eureka.client.fetch-registry=false", - "eureka.client.register-with-eureka=false", "logging.level.org.springframework=INFO" }, - webEnvironment = WebEnvironment.RANDOM_PORT) -@DirtiesContext -class RestTemplateEurekaHttpClientTests extends AbstractEurekaHttpClientTests { - - @Autowired - private InetUtils inetUtils; - - @Value("http://${security.user.name}:${security.user.password}@localhost:${local.server.port}/eureka") - private String serviceUrl; - - @BeforeEach - void setup() { - eurekaHttpClient = new RestTemplateTransportClientFactory().newClient(new DefaultEndpoint(serviceUrl)); - - EurekaInstanceConfigBean config = new EurekaInstanceConfigBean(inetUtils); - - String appname = "customapp"; - config.setIpAddress("127.0.0.1"); - config.setHostname("localhost"); - config.setAppname(appname); - config.setVirtualHostName(appname); - config.setSecureVirtualHostName(appname); - config.setNonSecurePort(4444); - config.setSecurePort(8443); - config.setInstanceId("127.0.0.1:customapp:4444"); - - info = new EurekaConfigBasedInstanceInfoProvider(config).get(); - } - - @Test - void basicAuth() { - assertThat(eurekaHttpClient).isInstanceOf(RestTemplateEurekaHttpClient.class); - RestTemplateEurekaHttpClient restTemplateEurekaHttpClient = (RestTemplateEurekaHttpClient) eurekaHttpClient; - RestTemplate restTemplate = restTemplateEurekaHttpClient.getRestTemplate(); - List interceptors = restTemplate.getInterceptors(); - boolean hasBasicAuth = interceptors.stream() - .anyMatch(interceptor -> interceptor instanceof BasicAuthenticationInterceptor); - assertThat(hasBasicAuth).as("Basic Auth not configured").isTrue(); - } - -} diff --git a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestTemplateTransportClientFactoryTests.java b/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestTemplateTransportClientFactoryTests.java deleted file mode 100644 index 6176a9d50..000000000 --- a/spring-cloud-netflix-eureka-client/src/test/java/org/springframework/cloud/netflix/eureka/http/RestTemplateTransportClientFactoryTests.java +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Copyright 2017-present 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 - * - * https://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.http; - -import java.util.Optional; - -import com.netflix.discovery.shared.resolver.DefaultEndpoint; -import com.netflix.discovery.shared.transport.EurekaHttpClient; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -import org.springframework.boot.http.client.ClientHttpRequestFactorySettings; -import org.springframework.boot.http.client.HttpRedirects; -import org.springframework.boot.restclient.RestTemplateBuilder; -import org.springframework.http.client.ClientHttpRequestFactory; -import org.springframework.http.client.HttpComponentsClientHttpRequestFactory; -import org.springframework.http.client.InterceptingClientHttpRequestFactory; -import org.springframework.web.client.RestTemplate; - -import static org.assertj.core.api.Assertions.assertThat; - -/** - * @author Daniel Lavoie - * @author Wonchul Heo - */ -class RestTemplateTransportClientFactoryTests { - - private RestTemplateTransportClientFactory transportClientFactory; - - @BeforeEach - void setup() { - transportClientFactory = new RestTemplateTransportClientFactory(); - } - - @Test - void withoutUserInfo() { - EurekaHttpClient eurekaHttpClient = transportClientFactory - .newClient(new DefaultEndpoint("http://localhost:8761")); - assertThat(eurekaHttpClient).isInstanceOf(RestTemplateEurekaHttpClient.class); - } - - @Test - void invalidUserInfo() { - EurekaHttpClient eurekaHttpClient = transportClientFactory - .newClient(new DefaultEndpoint("http://test@localhost:8761")); - assertThat(eurekaHttpClient).isInstanceOf(RestTemplateEurekaHttpClient.class); - } - - @Test - void userInfo() { - EurekaHttpClient eurekaHttpClient = transportClientFactory - .newClient(new DefaultEndpoint("http://test:test@localhost:8761")); - assertThat(eurekaHttpClient).isInstanceOf(RestTemplateEurekaHttpClient.class); - } - - @Test - void testRequestFactorySetWithRestTemplateBuilderSupplier() { - // Gateway Server WebMVC sets Redirects.DONT_FOLLOW, gh-4423 - RestTemplateBuilder builder = new RestTemplateBuilder() - .requestFactorySettings(new ClientHttpRequestFactorySettings(HttpRedirects.DONT_FOLLOW, null, null, null)); - transportClientFactory = new RestTemplateTransportClientFactory(Optional.empty(), Optional.empty(), - new DefaultEurekaClientHttpRequestFactorySupplier(), () -> builder); - EurekaHttpClient eurekaHttpClient = transportClientFactory - .newClient(new DefaultEndpoint("http://localhost:8761")); - RestTemplateEurekaHttpClient restTemplateEurekaHttpClient = (RestTemplateEurekaHttpClient) eurekaHttpClient; - RestTemplate restTemplate = restTemplateEurekaHttpClient.getRestTemplate(); - ClientHttpRequestFactory requestFactory = restTemplate.getRequestFactory(); - if (requestFactory instanceof InterceptingClientHttpRequestFactory interceptingClientHttpRequestFactory) { - requestFactory = interceptingClientHttpRequestFactory.getDelegate(); - } - assertThat(requestFactory).isInstanceOf(HttpComponentsClientHttpRequestFactory.class); - } - - @AfterEach - void shutdown() { - transportClientFactory.shutdown(); - } - -}