Skip to content

S
spring-boot
Commit 33e414fc authored by Stephane Nicoll's avatar Stephane Nicoll
Browse files
Options

Merge pull request #19699 from scottfrederick 

* pr/19699:
  Polish "Remove deprecated Joda-Time support"
  Remove deprecated Joda-Time support
  Remove deprecated 2.2 code
  Remove deprecated HealthIndicator and HealthAggregator 2.2 code
  Remove deprecated Actuator metrics 2.2 code
  Polish "Remove deprecated logging properties"
  Remove deprecated logging properties

Closes gh-19699
parents 421c464d 7270ca5c
Expand all Show whitespace changes
Inline Side-by-side
Showing with 88 additions and 5509 deletions
spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/endpoint/condition/ConditionalOnEnabledEndpoint.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.endpoint.condition;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
import org.springframework.boot.actuate.endpoint.annotation.EndpointExtension;
import org.springframework.context.annotation.Conditional;
import org.springframework.core.env.Environment;
/**
* {@link Conditional @Conditional} that checks whether an endpoint is enabled or not.
* Matches according to the endpoints specific {@link Environment} property, falling back
* to {@code management.endpoints.enabled-by-default} or failing that
* {@link Endpoint#enableByDefault()}.
* <p>
* When placed on a {@code @Bean} method, the endpoint defaults to the return type of the
* factory method:
*
* <pre class="code">
* &#064;Configuration
* public class MyConfiguration {
*
* &#064;ConditionalOnEnableEndpoint
* &#064;Bean
* public MyEndpoint myEndpoint() {
* ...
* }
*
* }</pre>
* <p>
* It is also possible to use the same mechanism for extensions:
*
* <pre class="code">
* &#064;Configuration
* public class MyConfiguration {
*
* &#064;ConditionalOnEnableEndpoint
* &#064;Bean
* public MyEndpointWebExtension myEndpointWebExtension() {
* ...
* }
*
* }</pre>
* <p>
* In the sample above, {@code MyEndpointWebExtension} will be created if the endpoint is
* enabled as defined by the rules above. {@code MyEndpointWebExtension} must be a regular
* extension that refers to an endpoint, something like:
*
* <pre class="code">
* &#064;EndpointWebExtension(endpoint = MyEndpoint.class)
* public class MyEndpointWebExtension {
*
* }</pre>
* <p>
* Alternatively, the target endpoint can be manually specified for components that should
* only be created when a given endpoint is enabled:
*
* <pre class="code">
* &#064;Configuration
* public class MyConfiguration {
*
* &#064;ConditionalOnEnableEndpoint(endpoint = MyEndpoint.class)
* &#064;Bean
* public MyComponent myComponent() {
* ...
* }
*
* }</pre>
*
* @author Stephane Nicoll
* @since 2.0.0
* @see Endpoint
* @deprecated as of 2.2.0 in favor of
* {@link ConditionalOnAvailableEndpoint @ConditionalOnAvailableEndpoint}
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD, ElementType.TYPE })
@Documented
@Conditional(OnEnabledEndpointCondition.class)
@Deprecated
public @interface ConditionalOnEnabledEndpoint {
/**
* The endpoint type that should be checked. Inferred when the return type of the
* {@code @Bean} method is either an {@link Endpoint @Endpoint} or an
* {@link EndpointExtension @EndpointExtension}.
* @return the endpoint type to check
* @since 2.0.6
*/
Class<?> endpoint() default Void.class;
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/endpoint/condition/OnEnabledEndpointCondition.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.endpoint.condition;
import org.springframework.boot.autoconfigure.condition.ConditionOutcome;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
/**
* A condition that checks if an endpoint is enabled.
*
* @author Stephane Nicoll
* @author Andy Wilkinson
* @author Phillip Webb
* @see ConditionalOnEnabledEndpoint
* @deprecated as of 2.2.0 in favor of {@link OnAvailableEndpointCondition}
*/
@Deprecated
class OnEnabledEndpointCondition extends AbstractEndpointCondition {
@Override
public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
return getEnablementOutcome(context, metadata, ConditionalOnEnabledEndpoint.class);
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/health/CompositeHealthIndicatorConfiguration.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.health;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.actuate.health.CompositeHealthIndicator;
import org.springframework.boot.actuate.health.DefaultHealthIndicatorRegistry;
import org.springframework.boot.actuate.health.HealthAggregator;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.boot.actuate.health.HealthIndicatorRegistry;
import org.springframework.core.ResolvableType;
/**
* Base class for configurations that can combine source beans using a
* {@link CompositeHealthIndicator}.
*
* @param <H> the health indicator type
* @param <S> the bean source type
* @author Stephane Nicoll
* @since 2.0.0
* @deprecated since 2.2.0 in favor of {@link CompositeHealthContributorConfiguration}
*/
@Deprecated
public abstract class CompositeHealthIndicatorConfiguration<H extends HealthIndicator, S> {
@Autowired
private HealthAggregator healthAggregator;
protected HealthIndicator createHealthIndicator(Map<String, S> beans) {
if (beans.size() == 1) {
return createHealthIndicator(beans.values().iterator().next());
}
HealthIndicatorRegistry registry = new DefaultHealthIndicatorRegistry();
beans.forEach((name, source) -> registry.register(name, createHealthIndicator(source)));
return new CompositeHealthIndicator(this.healthAggregator, registry);
}
@SuppressWarnings("unchecked")
protected H createHealthIndicator(S source) {
Class<?>[] generics = ResolvableType.forClass(CompositeHealthIndicatorConfiguration.class, getClass())
.resolveGenerics();
Class<H> indicatorClass = (Class<H>) generics[0];
Class<S> sourceClass = (Class<S>) generics[1];
try {
return indicatorClass.getConstructor(sourceClass).newInstance(source);
}
catch (Exception ex) {
throw new IllegalStateException(
"Unable to create indicator " + indicatorClass + " for source " + sourceClass, ex);
}
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/health/CompositeReactiveHealthIndicatorConfiguration.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.health;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.actuate.health.CompositeReactiveHealthIndicator;
import org.springframework.boot.actuate.health.DefaultReactiveHealthIndicatorRegistry;
import org.springframework.boot.actuate.health.HealthAggregator;
import org.springframework.boot.actuate.health.ReactiveHealthIndicator;
import org.springframework.boot.actuate.health.ReactiveHealthIndicatorRegistry;
import org.springframework.core.ResolvableType;
/**
* Reactive variant of {@link CompositeHealthIndicatorConfiguration}.
*
* @param <H> the health indicator type
* @param <S> the bean source type
* @author Stephane Nicoll
* @since 2.0.0
* @deprecated since 2.2.0 in favor of
* {@link CompositeReactiveHealthContributorConfiguration}
*/
@Deprecated
public abstract class CompositeReactiveHealthIndicatorConfiguration<H extends ReactiveHealthIndicator, S> {
@Autowired
private HealthAggregator healthAggregator;
protected ReactiveHealthIndicator createHealthIndicator(Map<String, S> beans) {
if (beans.size() == 1) {
return createHealthIndicator(beans.values().iterator().next());
}
ReactiveHealthIndicatorRegistry registry = new DefaultReactiveHealthIndicatorRegistry();
beans.forEach((name, source) -> registry.register(name, createHealthIndicator(source)));
return new CompositeReactiveHealthIndicator(this.healthAggregator, registry);
}
@SuppressWarnings("unchecked")
protected H createHealthIndicator(S source) {
Class<?>[] generics = ResolvableType.forClass(CompositeReactiveHealthIndicatorConfiguration.class, getClass())
.resolveGenerics();
Class<H> indicatorClass = (Class<H>) generics[0];
Class<S> sourceClass = (Class<S>) generics[1];
try {
return indicatorClass.getConstructor(sourceClass).newInstance(source);
}
catch (Exception ex) {
throw new IllegalStateException(
"Unable to create indicator " + indicatorClass + " for source " + sourceClass, ex);
}
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/health/HealthAggregatorStatusAggregatorAdapter.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.health;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthAggregator;
import org.springframework.boot.actuate.health.Status;
import org.springframework.boot.actuate.health.StatusAggregator;
/**
* Adapter class to convert a legacy {@link HealthAggregator} to a
* {@link StatusAggregator}.
*
* @author Phillip Webb
*/
@SuppressWarnings("deprecation")
class HealthAggregatorStatusAggregatorAdapter implements StatusAggregator {
private HealthAggregator healthAggregator;
HealthAggregatorStatusAggregatorAdapter(HealthAggregator healthAggregator) {
this.healthAggregator = healthAggregator;
}
@Override
public Status getAggregateStatus(Set<Status> statuses) {
int index = 0;
Map<String, Health> healths = new LinkedHashMap<>();
for (Status status : statuses) {
index++;
healths.put("health" + index, asHealth(status));
}
Health aggregate = this.healthAggregator.aggregate(healths);
return aggregate.getStatus();
}
private Health asHealth(Status status) {
return Health.status(status).build();
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/health/HealthContributorRegistryHealthIndicatorRegistryAdapter.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.health;
import java.util.LinkedHashMap;
import java.util.Map;
import org.springframework.boot.actuate.health.HealthContributor;
import org.springframework.boot.actuate.health.HealthContributorRegistry;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.boot.actuate.health.HealthIndicatorRegistry;
import org.springframework.boot.actuate.health.NamedContributor;
import org.springframework.util.Assert;
/**
* Adapter class to convert a {@link HealthContributorRegistry} to a legacy
* {@link HealthIndicatorRegistry}.
*
* @author Phillip Webb
*/
@SuppressWarnings("deprecation")
class HealthContributorRegistryHealthIndicatorRegistryAdapter implements HealthIndicatorRegistry {
private final HealthContributorRegistry contributorRegistry;
HealthContributorRegistryHealthIndicatorRegistryAdapter(HealthContributorRegistry contributorRegistry) {
Assert.notNull(contributorRegistry, "ContributorRegistry must not be null");
this.contributorRegistry = contributorRegistry;
}
@Override
public void register(String name, HealthIndicator healthIndicator) {
this.contributorRegistry.registerContributor(name, healthIndicator);
}
@Override
public HealthIndicator unregister(String name) {
HealthContributor contributor = this.contributorRegistry.unregisterContributor(name);
if (contributor instanceof HealthIndicator) {
return (HealthIndicator) contributor;
}
return null;
}
@Override
public HealthIndicator get(String name) {
HealthContributor contributor = this.contributorRegistry.getContributor(name);
if (contributor instanceof HealthIndicator) {
return (HealthIndicator) contributor;
}
return null;
}
@Override
public Map<String, HealthIndicator> getAll() {
Map<String, HealthIndicator> all = new LinkedHashMap<>();
for (NamedContributor<?> namedContributor : this.contributorRegistry) {
if (namedContributor.getContributor() instanceof HealthIndicator) {
all.put(namedContributor.getName(), (HealthIndicator) namedContributor.getContributor());
}
}
return all;
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/health/HealthEndpointAutoConfiguration.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -20,7 +20,6 @@ import org.springframework.boot.actuate.autoconfigure.endpoint.condition.Conditi
import org.springframework.boot.actuate.health.HealthEndpoint;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
......@@ -30,23 +29,14 @@ import org.springframework.context.annotation.Import;
* @author Andy Wilkinson
* @author Stephane Nicoll
* @author Phillip Webb
* @author Scott Frederick
* @since 2.0.0
*/
@Configuration(proxyBeanMethods = false)
@ConditionalOnAvailableEndpoint(endpoint = HealthEndpoint.class)
@EnableConfigurationProperties
@Import({ LegacyHealthEndpointAdaptersConfiguration.class, LegacyHealthEndpointCompatibilityConfiguration.class,
HealthEndpointConfiguration.class, ReactiveHealthEndpointConfiguration.class,
@EnableConfigurationProperties(HealthEndpointProperties.class)
@Import({ HealthEndpointConfiguration.class, ReactiveHealthEndpointConfiguration.class,
HealthEndpointWebExtensionConfiguration.class, HealthEndpointReactiveWebExtensionConfiguration.class })
public class HealthEndpointAutoConfiguration {
@Bean
@SuppressWarnings("deprecation")
HealthEndpointProperties healthEndpointProperties(HealthIndicatorProperties healthIndicatorProperties) {
HealthEndpointProperties healthEndpointProperties = new HealthEndpointProperties();
healthEndpointProperties.getStatus().getOrder().addAll(healthIndicatorProperties.getOrder());
healthEndpointProperties.getStatus().getHttpMapping().putAll(healthIndicatorProperties.getHttpMapping());
return healthEndpointProperties;
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/health/HealthIndicatorAutoConfiguration.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.health;
import org.springframework.boot.actuate.health.HealthContributor;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Configuration;
/**
* {@link EnableAutoConfiguration Auto-configuration} for {@link HealthContributor health
* contributors}.
*
* @author Andy Wilkinson
* @author Stephane Nicoll
* @author Phillip Webb
* @author Vedran Pavic
* @since 2.0.0
* @deprecated since 2.2.0 in favor of {@link HealthContributorAutoConfiguration}
*/
@Deprecated
@Configuration(proxyBeanMethods = false)
public class HealthIndicatorAutoConfiguration {
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/health/HealthIndicatorProperties.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.health;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.DeprecatedConfigurationProperty;
/**
* Configuration properties for some health properties.
*
* @author Christian Dupuis
* @since 2.0.0
* @deprecated since 2.2.0 in favor of {@link HealthEndpointProperties}
*/
@Deprecated
@ConfigurationProperties(prefix = "management.health.status")
public class HealthIndicatorProperties {
private List<String> order = new ArrayList<>();
private final Map<String, Integer> httpMapping = new LinkedHashMap<>();
@DeprecatedConfigurationProperty(replacement = "management.endpoint.health.status.order")
public List<String> getOrder() {
return this.order;
}
public void setOrder(List<String> order) {
this.order = order;
}
@DeprecatedConfigurationProperty(replacement = "management.endpoint.health.status.http-mapping")
public Map<String, Integer> getHttpMapping() {
return this.httpMapping;
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/health/HealthStatusHttpMapperHttpCodeStatusMapperAdapter.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.health;
import org.springframework.boot.actuate.health.HealthStatusHttpMapper;
import org.springframework.boot.actuate.health.HttpCodeStatusMapper;
import org.springframework.boot.actuate.health.Status;
/**
* Adapter class to convert a legacy {@link HealthStatusHttpMapper} to a
* {@link HttpCodeStatusMapper}.
*
* @author Phillip Webb
*/
@SuppressWarnings("deprecation")
class HealthStatusHttpMapperHttpCodeStatusMapperAdapter implements HttpCodeStatusMapper {
private final HealthStatusHttpMapper healthStatusHttpMapper;
HealthStatusHttpMapperHttpCodeStatusMapperAdapter(HealthStatusHttpMapper healthStatusHttpMapper) {
this.healthStatusHttpMapper = healthStatusHttpMapper;
}
@Override
public int getStatusCode(Status status) {
return this.healthStatusHttpMapper.mapStatus(status);
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/health/LegacyHealthEndpointAdaptersConfiguration.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.health;
import org.springframework.boot.actuate.health.HttpCodeStatusMapper;
import org.springframework.boot.actuate.health.StatusAggregator;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* Configuration to adapt legacy deprecated health endpoint classes and interfaces.
*
* @author Phillip Webb
* @see HealthEndpointAutoConfiguration
*/
@Configuration(proxyBeanMethods = false)
@SuppressWarnings("deprecation")
class LegacyHealthEndpointAdaptersConfiguration {
@Bean
@ConditionalOnBean(org.springframework.boot.actuate.health.HealthAggregator.class)
StatusAggregator healthAggregatorStatusAggregatorAdapter(
org.springframework.boot.actuate.health.HealthAggregator healthAggregator) {
return new HealthAggregatorStatusAggregatorAdapter(healthAggregator);
}
@Bean
@ConditionalOnBean(org.springframework.boot.actuate.health.HealthStatusHttpMapper.class)
HttpCodeStatusMapper healthStatusHttpMapperHttpCodeStatusMapperAdapter(
org.springframework.boot.actuate.health.HealthStatusHttpMapper healthStatusHttpMapper) {
return new HealthStatusHttpMapperHttpCodeStatusMapperAdapter(healthStatusHttpMapper);
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/health/LegacyHealthEndpointCompatibilityConfiguration.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.health;
import reactor.core.publisher.Mono;
import org.springframework.boot.actuate.health.HealthAggregator;
import org.springframework.boot.actuate.health.HealthContributorRegistry;
import org.springframework.boot.actuate.health.HealthIndicatorRegistry;
import org.springframework.boot.actuate.health.HealthStatusHttpMapper;
import org.springframework.boot.actuate.health.OrderedHealthAggregator;
import org.springframework.boot.actuate.health.ReactiveHealthContributorRegistry;
import org.springframework.boot.actuate.health.ReactiveHealthIndicatorRegistry;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.CollectionUtils;
/**
* Configuration to adapt legacy deprecated health endpoint classes and interfaces.
*
* @author Phillip Webb
* @see HealthEndpointAutoConfiguration
*/
@Configuration(proxyBeanMethods = false)
@SuppressWarnings("deprecation")
@EnableConfigurationProperties(HealthIndicatorProperties.class)
class LegacyHealthEndpointCompatibilityConfiguration {
@Bean
@ConditionalOnMissingBean
HealthAggregator healthAggregator(HealthIndicatorProperties healthIndicatorProperties) {
OrderedHealthAggregator aggregator = new OrderedHealthAggregator();
if (!CollectionUtils.isEmpty(healthIndicatorProperties.getOrder())) {
aggregator.setStatusOrder(healthIndicatorProperties.getOrder());
}
return aggregator;
}
@Bean
@ConditionalOnMissingBean
HealthStatusHttpMapper healthStatusHttpMapper(HealthIndicatorProperties healthIndicatorProperties) {
HealthStatusHttpMapper mapper = new HealthStatusHttpMapper();
if (!CollectionUtils.isEmpty(healthIndicatorProperties.getHttpMapping())) {
mapper.setStatusMapping(healthIndicatorProperties.getHttpMapping());
}
return mapper;
}
@Bean
@ConditionalOnMissingBean(HealthIndicatorRegistry.class)
HealthContributorRegistryHealthIndicatorRegistryAdapter healthIndicatorRegistry(
HealthContributorRegistry healthContributorRegistry) {
return new HealthContributorRegistryHealthIndicatorRegistryAdapter(healthContributorRegistry);
}
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(Mono.class)
static class LegacyReactiveHealthEndpointCompatibilityConfiguration {
@Bean
@ConditionalOnMissingBean(ReactiveHealthIndicatorRegistry.class)
ReactiveHealthContributorRegistryReactiveHealthIndicatorRegistryAdapter reactiveHealthIndicatorRegistry(
ReactiveHealthContributorRegistry reactiveHealthContributorRegistry) {
return new ReactiveHealthContributorRegistryReactiveHealthIndicatorRegistryAdapter(
reactiveHealthContributorRegistry);
}
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/health/ReactiveHealthContributorRegistryReactiveHealthIndicatorRegistryAdapter.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.health;
import java.util.LinkedHashMap;
import java.util.Map;
import org.springframework.boot.actuate.health.NamedContributor;
import org.springframework.boot.actuate.health.ReactiveHealthContributor;
import org.springframework.boot.actuate.health.ReactiveHealthContributorRegistry;
import org.springframework.boot.actuate.health.ReactiveHealthIndicator;
import org.springframework.boot.actuate.health.ReactiveHealthIndicatorRegistry;
import org.springframework.util.Assert;
/**
* Adapter class to convert a {@link ReactiveHealthContributorRegistry} to a legacy
* {@link ReactiveHealthIndicatorRegistry}.
*
* @author Phillip Webb
*/
@SuppressWarnings("deprecation")
class ReactiveHealthContributorRegistryReactiveHealthIndicatorRegistryAdapter
implements ReactiveHealthIndicatorRegistry {
private final ReactiveHealthContributorRegistry contributorRegistry;
ReactiveHealthContributorRegistryReactiveHealthIndicatorRegistryAdapter(
ReactiveHealthContributorRegistry contributorRegistry) {
Assert.notNull(contributorRegistry, "ContributorRegistry must not be null");
this.contributorRegistry = contributorRegistry;
}
@Override
public void register(String name, ReactiveHealthIndicator healthIndicator) {
this.contributorRegistry.registerContributor(name, healthIndicator);
}
@Override
public ReactiveHealthIndicator unregister(String name) {
ReactiveHealthContributor contributor = this.contributorRegistry.unregisterContributor(name);
if (contributor instanceof ReactiveHealthIndicator) {
return (ReactiveHealthIndicator) contributor;
}
return null;
}
@Override
public ReactiveHealthIndicator get(String name) {
ReactiveHealthContributor contributor = this.contributorRegistry.getContributor(name);
if (contributor instanceof ReactiveHealthIndicator) {
return (ReactiveHealthIndicator) contributor;
}
return null;
}
@Override
public Map<String, ReactiveHealthIndicator> getAll() {
Map<String, ReactiveHealthIndicator> all = new LinkedHashMap<>();
for (NamedContributor<?> namedContributor : this.contributorRegistry) {
if (namedContributor.getContributor() instanceof ReactiveHealthIndicator) {
all.put(namedContributor.getName(), (ReactiveHealthIndicator) namedContributor.getContributor());
}
}
return all;
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/logging/LogFileWebEndpointAutoConfiguration.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -56,16 +56,15 @@ public class LogFileWebEndpointAutoConfiguration {
private static class LogFileCondition extends SpringBootCondition {
@SuppressWarnings("deprecation")
@Override
public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
Environment environment = context.getEnvironment();
String config = getLogFileConfig(environment, LogFile.FILE_NAME_PROPERTY, LogFile.FILE_PROPERTY);
String config = getLogFileConfig(environment, LogFile.FILE_NAME_PROPERTY);
ConditionMessage.Builder message = ConditionMessage.forCondition("Log File");
if (StringUtils.hasText(config)) {
return ConditionOutcome.match(message.found(LogFile.FILE_NAME_PROPERTY).items(config));
}
config = getLogFileConfig(environment, LogFile.FILE_PATH_PROPERTY, LogFile.PATH_PROPERTY);
config = getLogFileConfig(environment, LogFile.FILE_PATH_PROPERTY);
if (StringUtils.hasText(config)) {
return ConditionOutcome.match(message.found(LogFile.FILE_PATH_PROPERTY).items(config));
}
......@@ -76,12 +75,8 @@ public class LogFileWebEndpointAutoConfiguration {
return ConditionOutcome.noMatch(message.didNotFind("logging file").atAll());
}
private String getLogFileConfig(Environment environment, String configName, String deprecatedConfigName) {
String config = environment.resolvePlaceholders("${" + configName + ":}");
if (StringUtils.hasText(config)) {
return config;
}
return environment.resolvePlaceholders("${" + deprecatedConfigName + ":}");
private String getLogFileConfig(Environment environment, String configName) {
return environment.resolvePlaceholders("${" + configName + ":}");
}
}
......
spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/metrics/MetricsProperties.java
View file @ 33e414fc
......@@ -20,7 +20,6 @@ import java.util.LinkedHashMap;
import java.util.Map;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.DeprecatedConfigurationProperty;
import org.springframework.boot.context.properties.NestedConfigurationProperty;
/**
......@@ -110,28 +109,6 @@ public class MetricsProperties {
return this.request;
}
/**
* Return the name of the metric for client requests.
* @return request metric name
* @deprecated since 2.2.0 in favor of {@link ClientRequest#getMetricName()}
*/
@Deprecated
@DeprecatedConfigurationProperty(replacement = "management.metrics.web.client.request.metric-name")
public String getRequestsMetricName() {
return this.request.getMetricName();
}
/**
* Set the name of the metric for client requests.
* @param requestsMetricName request metric name
* @deprecated since 2.2.0 in favor of
* {@link ClientRequest#setMetricName(String)}
*/
@Deprecated
public void setRequestsMetricName(String requestsMetricName) {
this.request.setMetricName(requestsMetricName);
}
public int getMaxUriTags() {
return this.maxUriTags;
}
......@@ -184,50 +161,6 @@ public class MetricsProperties {
return this.request;
}
/**
* Return whether server requests should be automatically timed.
* @return {@code true} if server request should be automatically timed
* @deprecated since 2.2.0 in favor of {@link AutoTimeProperties#isEnabled()}
*/
@DeprecatedConfigurationProperty(replacement = "management.metrics.web.server.request.autotime.enabled")
@Deprecated
public boolean isAutoTimeRequests() {
return this.request.getAutotime().isEnabled();
}
/**
* Set whether server requests should be automatically timed.
* @param autoTimeRequests whether server requests should be automatically
* timed
* @deprecated since 2.2.0 in favor of {@link AutoTimeProperties#isEnabled()}
*/
@Deprecated
public void setAutoTimeRequests(boolean autoTimeRequests) {
this.request.getAutotime().setEnabled(autoTimeRequests);
}
/**
* Return name of the metric for server requests.
* @return request metric name
* @deprecated since 2.2.0 in favor of {@link ServerRequest#getMetricName()}
*/
@DeprecatedConfigurationProperty(replacement = "management.metrics.web.server.request.metric-name")
@Deprecated
public String getRequestsMetricName() {
return this.request.getMetricName();
}
/**
* Set the name of the metric for server requests.
* @param requestsMetricName request metric name
* @deprecated since 2.2.0 in favor of
* {@link ServerRequest#setMetricName(String)}
*/
@Deprecated
public void setRequestsMetricName(String requestsMetricName) {
this.request.setMetricName(requestsMetricName);
}
public int getMaxUriTags() {
return this.maxUriTags;
}
......
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/endpoint/condition/ConditionalOnEnabledEndpointTests.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.endpoint.condition;
import org.junit.jupiter.api.Test;
import org.springframework.boot.actuate.endpoint.EndpointFilter;
import org.springframework.boot.actuate.endpoint.ExposableEndpoint;
import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
import org.springframework.boot.actuate.endpoint.annotation.EndpointExtension;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link ConditionalOnEnabledEndpoint @ConditionalOnEnabledEndpoint}.
*
* @author Stephane Nicoll
* @author Andy Wilkinson
*/
@Deprecated
@SuppressWarnings("deprecation")
class ConditionalOnEnabledEndpointTests {
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner();
@Test
void outcomeWhenEndpointEnabledPropertyIsTrueShouldMatch() {
this.contextRunner.withPropertyValues("management.endpoint.foo.enabled=true")
.withUserConfiguration(FooEndpointEnabledByDefaultFalseConfiguration.class)
.run((context) -> assertThat(context).hasBean("foo"));
}
@Test
void outcomeWhenEndpointEnabledPropertyIsFalseShouldNotMatch() {
this.contextRunner.withPropertyValues("management.endpoint.foo.enabled=false")
.withUserConfiguration(FooEndpointEnabledByDefaultTrueConfiguration.class)
.run((context) -> assertThat(context).doesNotHaveBean("foo"));
}
@Test
void outcomeWhenNoEndpointPropertyAndUserDefinedDefaultIsTrueShouldMatch() {
this.contextRunner.withPropertyValues("management.endpoints.enabled-by-default=true")
.withUserConfiguration(FooEndpointEnabledByDefaultFalseConfiguration.class)
.run((context) -> assertThat(context).hasBean("foo"));
}
@Test
void outcomeWhenNoEndpointPropertyAndUserDefinedDefaultIsFalseShouldNotMatch() {
this.contextRunner.withPropertyValues("management.endpoints.enabled-by-default=false")
.withUserConfiguration(FooEndpointEnabledByDefaultTrueConfiguration.class)
.run((context) -> assertThat(context).doesNotHaveBean("foo"));
}
@Test
void outcomeWhenNoPropertiesAndAnnotationIsEnabledByDefaultShouldMatch() {
this.contextRunner.withUserConfiguration(FooEndpointEnabledByDefaultTrueConfiguration.class)
.run((context) -> assertThat(context).hasBean("foo"));
}
@Test
void outcomeWhenNoPropertiesAndAnnotationIsNotEnabledByDefaultShouldNotMatch() {
this.contextRunner.withUserConfiguration(FooEndpointEnabledByDefaultFalseConfiguration.class)
.run((context) -> assertThat(context).doesNotHaveBean("foo"));
}
@Test
void outcomeWhenNoPropertiesAndExtensionAnnotationIsEnabledByDefaultShouldMatch() {
this.contextRunner.withUserConfiguration(FooEndpointAndExtensionEnabledByDefaultTrueConfiguration.class)
.run((context) -> assertThat(context).hasBean("foo").hasBean("fooExt"));
}
@Test
void outcomeWhenNoPropertiesAndExtensionAnnotationIsNotEnabledByDefaultShouldNotMatch() {
this.contextRunner.withUserConfiguration(FooEndpointAndExtensionEnabledByDefaultFalseConfiguration.class)
.run((context) -> assertThat(context).doesNotHaveBean("foo").doesNotHaveBean("fooExt"));
}
@Test
void outcomeWithReferenceWhenNoPropertiesShouldMatch() {
this.contextRunner
.withUserConfiguration(FooEndpointEnabledByDefaultTrue.class,
ComponentEnabledIfEndpointIsEnabledConfiguration.class)
.run((context) -> assertThat(context).hasBean("fooComponent"));
}
@Test
void outcomeWithReferenceWhenEndpointEnabledPropertyIsTrueShouldMatch() {
this.contextRunner.withPropertyValues("management.endpoint.foo.enabled=true")
.withUserConfiguration(FooEndpointEnabledByDefaultTrue.class,
ComponentEnabledIfEndpointIsEnabledConfiguration.class)
.run((context) -> assertThat(context).hasBean("fooComponent"));
}
@Test
void outcomeWithReferenceWhenEndpointEnabledPropertyIsFalseShouldNotMatch() {
this.contextRunner.withPropertyValues("management.endpoint.foo.enabled=false")
.withUserConfiguration(FooEndpointEnabledByDefaultTrue.class,
ComponentEnabledIfEndpointIsEnabledConfiguration.class)
.run((context) -> assertThat(context).doesNotHaveBean("fooComponent"));
}
@Test
void outcomeWithNoReferenceShouldFail() {
this.contextRunner.withUserConfiguration(ComponentWithNoEndpointReferenceConfiguration.class).run((context) -> {
assertThat(context).hasFailed();
assertThat(context.getStartupFailure().getCause().getMessage())
.contains("No endpoint is specified and the return type of the @Bean method "
+ "is neither an @Endpoint, nor an @EndpointExtension");
});
}
@Test
void outcomeWhenEndpointEnabledPropertyIsTrueAndMixedCaseShouldMatch() {
this.contextRunner.withPropertyValues("management.endpoint.foo-bar.enabled=true")
.withUserConfiguration(FooBarEndpointEnabledByDefaultFalseConfiguration.class)
.run((context) -> assertThat(context).hasBean("fooBar"));
}
@Test
void outcomeWhenEndpointEnabledPropertyIsFalseOnClassShouldNotMatch() {
this.contextRunner.withPropertyValues("management.endpoint.foo.enabled=false")
.withUserConfiguration(FooEndpointEnabledByDefaultTrueOnConfigurationConfiguration.class)
.run((context) -> assertThat(context).doesNotHaveBean("foo"));
}
@Endpoint(id = "foo", enableByDefault = true)
static class FooEndpointEnabledByDefaultTrue {
}
@Endpoint(id = "foo", enableByDefault = false)
static class FooEndpointEnabledByDefaultFalse {
}
@Endpoint(id = "fooBar", enableByDefault = false)
static class FooBarEndpointEnabledByDefaultFalse {
}
@EndpointExtension(endpoint = FooEndpointEnabledByDefaultTrue.class, filter = TestFilter.class)
static class FooEndpointExtensionEnabledByDefaultTrue {
}
@EndpointExtension(endpoint = FooEndpointEnabledByDefaultFalse.class, filter = TestFilter.class)
static class FooEndpointExtensionEnabledByDefaultFalse {
}
static class TestFilter implements EndpointFilter<ExposableEndpoint<?>> {
@Override
public boolean match(ExposableEndpoint<?> endpoint) {
return true;
}
}
@Configuration(proxyBeanMethods = false)
static class FooEndpointEnabledByDefaultTrueConfiguration {
@Bean
@ConditionalOnEnabledEndpoint
FooEndpointEnabledByDefaultTrue foo() {
return new FooEndpointEnabledByDefaultTrue();
}
}
@Configuration(proxyBeanMethods = false)
@ConditionalOnEnabledEndpoint(endpoint = FooEndpointEnabledByDefaultTrue.class)
static class FooEndpointEnabledByDefaultTrueOnConfigurationConfiguration {
@Bean
FooEndpointEnabledByDefaultTrue foo() {
return new FooEndpointEnabledByDefaultTrue();
}
}
@Configuration(proxyBeanMethods = false)
static class FooEndpointEnabledByDefaultFalseConfiguration {
@Bean
@ConditionalOnEnabledEndpoint
FooEndpointEnabledByDefaultFalse foo() {
return new FooEndpointEnabledByDefaultFalse();
}
}
@Configuration(proxyBeanMethods = false)
static class FooBarEndpointEnabledByDefaultFalseConfiguration {
@Bean
@ConditionalOnEnabledEndpoint
FooBarEndpointEnabledByDefaultFalse fooBar() {
return new FooBarEndpointEnabledByDefaultFalse();
}
}
@Configuration(proxyBeanMethods = false)
static class FooEndpointAndExtensionEnabledByDefaultTrueConfiguration {
@Bean
@ConditionalOnEnabledEndpoint
FooEndpointEnabledByDefaultTrue foo() {
return new FooEndpointEnabledByDefaultTrue();
}
@Bean
@ConditionalOnEnabledEndpoint
FooEndpointExtensionEnabledByDefaultTrue fooExt() {
return new FooEndpointExtensionEnabledByDefaultTrue();
}
}
@Configuration(proxyBeanMethods = false)
static class FooEndpointAndExtensionEnabledByDefaultFalseConfiguration {
@Bean
@ConditionalOnEnabledEndpoint
FooEndpointEnabledByDefaultFalse foo() {
return new FooEndpointEnabledByDefaultFalse();
}
@Bean
@ConditionalOnEnabledEndpoint
FooEndpointExtensionEnabledByDefaultFalse fooExt() {
return new FooEndpointExtensionEnabledByDefaultFalse();
}
}
@Configuration(proxyBeanMethods = false)
static class ComponentEnabledIfEndpointIsEnabledConfiguration {
@Bean
@ConditionalOnEnabledEndpoint(endpoint = FooEndpointEnabledByDefaultTrue.class)
String fooComponent() {
return "foo";
}
}
@Configuration(proxyBeanMethods = false)
static class ComponentWithNoEndpointReferenceConfiguration {
@Bean
@ConditionalOnEnabledEndpoint
String fooComponent() {
return "foo";
}
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/health/HealthAggregatorStatusAggregatorAdapterTests.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.health;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.springframework.boot.actuate.health.AbstractHealthAggregator;
import org.springframework.boot.actuate.health.Status;
import org.springframework.boot.actuate.health.StatusAggregator;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link HealthAggregatorStatusAggregatorAdapter}.
*
* @author Phillip Webb
*/
@SuppressWarnings("deprecation")
class HealthAggregatorStatusAggregatorAdapterTests {
@Test
void getAggregateStatusDelegateToHealthAggregator() {
StatusAggregator adapter = new HealthAggregatorStatusAggregatorAdapter(new TestHealthAggregator());
Status status = adapter.getAggregateStatus(Status.UP, Status.DOWN);
assertThat(status.getCode()).isEqualTo("called2");
}
private static class TestHealthAggregator extends AbstractHealthAggregator {
@Override
protected Status aggregateStatus(List<Status> candidates) {
return new Status("called" + candidates.size());
}
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/health/HealthContributorRegistryHealthIndicatorRegistryAdapterTests.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.health;
import java.util.Map;
import org.junit.jupiter.api.Test;
import org.springframework.boot.actuate.health.CompositeHealthContributor;
import org.springframework.boot.actuate.health.DefaultHealthContributorRegistry;
import org.springframework.boot.actuate.health.HealthContributorRegistry;
import org.springframework.boot.actuate.health.HealthIndicator;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.assertj.core.api.Assertions.entry;
import static org.mockito.Mockito.mock;
/**
* Tests for {@link HealthContributorRegistryHealthIndicatorRegistryAdapter}.
*
* @author Phillip Webb
*/
class HealthContributorRegistryHealthIndicatorRegistryAdapterTests {
private HealthContributorRegistry contributorRegistry = new DefaultHealthContributorRegistry();
private HealthContributorRegistryHealthIndicatorRegistryAdapter adapter = new HealthContributorRegistryHealthIndicatorRegistryAdapter(
this.contributorRegistry);
@Test
void createWhenContributorRegistryIsNullThrowsException() {
assertThatIllegalArgumentException()
.isThrownBy(() -> new HealthContributorRegistryHealthIndicatorRegistryAdapter(null))
.withMessage("ContributorRegistry must not be null");
}
@Test
void registerDelegatesToContributorRegistry() {
HealthIndicator healthIndicator = mock(HealthIndicator.class);
this.adapter.register("test", healthIndicator);
assertThat(this.contributorRegistry.getContributor("test")).isSameAs(healthIndicator);
}
@Test
void unregisterDelegatesToContributorRegistry() {
HealthIndicator healthIndicator = mock(HealthIndicator.class);
this.contributorRegistry.registerContributor("test", healthIndicator);
HealthIndicator unregistered = this.adapter.unregister("test");
assertThat(unregistered).isSameAs(healthIndicator);
assertThat(this.contributorRegistry.getContributor("test")).isNull();
}
@Test
void unregisterWhenContributorRegistryResultIsNotHealthIndicatorReturnsNull() {
CompositeHealthContributor healthContributor = mock(CompositeHealthContributor.class);
this.contributorRegistry.registerContributor("test", healthContributor);
HealthIndicator unregistered = this.adapter.unregister("test");
assertThat(unregistered).isNull();
assertThat(this.contributorRegistry.getContributor("test")).isNull();
}
@Test
void getDelegatesToContributorRegistry() {
HealthIndicator healthIndicator = mock(HealthIndicator.class);
this.contributorRegistry.registerContributor("test", healthIndicator);
assertThat(this.adapter.get("test")).isSameAs(healthIndicator);
}
@Test
void getWhenContributorRegistryResultIsNotHealthIndicatorReturnsNull() {
CompositeHealthContributor healthContributor = mock(CompositeHealthContributor.class);
this.contributorRegistry.registerContributor("test", healthContributor);
assertThat(this.adapter.get("test")).isNull();
}
@Test
void getAllDelegatesToContributorRegistry() {
HealthIndicator healthIndicator = mock(HealthIndicator.class);
this.contributorRegistry.registerContributor("test", healthIndicator);
Map<String, HealthIndicator> all = this.adapter.getAll();
assertThat(all).containsOnly(entry("test", healthIndicator));
}
@Test
void getAllWhenContributorRegistryContainsNonHealthIndicatorInstancesReturnsFilteredMap() {
CompositeHealthContributor healthContributor = mock(CompositeHealthContributor.class);
this.contributorRegistry.registerContributor("test1", healthContributor);
HealthIndicator healthIndicator = mock(HealthIndicator.class);
this.contributorRegistry.registerContributor("test2", healthIndicator);
Map<String, HealthIndicator> all = this.adapter.getAll();
assertThat(all).containsOnly(entry("test2", healthIndicator));
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/health/HealthEndpointAutoConfigurationTests.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -17,9 +17,6 @@
package org.springframework.boot.actuate.autoconfigure.health;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Test;
import reactor.core.publisher.Flux;
......@@ -28,24 +25,20 @@ import reactor.core.publisher.Mono;
import org.springframework.boot.actuate.endpoint.SecurityContext;
import org.springframework.boot.actuate.endpoint.http.ApiVersion;
import org.springframework.boot.actuate.endpoint.web.WebEndpointResponse;
import org.springframework.boot.actuate.health.AbstractHealthAggregator;
import org.springframework.boot.actuate.health.DefaultHealthContributorRegistry;
import org.springframework.boot.actuate.health.DefaultReactiveHealthContributorRegistry;
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthAggregator;
import org.springframework.boot.actuate.health.HealthComponent;
import org.springframework.boot.actuate.health.HealthContributorRegistry;
import org.springframework.boot.actuate.health.HealthEndpoint;
import org.springframework.boot.actuate.health.HealthEndpointGroups;
import org.springframework.boot.actuate.health.HealthEndpointWebExtension;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.boot.actuate.health.HealthStatusHttpMapper;
import org.springframework.boot.actuate.health.HttpCodeStatusMapper;
import org.springframework.boot.actuate.health.NamedContributor;
import org.springframework.boot.actuate.health.ReactiveHealthContributorRegistry;
import org.springframework.boot.actuate.health.ReactiveHealthEndpointWebExtension;
import org.springframework.boot.actuate.health.ReactiveHealthIndicator;
import org.springframework.boot.actuate.health.ReactiveHealthIndicatorRegistry;
import org.springframework.boot.actuate.health.Status;
import org.springframework.boot.actuate.health.StatusAggregator;
import org.springframework.boot.autoconfigure.AutoConfigurations;
......@@ -66,7 +59,6 @@ import static org.mockito.Mockito.mock;
* @author Andy Wilkinson
* @author Stephane Nicoll
*/
@SuppressWarnings("deprecation")
class HealthEndpointAutoConfigurationTests {
private WebApplicationContextRunner contextRunner = new WebApplicationContextRunner()
......@@ -91,22 +83,6 @@ class HealthEndpointAutoConfigurationTests {
});
}
@Test
void runWhenHasHealthAggregatorAdaptsToStatusAggregator() {
this.contextRunner.withUserConfiguration(HealthAggregatorConfiguration.class).run((context) -> {
StatusAggregator aggregator = context.getBean(StatusAggregator.class);
assertThat(aggregator.getAggregateStatus(Status.UP, Status.DOWN)).isEqualTo(Status.UNKNOWN);
});
}
@Test
void runWhenHasHealthStatusHttpMapperAdaptsToHttpCodeStatusMapper() {
this.contextRunner.withUserConfiguration(HealthStatusHttpMapperConfiguration.class).run((context) -> {
HttpCodeStatusMapper mapper = context.getBean(HttpCodeStatusMapper.class);
assertThat(mapper.getStatusCode(Status.UP)).isEqualTo(123);
});
}
@Test
void runCreatesStatusAggregatorFromProperties() {
this.contextRunner.withPropertyValues("management.endpoint.health.status.order=up,down").run((context) -> {
......@@ -115,14 +91,6 @@ class HealthEndpointAutoConfigurationTests {
});
}
@Test
void runWhenUsingDeprecatedPropertyCreatesStatusAggregatorFromProperties() {
this.contextRunner.withPropertyValues("management.health.status.order=up,down").run((context) -> {
StatusAggregator aggregator = context.getBean(StatusAggregator.class);
assertThat(aggregator.getAggregateStatus(Status.UP, Status.DOWN)).isEqualTo(Status.UP);
});
}
@Test
void runWhenHasStatusAggregatorBeanIgnoresProperties() {
this.contextRunner.withUserConfiguration(StatusAggregatorConfiguration.class)
......@@ -141,14 +109,6 @@ class HealthEndpointAutoConfigurationTests {
});
}
@Test
void runUsingDeprecatedPropertyCreatesHttpCodeStatusMapperFromProperties() {
this.contextRunner.withPropertyValues("management.health.status.http-mapping.up=123").run((context) -> {
HttpCodeStatusMapper mapper = context.getBean(HttpCodeStatusMapper.class);
assertThat(mapper.getStatusCode(Status.UP)).isEqualTo(123);
});
}
@Test
void runWhenHasHttpCodeStatusMapperBeanIgnoresProperties() {
this.contextRunner.withUserConfiguration(HttpCodeStatusMapperConfiguration.class)
......@@ -286,37 +246,6 @@ class HealthEndpointAutoConfigurationTests {
});
}
@Test // gh-18354
void runCreatesLegacyHealthAggregator() {
this.contextRunner.run((context) -> {
HealthAggregator aggregator = context.getBean(HealthAggregator.class);
Map<String, Health> healths = new LinkedHashMap<>();
healths.put("one", Health.up().build());
healths.put("two", Health.down().build());
Health result = aggregator.aggregate(healths);
assertThat(result.getStatus()).isEqualTo(Status.DOWN);
});
}
@Test // gh-18354
void runCreatesLegacyHealthStatusHttpMapper() {
this.contextRunner.run((context) -> {
HealthStatusHttpMapper mapper = context.getBean(HealthStatusHttpMapper.class);
assertThat(mapper.mapStatus(Status.DOWN)).isEqualTo(503);
});
}
@Test
void runWhenReactorAvailableCreatesReactiveHealthIndicatorRegistryBean() {
this.contextRunner.run((context) -> assertThat(context).hasSingleBean(ReactiveHealthIndicatorRegistry.class));
}
@Test // gh-18570
void runWhenReactorUnavailableDoesNotCreateReactiveHealthIndicatorRegistryBean() {
this.contextRunner.withClassLoader(new FilteredClassLoader(Mono.class.getPackage().getName()))
.run((context) -> assertThat(context).doesNotHaveBean(ReactiveHealthIndicatorRegistry.class));
}
@Configuration(proxyBeanMethods = false)
static class HealthIndicatorsConfiguration {
......@@ -337,40 +266,6 @@ class HealthEndpointAutoConfigurationTests {
}
@Configuration(proxyBeanMethods = false)
static class HealthAggregatorConfiguration {
@Bean
HealthAggregator healthAggregator() {
return new AbstractHealthAggregator() {
@Override
protected Status aggregateStatus(List<Status> candidates) {
return Status.UNKNOWN;
}
};
}
}
@Configuration(proxyBeanMethods = false)
static class HealthStatusHttpMapperConfiguration {
@Bean
HealthStatusHttpMapper healthStatusHttpMapper() {
return new HealthStatusHttpMapper() {
@Override
public int mapStatus(Status status) {
return 123;
}
};
}
}
@Configuration(proxyBeanMethods = false)
static class StatusAggregatorConfiguration {
......
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/health/HealthIndicatorRegistryInjectionIntegrationTests.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.health;
import io.micrometer.core.instrument.Gauge;
import io.micrometer.core.instrument.MeterRegistry;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.actuate.autoconfigure.metrics.CompositeMeterRegistryAutoConfiguration;
import org.springframework.boot.actuate.autoconfigure.metrics.MetricsAutoConfiguration;
import org.springframework.boot.actuate.health.CompositeHealthIndicator;
import org.springframework.boot.actuate.health.HealthAggregator;
import org.springframework.boot.actuate.health.HealthIndicatorRegistry;
import org.springframework.boot.actuate.health.Status;
import org.springframework.boot.autoconfigure.ImportAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.context.annotation.Configuration;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Integration test to ensure that the legacy {@link HealthIndicatorRegistry} can still be
* injected.
*
* @author Phillip Webb
*/
@SuppressWarnings("deprecation")
@SpringBootTest(webEnvironment = WebEnvironment.NONE)
public class HealthIndicatorRegistryInjectionIntegrationTests {
// gh-18194
@Test
void meterRegistryBeanHasBeenConfigured(@Autowired MeterRegistry meterRegistry) {
assertThat(meterRegistry).isNotNull();
assertThat(meterRegistry.get("health").gauge()).isNotNull();
}
@Configuration
@ImportAutoConfiguration({ HealthEndpointAutoConfiguration.class, HealthContributorAutoConfiguration.class,
CompositeMeterRegistryAutoConfiguration.class, MetricsAutoConfiguration.class })
static class Config {
Config(HealthAggregator healthAggregator, HealthIndicatorRegistry healthIndicatorRegistry,
MeterRegistry registry) {
CompositeHealthIndicator healthIndicator = new CompositeHealthIndicator(healthAggregator,
healthIndicatorRegistry);
Gauge.builder("health", healthIndicator, this::getGuageValue)
.description("Spring boot health indicator. 3=UP, 2=OUT_OF_SERVICE, 1=DOWN, 0=UNKNOWN")
.strongReference(true).register(registry);
}
private double getGuageValue(CompositeHealthIndicator health) {
Status status = health.health().getStatus();
switch (status.getCode()) {
case "UP":
return 3;
case "OUT_OF_SERVICE":
return 2;
case "DOWN":
return 1;
case "UNKNOWN":
default:
return 0;
}
}
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/health/HealthStatusHttpMapperHttpCodeStatusMapperAdapterTests.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.health;
import org.junit.jupiter.api.Test;
import org.springframework.boot.actuate.health.HealthStatusHttpMapper;
import org.springframework.boot.actuate.health.HttpCodeStatusMapper;
import org.springframework.boot.actuate.health.Status;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link HealthStatusHttpMapperHttpCodeStatusMapperAdapter}.
*
* @author Phillip Webb
*/
@SuppressWarnings("deprecation")
class HealthStatusHttpMapperHttpCodeStatusMapperAdapterTests {
@Test
void getStatusCodeDelegatesToHealthStatusHttpMapper() {
HttpCodeStatusMapper adapter = new HealthStatusHttpMapperHttpCodeStatusMapperAdapter(
new TestHealthStatusHttpMapper());
assertThat(adapter.getStatusCode(Status.UP)).isEqualTo(123);
}
static class TestHealthStatusHttpMapper extends HealthStatusHttpMapper {
@Override
public int mapStatus(Status status) {
return 123;
}
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/health/ReactiveHealthContributorRegistryReactiveHealthIndicatorRegistryAdapterTests.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.autoconfigure.health;
import java.util.Map;
import org.junit.jupiter.api.Test;
import org.springframework.boot.actuate.health.CompositeReactiveHealthContributor;
import org.springframework.boot.actuate.health.DefaultReactiveHealthContributorRegistry;
import org.springframework.boot.actuate.health.ReactiveHealthContributorRegistry;
import org.springframework.boot.actuate.health.ReactiveHealthIndicator;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.assertj.core.api.Assertions.entry;
import static org.mockito.Mockito.mock;
/**
* Test for
* {@link ReactiveHealthContributorRegistryReactiveHealthIndicatorRegistryAdapter}.
*
* @author Phillip Webb
*/
class ReactiveHealthContributorRegistryReactiveHealthIndicatorRegistryAdapterTests {
private ReactiveHealthContributorRegistry contributorRegistry = new DefaultReactiveHealthContributorRegistry();
private ReactiveHealthContributorRegistryReactiveHealthIndicatorRegistryAdapter adapter = new ReactiveHealthContributorRegistryReactiveHealthIndicatorRegistryAdapter(
this.contributorRegistry);
@Test
void createWhenContributorRegistryIsNullThrowsException() {
assertThatIllegalArgumentException()
.isThrownBy(() -> new ReactiveHealthContributorRegistryReactiveHealthIndicatorRegistryAdapter(null))
.withMessage("ContributorRegistry must not be null");
}
@Test
void registerDelegatesToContributorRegistry() {
ReactiveHealthIndicator healthIndicator = mock(ReactiveHealthIndicator.class);
this.adapter.register("test", healthIndicator);
assertThat(this.contributorRegistry.getContributor("test")).isSameAs(healthIndicator);
}
@Test
void unregisterDelegatesToContributorRegistry() {
ReactiveHealthIndicator healthIndicator = mock(ReactiveHealthIndicator.class);
this.contributorRegistry.registerContributor("test", healthIndicator);
ReactiveHealthIndicator unregistered = this.adapter.unregister("test");
assertThat(unregistered).isSameAs(healthIndicator);
assertThat(this.contributorRegistry.getContributor("test")).isNull();
}
@Test
void unregisterWhenContributorRegistryResultIsNotHealthIndicatorReturnsNull() {
CompositeReactiveHealthContributor healthContributor = mock(CompositeReactiveHealthContributor.class);
this.contributorRegistry.registerContributor("test", healthContributor);
ReactiveHealthIndicator unregistered = this.adapter.unregister("test");
assertThat(unregistered).isNull();
assertThat(this.contributorRegistry.getContributor("test")).isNull();
}
@Test
void getDelegatesToContributorRegistry() {
ReactiveHealthIndicator healthIndicator = mock(ReactiveHealthIndicator.class);
this.contributorRegistry.registerContributor("test", healthIndicator);
assertThat(this.adapter.get("test")).isSameAs(healthIndicator);
}
@Test
void getWhenContributorRegistryResultIsNotHealthIndicatorReturnsNull() {
CompositeReactiveHealthContributor healthContributor = mock(CompositeReactiveHealthContributor.class);
this.contributorRegistry.registerContributor("test", healthContributor);
assertThat(this.adapter.get("test")).isNull();
}
@Test
void getAllDelegatesToContributorRegistry() {
ReactiveHealthIndicator healthIndicator = mock(ReactiveHealthIndicator.class);
this.contributorRegistry.registerContributor("test", healthIndicator);
Map<String, ReactiveHealthIndicator> all = this.adapter.getAll();
assertThat(all).containsOnly(entry("test", healthIndicator));
}
@Test
void getAllWhenContributorRegistryContainsNonHealthIndicatorInstancesReturnsFilteredMap() {
CompositeReactiveHealthContributor healthContributor = mock(CompositeReactiveHealthContributor.class);
this.contributorRegistry.registerContributor("test1", healthContributor);
ReactiveHealthIndicator healthIndicator = mock(ReactiveHealthIndicator.class);
this.contributorRegistry.registerContributor("test2", healthIndicator);
Map<String, ReactiveHealthIndicator> all = this.adapter.getAll();
assertThat(all).containsOnly(entry("test2", healthIndicator));
}
}
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/logging/LogFileWebEndpointAutoConfigurationTests.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -64,14 +64,6 @@ class LogFileWebEndpointAutoConfigurationTests {
.run((context) -> assertThat(context).hasSingleBean(LogFileWebEndpoint.class));
}
@Test
@Deprecated
void runWhenLoggingFileIsSetWithDeprecatedPropertyAndExposedShouldHaveEndpointBean() {
this.contextRunner
.withPropertyValues("logging.file:test.log", "management.endpoints.web.exposure.include=logfile")
.run((context) -> assertThat(context).hasSingleBean(LogFileWebEndpoint.class));
}
@Test
void runWhenLoggingPathIsSetAndNotExposedShouldNotHaveEndpointBean() {
this.contextRunner.withPropertyValues("logging.file.path:test/logs")
......@@ -85,14 +77,6 @@ class LogFileWebEndpointAutoConfigurationTests {
.run((context) -> assertThat(context).hasSingleBean(LogFileWebEndpoint.class));
}
@Test
@Deprecated
void runWhenLoggingPathIsSetWithDeprecatedPropertyAndExposedShouldHaveEndpointBean() {
this.contextRunner
.withPropertyValues("logging.path:test/logs", "management.endpoints.web.exposure.include=logfile")
.run((context) -> assertThat(context).hasSingleBean(LogFileWebEndpoint.class));
}
@Test
void logFileWebEndpointIsAutoConfiguredWhenExternalFileIsSet() {
this.contextRunner
......
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/metrics/web/reactive/WebFluxMetricsAutoConfigurationTests.java
View file @ 33e414fc
......@@ -112,17 +112,6 @@ class WebFluxMetricsAutoConfigurationTests {
});
}
@Test
@Deprecated
void metricsAreNotRecordedIfAutoTimeRequestsIsDisabledWithDeprecatedProperty() {
this.contextRunner.withConfiguration(AutoConfigurations.of(WebFluxAutoConfiguration.class))
.withUserConfiguration(TestController.class)
.withPropertyValues("management.metrics.web.server.auto-time-requests=false").run((context) -> {
MeterRegistry registry = getInitializedMeterRegistry(context);
assertThat(registry.find("http.server.requests").meter()).isNull();
});
}
private MeterRegistry getInitializedMeterRegistry(AssertableReactiveWebApplicationContext context) {
WebTestClient webTestClient = WebTestClient.bindToApplicationContext(context).build();
for (int i = 0; i < 3; i++) {
......
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/elasticsearch/ElasticsearchHealthIndicator.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.elasticsearch;
import java.util.List;
import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequest;
import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse;
import org.elasticsearch.client.Client;
import org.elasticsearch.client.Requests;
import org.springframework.boot.actuate.health.AbstractHealthIndicator;
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
/**
* {@link HealthIndicator} for an Elasticsearch cluster.
*
* @author Binwei Yang
* @author Andy Wilkinson
* @since 2.0.0
* @deprecated since 2.2.0 as {@literal org.elasticsearch.client:transport} has been
* deprecated upstream
*/
@Deprecated
public class ElasticsearchHealthIndicator extends AbstractHealthIndicator {
private static final String[] ALL_INDICES = { "_all" };
private final Client client;
private final String[] indices;
private final long responseTimeout;
/**
* Create a new {@link ElasticsearchHealthIndicator} instance.
* @param client the Elasticsearch client
* @param responseTimeout the request timeout in milliseconds
* @param indices the indices to check
*/
public ElasticsearchHealthIndicator(Client client, long responseTimeout, List<String> indices) {
this(client, responseTimeout, (indices != null) ? StringUtils.toStringArray(indices) : null);
}
/**
* Create a new {@link ElasticsearchHealthIndicator} instance.
* @param client the Elasticsearch client
* @param responseTimeout the request timeout in milliseconds
* @param indices the indices to check
*/
public ElasticsearchHealthIndicator(Client client, long responseTimeout, String... indices) {
super("Elasticsearch health check failed");
this.client = client;
this.responseTimeout = responseTimeout;
this.indices = indices;
}
@Override
protected void doHealthCheck(Health.Builder builder) throws Exception {
ClusterHealthRequest request = Requests
.clusterHealthRequest(ObjectUtils.isEmpty(this.indices) ? ALL_INDICES : this.indices);
ClusterHealthResponse response = this.client.admin().cluster().health(request).actionGet(this.responseTimeout);
switch (response.getStatus()) {
case GREEN:
case YELLOW:
builder.up();
break;
case RED:
default:
builder.down();
break;
}
builder.withDetail("clusterName", response.getClusterName());
builder.withDetail("numberOfNodes", response.getNumberOfNodes());
builder.withDetail("numberOfDataNodes", response.getNumberOfDataNodes());
builder.withDetail("activePrimaryShards", response.getActivePrimaryShards());
builder.withDetail("activeShards", response.getActiveShards());
builder.withDetail("relocatingShards", response.getRelocatingShards());
builder.withDetail("initializingShards", response.getInitializingShards());
builder.withDetail("unassignedShards", response.getUnassignedShards());
}
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/http/ActuatorMediaType.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -25,13 +25,6 @@ package org.springframework.boot.actuate.endpoint.http;
*/
public final class ActuatorMediaType {
/**
* Constant for the Actuator V1 media type.
* @deprecated since 2.2.0 as the v1 format is no longer supported
*/
@Deprecated
public static final String V1_JSON = "application/vnd.spring-boot.actuator.v1+json";
/**
* Constant for the Actuator {@link ApiVersion#V2 v2} media type.
*/
......
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/AbstractHealthAggregator.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* Base {@link HealthAggregator} implementation to allow subclasses to focus on
* aggregating the {@link Status} instances and not deal with contextual details etc.
*
* @author Christian Dupuis
* @author Vedran Pavic
* @since 1.1.0
* @deprecated since 2.2.0 as {@link HealthAggregator} has been deprecated
*/
@Deprecated
public abstract class AbstractHealthAggregator implements HealthAggregator {
@Override
public final Health aggregate(Map<String, Health> healths) {
List<Status> statusCandidates = healths.values().stream().map(Health::getStatus).collect(Collectors.toList());
Status status = aggregateStatus(statusCandidates);
Map<String, Object> details = aggregateDetails(healths);
return new Health.Builder(status, details).build();
}
/**
* Return the single 'aggregate' status that should be used from the specified
* candidates.
* @param candidates the candidates
* @return a single status
*/
protected abstract Status aggregateStatus(List<Status> candidates);
/**
* Return the map of 'aggregate' details that should be used from the specified
* healths.
* @param healths the health instances to aggregate
* @return a map of details
* @since 1.3.1
*/
protected Map<String, Object> aggregateDetails(Map<String, Health> healths) {
return new LinkedHashMap<>(healths);
}
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/ApplicationHealthIndicator.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
/**
* Default implementation of {@link HealthIndicator} that returns {@link Status#UP}.
*
* @author Dave Syer
* @author Christian Dupuis
* @since 1.2.0
* @see Status#UP
* @deprecated since 2.2 in favor of {@link PingHealthIndicator}.
*/
@Deprecated
public class ApplicationHealthIndicator extends AbstractHealthIndicator {
public ApplicationHealthIndicator() {
super("Application health check failed");
}
@Override
protected void doHealthCheck(Health.Builder builder) throws Exception {
builder.up();
}
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/CompositeHealthIndicator.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* {@link HealthIndicator} that returns health indications from all registered delegates.
*
* @author Tyler J. Frederick
* @author Phillip Webb
* @author Christian Dupuis
* @since 1.1.0
* @deprecated since 2.2.0 in favor of a {@link CompositeHealthContributor}
*/
@Deprecated
public class CompositeHealthIndicator implements HealthIndicator {
private final HealthIndicatorRegistry registry;
private final HealthAggregator aggregator;
/**
* Create a new {@link CompositeHealthIndicator} from the specified indicators.
* @param healthAggregator the health aggregator
* @param indicators a map of {@link HealthIndicator HealthIndicators} with the key
* being used as an indicator name.
*/
public CompositeHealthIndicator(HealthAggregator healthAggregator, Map<String, HealthIndicator> indicators) {
this(healthAggregator, new DefaultHealthIndicatorRegistry(indicators));
}
/**
* Create a new {@link CompositeHealthIndicator} from the indicators in the given
* {@code registry}.
* @param healthAggregator the health aggregator
* @param registry the registry of {@link HealthIndicator HealthIndicators}.
*/
public CompositeHealthIndicator(HealthAggregator healthAggregator, HealthIndicatorRegistry registry) {
this.aggregator = healthAggregator;
this.registry = registry;
}
/**
* Return the {@link HealthIndicatorRegistry} of this instance.
* @return the registry of nested {@link HealthIndicator health indicators}
* @since 2.1.0
*/
public HealthIndicatorRegistry getRegistry() {
return this.registry;
}
@Override
public Health health() {
Map<String, Health> healths = new LinkedHashMap<>();
for (Map.Entry<String, HealthIndicator> entry : this.registry.getAll().entrySet()) {
healths.put(entry.getKey(), entry.getValue().health());
}
return this.aggregator.aggregate(healths);
}
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/CompositeReactiveHealthIndicator.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.time.Duration;
import java.util.function.Function;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.util.function.Tuple2;
/**
* {@link ReactiveHealthIndicator} that returns health indications from all registered
* delegates. Provides an alternative {@link Health} for a delegate that reaches a
* configurable timeout.
*
* @author Stephane Nicoll
* @since 2.0.0
* @deprecated since 2.2.0 in favor of a {@link CompositeReactiveHealthContributor}
*/
@Deprecated
public class CompositeReactiveHealthIndicator implements ReactiveHealthIndicator {
private final ReactiveHealthIndicatorRegistry registry;
private final HealthAggregator healthAggregator;
private Long timeout;
private Health timeoutHealth;
private final Function<Mono<Health>, Mono<Health>> timeoutCompose;
/**
* Create a new {@link CompositeReactiveHealthIndicator} from the indicators in the
* given {@code registry}.
* @param healthAggregator the health aggregator
* @param registry the registry of {@link ReactiveHealthIndicator HealthIndicators}.
*/
public CompositeReactiveHealthIndicator(HealthAggregator healthAggregator,
ReactiveHealthIndicatorRegistry registry) {
this.registry = registry;
this.healthAggregator = healthAggregator;
this.timeoutCompose = (mono) -> (this.timeout != null)
? mono.timeout(Duration.ofMillis(this.timeout), Mono.just(this.timeoutHealth)) : mono;
}
/**
* Specify an alternative timeout {@link Health} if a {@link HealthIndicator} failed
* to reply after specified {@code timeout}.
* @param timeout number of milliseconds to wait before using the
* {@code timeoutHealth}
* @param timeoutHealth the {@link Health} to use if an health indicator reached the
* {@code timeout}
* @return this instance
*/
public CompositeReactiveHealthIndicator timeoutStrategy(long timeout, Health timeoutHealth) {
this.timeout = timeout;
this.timeoutHealth = (timeoutHealth != null) ? timeoutHealth : Health.unknown().build();
return this;
}
ReactiveHealthIndicatorRegistry getRegistry() {
return this.registry;
}
@Override
public Mono<Health> health() {
return Flux.fromIterable(this.registry.getAll().entrySet())
.flatMap((entry) -> Mono.zip(Mono.just(entry.getKey()),
entry.getValue().health().transformDeferred(this.timeoutCompose)))
.collectMap(Tuple2::getT1, Tuple2::getT2).map(this.healthAggregator::aggregate);
}
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/DefaultHealthIndicatorRegistry.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import org.springframework.util.Assert;
/**
* Default implementation of {@link HealthIndicatorRegistry}.
*
* @author Vedran Pavic
* @author Stephane Nicoll
* @since 2.1.0
* @deprecated since 2.2.0 in favor of {@link DefaultContributorRegistry}
*/
@Deprecated
public class DefaultHealthIndicatorRegistry implements HealthIndicatorRegistry {
private final Object monitor = new Object();
private final Map<String, HealthIndicator> healthIndicators;
/**
* Create a new {@link DefaultHealthIndicatorRegistry}.
*/
public DefaultHealthIndicatorRegistry() {
this(new LinkedHashMap<>());
}
/**
* Create a new {@link DefaultHealthIndicatorRegistry} from the specified indicators.
* @param healthIndicators a map of {@link HealthIndicator}s with the key being used
* as an indicator name.
*/
public DefaultHealthIndicatorRegistry(Map<String, HealthIndicator> healthIndicators) {
Assert.notNull(healthIndicators, "HealthIndicators must not be null");
this.healthIndicators = new LinkedHashMap<>(healthIndicators);
}
@Override
public void register(String name, HealthIndicator healthIndicator) {
Assert.notNull(healthIndicator, "HealthIndicator must not be null");
Assert.notNull(name, "Name must not be null");
synchronized (this.monitor) {
HealthIndicator existing = this.healthIndicators.putIfAbsent(name, healthIndicator);
if (existing != null) {
throw new IllegalStateException("HealthIndicator with name '" + name + "' already registered");
}
}
}
@Override
public HealthIndicator unregister(String name) {
Assert.notNull(name, "Name must not be null");
synchronized (this.monitor) {
return this.healthIndicators.remove(name);
}
}
@Override
public HealthIndicator get(String name) {
Assert.notNull(name, "Name must not be null");
synchronized (this.monitor) {
return this.healthIndicators.get(name);
}
}
@Override
public Map<String, HealthIndicator> getAll() {
synchronized (this.monitor) {
return Collections.unmodifiableMap(new LinkedHashMap<>(this.healthIndicators));
}
}
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/DefaultReactiveHealthIndicatorRegistry.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import org.springframework.util.Assert;
/**
* Default implementation of {@link ReactiveHealthIndicatorRegistry}.
*
* @author Vedran Pavic
* @author Stephane Nicoll
* @since 2.1.0
* @deprecated since 2.2.0 in favor of {@link DefaultContributorRegistry}
*/
@Deprecated
public class DefaultReactiveHealthIndicatorRegistry implements ReactiveHealthIndicatorRegistry {
private final Object monitor = new Object();
private final Map<String, ReactiveHealthIndicator> healthIndicators;
/**
* Create a new {@link DefaultReactiveHealthIndicatorRegistry}.
*/
public DefaultReactiveHealthIndicatorRegistry() {
this(new LinkedHashMap<>());
}
/**
* Create a new {@link DefaultReactiveHealthIndicatorRegistry} from the specified
* indicators.
* @param healthIndicators a map of {@link HealthIndicator}s with the key being used
* as an indicator name.
*/
public DefaultReactiveHealthIndicatorRegistry(Map<String, ReactiveHealthIndicator> healthIndicators) {
Assert.notNull(healthIndicators, "HealthIndicators must not be null");
this.healthIndicators = new LinkedHashMap<>(healthIndicators);
}
@Override
public void register(String name, ReactiveHealthIndicator healthIndicator) {
Assert.notNull(healthIndicator, "HealthIndicator must not be null");
Assert.notNull(name, "Name must not be null");
synchronized (this.monitor) {
ReactiveHealthIndicator existing = this.healthIndicators.putIfAbsent(name, healthIndicator);
if (existing != null) {
throw new IllegalStateException("HealthIndicator with name '" + name + "' already registered");
}
}
}
@Override
public ReactiveHealthIndicator unregister(String name) {
Assert.notNull(name, "Name must not be null");
synchronized (this.monitor) {
return this.healthIndicators.remove(name);
}
}
@Override
public ReactiveHealthIndicator get(String name) {
Assert.notNull(name, "Name must not be null");
synchronized (this.monitor) {
return this.healthIndicators.get(name);
}
}
@Override
public Map<String, ReactiveHealthIndicator> getAll() {
synchronized (this.monitor) {
return Collections.unmodifiableMap(new LinkedHashMap<>(this.healthIndicators));
}
}
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/HealthAggregator.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.util.Map;
/**
* Strategy interface used to aggregate {@link Health} instances into a final one.
* <p>
* This is especially useful to combine subsystem states expressed through
* {@link Health#getStatus()} into one state for the entire system. The default
* implementation {@link OrderedHealthAggregator} sorts {@link Status} instances based on
* a priority list.
* <p>
* It is possible to add more complex {@link Status} types to the system. In that case
* either the {@link OrderedHealthAggregator} needs to be properly configured or users
* need to register a custom {@link HealthAggregator} as bean.
*
* @author Christian Dupuis
* @since 1.1.0
* @deprecated since 2.2.0 in favor of {@link StatusAggregator}
*/
@FunctionalInterface
@Deprecated
public interface HealthAggregator {
/**
* Aggregate several given {@link Health} instances into one.
* @param healths the health instances to aggregate
* @return the aggregated health
*/
Health aggregate(Map<String, Health> healths);
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/HealthEndpoint.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -40,17 +40,6 @@ public class HealthEndpoint extends HealthEndpointSupport<HealthContributor, Hea
private static final String[] EMPTY_PATH = {};
/**
* Create a new {@link HealthEndpoint} instance that will use the given {@code
* healthIndicator} to generate its response.
* @param healthIndicator the health indicator
* @deprecated since 2.2.0 in favor of
* {@link #HealthEndpoint(HealthContributorRegistry, HealthEndpointGroups)}
*/
@Deprecated
public HealthEndpoint(HealthIndicator healthIndicator) {
}
/**
* Create a new {@link HealthEndpoint} instance.
* @param registry the health contributor registry
......
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/HealthEndpointSupport.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -40,16 +40,6 @@ abstract class HealthEndpointSupport<C, T> {
private final HealthEndpointGroups groups;
/**
* Throw a new {@link IllegalStateException} to indicate a constructor has been
* deprecated.
* @deprecated since 2.2.0 in order to support deprecated subclass constructors
*/
@Deprecated
HealthEndpointSupport() {
throw new IllegalStateException("Unable to create " + getClass() + " using deprecated constructor");
}
/**
* Create a new {@link HealthEndpointSupport} instance.
* @param registry the health contributor registry
......
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/HealthEndpointWebExtension.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -45,17 +45,6 @@ public class HealthEndpointWebExtension extends HealthEndpointSupport<HealthCont
private static final String[] NO_PATH = {};
/**
* Create a new {@link HealthEndpointWebExtension} instance using a delegate endpoint.
* @param delegate the delegate endpoint
* @param responseMapper the response mapper
* @deprecated since 2.2.0 in favor of
* {@link #HealthEndpointWebExtension(HealthContributorRegistry, HealthEndpointGroups)}
*/
@Deprecated
public HealthEndpointWebExtension(HealthEndpoint delegate, HealthWebEndpointResponseMapper responseMapper) {
}
/**
* Create a new {@link HealthEndpointWebExtension} instance.
* @param registry the health contributor registry
......
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/HealthIndicatorNameFactory.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
/**
* Generate a sensible health indicator name based on its bean name.
*
* @author Stephane Nicoll
* @author Phillip Webb
* @since 2.0.0
* @deprecated since 2.2.0 in favor of {@link HealthContributorNameFactory}
*/
@Deprecated
public class HealthIndicatorNameFactory extends HealthContributorNameFactory {
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/HealthIndicatorReactiveAdapter.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
......@@ -26,17 +26,12 @@ import org.springframework.util.Assert;
* safely invoked in a reactive environment.
*
* @author Stephane Nicoll
* @since 2.0.0
* @deprecated since 2.2.0 in favor of
* {@link ReactiveHealthContributor#adapt(HealthContributor)}
* @see ReactiveHealthContributor#adapt(HealthContributor)
*/
@Deprecated
public class HealthIndicatorReactiveAdapter implements ReactiveHealthIndicator {
class HealthIndicatorReactiveAdapter implements ReactiveHealthIndicator {
private final HealthIndicator delegate;
public HealthIndicatorReactiveAdapter(HealthIndicator delegate) {
HealthIndicatorReactiveAdapter(HealthIndicator delegate) {
Assert.notNull(delegate, "Delegate must not be null");
this.delegate = delegate;
}
......
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/HealthIndicatorRegistry.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.util.Map;
/**
* A mutable registry of {@link HealthIndicator HealthIndicators}.
* <p>
* Implementations <strong>must</strong> be thread-safe.
*
* @author Andy Wilkinson
* @author Vedran Pavic
* @author Stephane Nicoll
* @since 2.1.0
* @see HealthEndpoint
* @deprecated since 2.2.0 in favor of a {@link HealthContributorRegistry}
*/
@Deprecated
public interface HealthIndicatorRegistry {
/**
* Registers the given {@link HealthIndicator}, associating it with the given
* {@code name}.
* @param name the name of the indicator
* @param healthIndicator the indicator
* @throws IllegalStateException if the indicator cannot be registered with the given
* {@code name}.
*/
void register(String name, HealthIndicator healthIndicator);
/**
* Unregisters the {@link HealthIndicator} previously registered with the given
* {@code name}.
* @param name the name of the indicator
* @return the unregistered indicator, or {@code null} if no indicator was found in
* the registry for the given {@code name}.
*/
HealthIndicator unregister(String name);
/**
* Returns the {@link HealthIndicator} registered with the given {@code name}.
* @param name the name of the indicator
* @return the health indicator, or {@code null} if no indicator was registered with
* the given {@code name}.
*/
HealthIndicator get(String name);
/**
* Returns a snapshot of the registered health indicators and their names. The
* contents of the map do not reflect subsequent changes to the registry.
* @return the snapshot of registered health indicators
*/
Map<String, HealthIndicator> getAll();
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/HealthIndicatorRegistryFactory.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.util.Map;
import java.util.function.Function;
import org.springframework.util.Assert;
/**
* Factory to create a {@link HealthIndicatorRegistry}.
*
* @author Stephane Nicoll
* @since 2.1.0
* @deprecated since 2.2.0 in favor of {@link DefaultHealthIndicatorRegistry}
*/
@Deprecated
public class HealthIndicatorRegistryFactory {
private final Function<String, String> healthIndicatorNameFactory;
public HealthIndicatorRegistryFactory(Function<String, String> healthIndicatorNameFactory) {
this.healthIndicatorNameFactory = healthIndicatorNameFactory;
}
public HealthIndicatorRegistryFactory() {
this(new HealthIndicatorNameFactory());
}
/**
* Create a {@link HealthIndicatorRegistry} based on the specified health indicators.
* @param healthIndicators the {@link HealthIndicator} instances mapped by name
* @return a {@link HealthIndicator} that delegates to the specified
* {@code healthIndicators}.
*/
public HealthIndicatorRegistry createHealthIndicatorRegistry(Map<String, HealthIndicator> healthIndicators) {
Assert.notNull(healthIndicators, "HealthIndicators must not be null");
return initialize(new DefaultHealthIndicatorRegistry(), healthIndicators);
}
protected <T extends HealthIndicatorRegistry> T initialize(T registry,
Map<String, HealthIndicator> healthIndicators) {
for (Map.Entry<String, HealthIndicator> entry : healthIndicators.entrySet()) {
String name = this.healthIndicatorNameFactory.apply(entry.getKey());
registry.register(name, entry.getValue());
}
return registry;
}
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/HealthStatusHttpMapper.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import org.springframework.boot.actuate.endpoint.web.WebEndpointResponse;
import org.springframework.util.Assert;
/**
* Map a {@link Status} to an HTTP status code.
*
* @author Stephane Nicoll
* @since 2.0.0
* @deprecated since 2.2.0 in favor of {@link HttpCodeStatusMapper} or
* {@link SimpleHttpCodeStatusMapper}
*/
@Deprecated
public class HealthStatusHttpMapper {
private Map<String, Integer> statusMapping = new HashMap<>();
/**
* Create a new instance.
*/
public HealthStatusHttpMapper() {
setupDefaultStatusMapping();
}
private void setupDefaultStatusMapping() {
addStatusMapping(Status.DOWN, WebEndpointResponse.STATUS_SERVICE_UNAVAILABLE);
addStatusMapping(Status.OUT_OF_SERVICE, WebEndpointResponse.STATUS_SERVICE_UNAVAILABLE);
}
/**
* Set specific status mappings.
* @param statusMapping a map of health status code to HTTP status code
*/
public void setStatusMapping(Map<String, Integer> statusMapping) {
Assert.notNull(statusMapping, "StatusMapping must not be null");
this.statusMapping = new HashMap<>(statusMapping);
}
/**
* Add specific status mappings to the existing set.
* @param statusMapping a map of health status code to HTTP status code
*/
public void addStatusMapping(Map<String, Integer> statusMapping) {
Assert.notNull(statusMapping, "StatusMapping must not be null");
this.statusMapping.putAll(statusMapping);
}
/**
* Add a status mapping to the existing set.
* @param status the status to map
* @param httpStatus the http status
*/
public void addStatusMapping(Status status, Integer httpStatus) {
Assert.notNull(status, "Status must not be null");
Assert.notNull(httpStatus, "HttpStatus must not be null");
addStatusMapping(status.getCode(), httpStatus);
}
/**
* Add a status mapping to the existing set.
* @param statusCode the status code to map
* @param httpStatus the http status
*/
public void addStatusMapping(String statusCode, Integer httpStatus) {
Assert.notNull(statusCode, "StatusCode must not be null");
Assert.notNull(httpStatus, "HttpStatus must not be null");
this.statusMapping.put(statusCode, httpStatus);
}
/**
* Return an immutable view of the status mapping.
* @return the http status codes mapped by status name
*/
public Map<String, Integer> getStatusMapping() {
return Collections.unmodifiableMap(this.statusMapping);
}
/**
* Map the specified {@link Status} to an HTTP status code.
* @param status the health {@link Status}
* @return the corresponding HTTP status code
*/
public int mapStatus(Status status) {
String code = getUniformValue(status.getCode());
if (code != null) {
return this.statusMapping.entrySet().stream()
.filter((entry) -> code.equals(getUniformValue(entry.getKey()))).map(Map.Entry::getValue)
.findFirst().orElse(WebEndpointResponse.STATUS_OK);
}
return WebEndpointResponse.STATUS_OK;
}
private String getUniformValue(String code) {
if (code == null) {
return null;
}
StringBuilder builder = new StringBuilder();
for (char ch : code.toCharArray()) {
if (Character.isAlphabetic(ch) || Character.isDigit(ch)) {
builder.append(Character.toLowerCase(ch));
}
}
return builder.toString();
}
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/HealthWebEndpointResponseMapper.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.security.Principal;
import java.util.Set;
import java.util.function.Supplier;
import org.springframework.boot.actuate.endpoint.SecurityContext;
import org.springframework.boot.actuate.endpoint.web.WebEndpointResponse;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.util.ClassUtils;
import org.springframework.util.CollectionUtils;
/**
* Maps a {@link Health} to a {@link WebEndpointResponse}.
*
* @author Andy Wilkinson
* @since 2.0.0
* @deprecated since 2.2.0 in favor of {@link HealthEndpointWebExtension} or
* {@link ReactiveHealthEndpointWebExtension}
*/
@Deprecated
public class HealthWebEndpointResponseMapper {
private final HealthStatusHttpMapper statusHttpMapper;
private final ShowDetails showDetails;
private final Set<String> authorizedRoles;
public HealthWebEndpointResponseMapper(HealthStatusHttpMapper statusHttpMapper, ShowDetails showDetails,
Set<String> authorizedRoles) {
this.statusHttpMapper = statusHttpMapper;
this.showDetails = showDetails;
this.authorizedRoles = authorizedRoles;
}
/**
* Maps the given {@code health} details to a {@link WebEndpointResponse}, honouring
* the mapper's default {@link ShowDetails} using the given {@code securityContext}.
* <p>
* If the current user does not have the right to see the details, the
* {@link Supplier} is not invoked and a 404 response is returned instead.
* @param health the provider of health details, invoked if the current user has the
* right to see them
* @param securityContext the security context
* @return the mapped response
*/
public WebEndpointResponse<Health> mapDetails(Supplier<Health> health, SecurityContext securityContext) {
if (canSeeDetails(securityContext, this.showDetails)) {
Health healthDetails = health.get();
if (healthDetails != null) {
return createWebEndpointResponse(healthDetails);
}
}
return new WebEndpointResponse<>(WebEndpointResponse.STATUS_NOT_FOUND);
}
/**
* Maps the given {@code health} to a {@link WebEndpointResponse}, honouring the
* mapper's default {@link ShowDetails} using the given {@code securityContext}.
* @param health the health to map
* @param securityContext the security context
* @return the mapped response
*/
public WebEndpointResponse<Health> map(Health health, SecurityContext securityContext) {
return map(health, securityContext, this.showDetails);
}
/**
* Maps the given {@code health} to a {@link WebEndpointResponse}, honouring the given
* {@code showDetails} using the given {@code securityContext}.
* @param health the health to map
* @param securityContext the security context
* @param showDetails when to show details in the response
* @return the mapped response
*/
public WebEndpointResponse<Health> map(Health health, SecurityContext securityContext, ShowDetails showDetails) {
if (!canSeeDetails(securityContext, showDetails)) {
health = Health.status(health.getStatus()).build();
}
return createWebEndpointResponse(health);
}
private WebEndpointResponse<Health> createWebEndpointResponse(Health health) {
int status = this.statusHttpMapper.mapStatus(health.getStatus());
return new WebEndpointResponse<>(health, status);
}
private boolean canSeeDetails(SecurityContext securityContext, ShowDetails showDetails) {
return showDetails != ShowDetails.NEVER && (showDetails != ShowDetails.WHEN_AUTHORIZED
|| (securityContext.getPrincipal() != null && isUserInRole(securityContext)));
}
private boolean isUserInRole(SecurityContext securityContext) {
if (CollectionUtils.isEmpty(this.authorizedRoles)) {
return true;
}
Principal principal = securityContext.getPrincipal();
boolean checkAuthorities = isSpringSecurityAuthentication(principal);
for (String role : this.authorizedRoles) {
if (securityContext.isUserInRole(role)) {
return true;
}
if (checkAuthorities) {
Authentication authentication = (Authentication) principal;
for (GrantedAuthority authority : authentication.getAuthorities()) {
String name = authority.getAuthority();
if (role.equals(name)) {
return true;
}
}
}
}
return false;
}
private boolean isSpringSecurityAuthentication(Principal principal) {
return ClassUtils.isPresent("org.springframework.security.core.Authentication", null)
&& (principal instanceof Authentication);
}
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/OrderedHealthAggregator.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2020 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.boot.actuate.health;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import org.springframework.util.Assert;
/**
* Default {@link HealthAggregator} implementation that aggregates {@link Health}
* instances and determines the final system state based on a simple ordered list.
* <p>
* If a different order is required or a new {@link Status} type will be used, the order
* can be set by calling {@link #setStatusOrder(List)}.
*
* @author Christian Dupuis
* @since 1.1.0
* @deprecated since 2.2.0 in favor of {@link SimpleStatusAggregator}
*/
@Deprecated
public class OrderedHealthAggregator extends AbstractHealthAggregator {
private List<String> statusOrder;
/**
* Create a new {@link OrderedHealthAggregator} instance.
*/
public OrderedHealthAggregator() {
setStatusOrder(Status.DOWN, Status.OUT_OF_SERVICE, Status.UP, Status.UNKNOWN);
}
/**
* Set the ordering of the status.
* @param statusOrder an ordered list of the status
*/
public void setStatusOrder(Status... statusOrder) {
String[] order = new String[statusOrder.length];
for (int i = 0; i < statusOrder.length; i++) {
order[i] = statusOrder[i].getCode();
}
setStatusOrder(Arrays.asList(order));
}
/**
* Set the ordering of the status.
* @param statusOrder an ordered list of the status codes
*/
public void setStatusOrder(List<String> statusOrder) {
Assert.notNull(statusOrder, "StatusOrder must not be null");
this.statusOrder = statusOrder;
}
@Override
protected Status aggregateStatus(List<Status> candidates) {
// Only sort those status instances that we know about
List<Status> filteredCandidates = new ArrayList<>();
for (Status candidate : candidates) {
if (this.statusOrder.contains(candidate.getCode())) {
filteredCandidates.add(candidate);
}
}
// If no status is given return UNKNOWN
if (filteredCandidates.isEmpty()) {
return Status.UNKNOWN;
}
// Sort given Status instances by configured order
filteredCandidates.sort(new StatusComparator(this.statusOrder));
return filteredCandidates.get(0);
}
/**
* {@link Comparator} used to order {@link Status}.
*/
private static class StatusComparator implements Comparator<Status> {
private final List<String> statusOrder;
StatusComparator(List<String> statusOrder) {
this.statusOrder = statusOrder;
}
@Override
public int compare(Status s1, Status s2) {
int i1 = this.statusOrder.indexOf(s1.getCode());
int i2 = this.statusOrder.indexOf(s2.getCode());
return (i1 < i2) ? -1 : (i1 != i2) ? 1 : s1.getCode().compareTo(s2.getCode());
}
}
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/ReactiveHealthContributor.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -31,7 +31,6 @@ import org.springframework.util.Assert;
*/
public interface ReactiveHealthContributor {
@SuppressWarnings("deprecation")
static ReactiveHealthContributor adapt(HealthContributor healthContributor) {
Assert.notNull(healthContributor, "HealthContributor must not be null");
if (healthContributor instanceof HealthIndicator) {
......
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/ReactiveHealthEndpointWebExtension.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -45,18 +45,6 @@ public class ReactiveHealthEndpointWebExtension
private static final String[] NO_PATH = {};
/**
* Create a new {@link ReactiveHealthEndpointWebExtension} instance.
* @param delegate the delegate health indicator
* @param responseMapper the response mapper
* @deprecated since 2.2.0 in favor of
* {@link #ReactiveHealthEndpointWebExtension(ReactiveHealthContributorRegistry, HealthEndpointGroups)}
*/
@Deprecated
public ReactiveHealthEndpointWebExtension(ReactiveHealthIndicator delegate,
HealthWebEndpointResponseMapper responseMapper) {
}
/**
* Create a new {@link ReactiveHealthEndpointWebExtension} instance.
* @param registry the health contributor registry
......
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/ReactiveHealthIndicatorRegistry.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.util.Map;
/**
* A registry of {@link ReactiveHealthIndicator ReactiveHealthIndicators}.
* <p>
* Implementations <strong>must</strong> be thread-safe.
*
* @author Andy Wilkinson
* @author Vedran Pavic
* @author Stephane Nicoll
* @since 2.1.0
* @see HealthIndicatorRegistry
* @deprecated since 2.2.0 in favor of a {@link ReactiveHealthContributorRegistry}
*/
@Deprecated
public interface ReactiveHealthIndicatorRegistry {
/**
* Registers the given {@link ReactiveHealthIndicator}, associating it with the given
* {@code name}.
* @param name the name of the indicator
* @param healthIndicator the indicator
* @throws IllegalStateException if an indicator with the given {@code name} is
* already registered.
*/
void register(String name, ReactiveHealthIndicator healthIndicator);
/**
* Unregisters the {@link ReactiveHealthIndicator} previously registered with the
* given {@code name}.
* @param name the name of the indicator
* @return the unregistered indicator, or {@code null} if no indicator was found in
* the registry for the given {@code name}.
*/
ReactiveHealthIndicator unregister(String name);
/**
* Returns the {@link ReactiveHealthIndicator} registered with the given {@code name}.
* @param name the name of the indicator
* @return the health indicator, or {@code null} if no indicator was registered with
* the given {@code name}.
*/
ReactiveHealthIndicator get(String name);
/**
* Returns a snapshot of the registered health indicators and their names. The
* contents of the map do not reflect subsequent changes to the registry.
* @return the snapshot of registered health indicators
*/
Map<String, ReactiveHealthIndicator> getAll();
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/ReactiveHealthIndicatorRegistryFactory.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.function.Function;
import org.springframework.util.Assert;
import org.springframework.util.ObjectUtils;
/**
* Factory to create a {@link HealthIndicatorRegistry}.
*
* @author Stephane Nicoll
* @since 2.1.0
* @deprecated since 2.2.0 in favor of {@link DefaultReactiveHealthIndicatorRegistry}
*/
@Deprecated
public class ReactiveHealthIndicatorRegistryFactory {
private final Function<String, String> healthIndicatorNameFactory;
public ReactiveHealthIndicatorRegistryFactory(Function<String, String> healthIndicatorNameFactory) {
this.healthIndicatorNameFactory = healthIndicatorNameFactory;
}
public ReactiveHealthIndicatorRegistryFactory() {
this(new HealthIndicatorNameFactory());
}
/**
* Create a {@link ReactiveHealthIndicatorRegistry} based on the specified health
* indicators. Each {@link HealthIndicator} are wrapped to a
* {@link HealthIndicatorReactiveAdapter}. If two instances share the same name, the
* reactive variant takes precedence.
* @param reactiveHealthIndicators the {@link ReactiveHealthIndicator} instances
* mapped by name
* @param healthIndicators the {@link HealthIndicator} instances mapped by name if
* any.
* @return a {@link ReactiveHealthIndicator} that delegates to the specified
* {@code reactiveHealthIndicators}.
*/
public ReactiveHealthIndicatorRegistry createReactiveHealthIndicatorRegistry(
Map<String, ReactiveHealthIndicator> reactiveHealthIndicators,
Map<String, HealthIndicator> healthIndicators) {
Assert.notNull(reactiveHealthIndicators, "ReactiveHealthIndicators must not be null");
return initialize(new DefaultReactiveHealthIndicatorRegistry(), reactiveHealthIndicators, healthIndicators);
}
protected <T extends ReactiveHealthIndicatorRegistry> T initialize(T registry,
Map<String, ReactiveHealthIndicator> reactiveHealthIndicators,
Map<String, HealthIndicator> healthIndicators) {
merge(reactiveHealthIndicators, healthIndicators).forEach((beanName, indicator) -> {
String name = this.healthIndicatorNameFactory.apply(beanName);
registry.register(name, indicator);
});
return registry;
}
private Map<String, ReactiveHealthIndicator> merge(Map<String, ReactiveHealthIndicator> reactiveHealthIndicators,
Map<String, HealthIndicator> healthIndicators) {
if (ObjectUtils.isEmpty(healthIndicators)) {
return reactiveHealthIndicators;
}
Map<String, ReactiveHealthIndicator> allIndicators = new LinkedHashMap<>(reactiveHealthIndicators);
healthIndicators.forEach((beanName, indicator) -> {
String name = this.healthIndicatorNameFactory.apply(beanName);
allIndicators.computeIfAbsent(name, (n) -> new HealthIndicatorReactiveAdapter(indicator));
});
return allIndicators;
}
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/ShowDetails.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
/**
* Options for showing details in responses from the {@link HealthEndpoint} web
* extensions.
*
* @author Andy Wilkinson
* @since 2.0.0
* @deprecated since 2.2.0 in favor of {@code HealthEndpointProperties.ShowDetails}
*/
@Deprecated
public enum ShowDetails {
/**
* Never show details in the response.
*/
NEVER,
/**
* Show details in the response when accessed by an authorized user.
*/
WHEN_AUTHORIZED,
/**
* Always show details in the response.
*/
ALWAYS
}
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/metrics/web/client/MetricsClientHttpRequestInterceptor.java
View file @ 33e414fc
......@@ -53,20 +53,6 @@ class MetricsClientHttpRequestInterceptor implements ClientHttpRequestIntercepto
private final AutoTimer autoTimer;
/**
* Create a new {@code MetricsClientHttpRequestInterceptor}.
* @param meterRegistry the registry to which metrics are recorded
* @param tagProvider provider for metrics tags
* @param metricName name of the metric to record
* @deprecated since 2.2.0 in favor of
* {@link #MetricsClientHttpRequestInterceptor(MeterRegistry, RestTemplateExchangeTagsProvider, String, AutoTimer)}
*/
@Deprecated
MetricsClientHttpRequestInterceptor(MeterRegistry meterRegistry, RestTemplateExchangeTagsProvider tagProvider,
String metricName) {
this(meterRegistry, tagProvider, metricName, AutoTimer.ENABLED);
}
/**
* Create a new {@code MetricsClientHttpRequestInterceptor}.
* @param meterRegistry the registry to which metrics are recorded
......
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/metrics/web/client/MetricsRestTemplateCustomizer.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -39,22 +39,6 @@ public class MetricsRestTemplateCustomizer implements RestTemplateCustomizer {
private final MetricsClientHttpRequestInterceptor interceptor;
/**
* Creates a new {@code MetricsRestTemplateInterceptor} that will record metrics using
* the given {@code meterRegistry} with tags provided by the given
* {@code tagProvider}.
* @param meterRegistry the meter registry
* @param tagProvider the tag provider
* @param metricName the name of the recorded metric
* @deprecated since 2.2.0 in favor of
* {@link #MetricsRestTemplateCustomizer(MeterRegistry, RestTemplateExchangeTagsProvider, String, AutoTimer)}
*/
@Deprecated
public MetricsRestTemplateCustomizer(MeterRegistry meterRegistry, RestTemplateExchangeTagsProvider tagProvider,
String metricName) {
this(meterRegistry, tagProvider, metricName, AutoTimer.ENABLED);
}
/**
* Creates a new {@code MetricsRestTemplateInterceptor}. When {@code autoTimeRequests}
* is set to {@code true}, the interceptor records metrics using the given
......
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/metrics/web/reactive/client/MetricsWebClientCustomizer.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -33,22 +33,6 @@ public class MetricsWebClientCustomizer implements WebClientCustomizer {
private final MetricsWebClientFilterFunction filterFunction;
/**
* Create a new {@code MetricsWebClientFilterFunction} that will record metrics using
* the given {@code meterRegistry} with tags provided by the given
* {@code tagProvider}.
* @param meterRegistry the meter registry
* @param tagProvider the tag provider
* @param metricName the name of the recorded metric
* @deprecated since 2.2.0 in favor of
* {@link #MetricsWebClientCustomizer(MeterRegistry, WebClientExchangeTagsProvider, String, AutoTimer)}
*/
@Deprecated
public MetricsWebClientCustomizer(MeterRegistry meterRegistry, WebClientExchangeTagsProvider tagProvider,
String metricName) {
this(meterRegistry, tagProvider, metricName, AutoTimer.ENABLED);
}
/**
* Create a new {@code MetricsWebClientFilterFunction} that will record metrics using
* the given {@code meterRegistry} with tags provided by the given
......
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/metrics/web/reactive/client/MetricsWebClientFilterFunction.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -50,20 +50,6 @@ public class MetricsWebClientFilterFunction implements ExchangeFilterFunction {
private final AutoTimer autoTimer;
/**
* Create a new {@code MetricsWebClientFilterFunction}.
* @param meterRegistry the registry to which metrics are recorded
* @param tagProvider provider for metrics tags
* @param metricName name of the metric to record
* @deprecated since 2.2.0 in favor of
* {@link #MetricsWebClientFilterFunction(MeterRegistry, WebClientExchangeTagsProvider, String, AutoTimer)}
*/
@Deprecated
public MetricsWebClientFilterFunction(MeterRegistry meterRegistry, WebClientExchangeTagsProvider tagProvider,
String metricName) {
this(meterRegistry, tagProvider, metricName, AutoTimer.ENABLED);
}
/**
* Create a new {@code MetricsWebClientFilterFunction}.
* @param meterRegistry the registry to which metrics are recorded
......
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/metrics/web/reactive/server/MetricsWebFilter.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -49,21 +49,6 @@ public class MetricsWebFilter implements WebFilter {
private final AutoTimer autoTimer;
/**
* Create a new {@code MetricsWebFilter}.
* @param registry the registry to which metrics are recorded
* @param tagsProvider provider for metrics tags
* @param metricName name of the metric to record
* @param autoTimeRequests if requests should be automatically timed
* @deprecated since 2.2.0 in favor of
* {@link #MetricsWebFilter(MeterRegistry, WebFluxTagsProvider, String, AutoTimer)}
*/
@Deprecated
public MetricsWebFilter(MeterRegistry registry, WebFluxTagsProvider tagsProvider, String metricName,
boolean autoTimeRequests) {
this(registry, tagsProvider, metricName, AutoTimer.ENABLED);
}
/**
* Create a new {@code MetricsWebFilter}.
* @param registry the registry to which metrics are recorded
......
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/metrics/web/servlet/WebMvcMetricsFilter.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -60,22 +60,6 @@ public class WebMvcMetricsFilter extends OncePerRequestFilter {
private final AutoTimer autoTimer;
/**
* Create a new {@link WebMvcMetricsFilter} instance.
* @param registry the meter registry
* @param tagsProvider the tags provider
* @param metricName the metric name
* @param autoTimeRequests if requests should be automatically timed
* @since 2.0.7
* @deprecated since 2.2.0 in favor of
* {@link #WebMvcMetricsFilter(MeterRegistry, WebMvcTagsProvider, String, AutoTimer)}
*/
@Deprecated
public WebMvcMetricsFilter(MeterRegistry registry, WebMvcTagsProvider tagsProvider, String metricName,
boolean autoTimeRequests) {
this(registry, tagsProvider, metricName, AutoTimer.ENABLED);
}
/**
* Create a new {@link WebMvcMetricsFilter} instance.
* @param registry the meter registry
......
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/elasticsearch/ElasticsearchHealthIndicatorTests.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.elasticsearch;
import java.util.Map;
import org.elasticsearch.ElasticsearchException;
import org.elasticsearch.ElasticsearchTimeoutException;
import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequest;
import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse;
import org.elasticsearch.action.support.PlainActionFuture;
import org.elasticsearch.client.AdminClient;
import org.elasticsearch.client.Client;
import org.elasticsearch.client.ClusterAdminClient;
import org.elasticsearch.cluster.ClusterState;
import org.elasticsearch.cluster.block.ClusterBlocks;
import org.elasticsearch.cluster.health.ClusterHealthStatus;
import org.elasticsearch.cluster.node.DiscoveryNodes;
import org.elasticsearch.cluster.routing.RoutingTable;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.Status;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
/**
* Test for {@link ElasticsearchHealthIndicator}.
*
* @author Andy Wilkinson
*/
@Deprecated
class ElasticsearchHealthIndicatorTests {
@Mock
private Client client;
@Mock
private AdminClient admin;
@Mock
private ClusterAdminClient cluster;
private ElasticsearchHealthIndicator indicator;
@BeforeEach
void setUp() {
MockitoAnnotations.initMocks(this);
given(this.client.admin()).willReturn(this.admin);
given(this.admin.cluster()).willReturn(this.cluster);
this.indicator = new ElasticsearchHealthIndicator(this.client, 100L);
}
@Test
void defaultConfigurationQueriesAllIndicesWith100msTimeout() {
TestActionFuture responseFuture = new TestActionFuture();
responseFuture.onResponse(new StubClusterHealthResponse());
ArgumentCaptor<ClusterHealthRequest> requestCaptor = ArgumentCaptor.forClass(ClusterHealthRequest.class);
given(this.cluster.health(requestCaptor.capture())).willReturn(responseFuture);
Health health = this.indicator.health();
assertThat(responseFuture.getTimeout).isEqualTo(100L);
assertThat(requestCaptor.getValue().indices()).contains("_all");
assertThat(health.getStatus()).isEqualTo(Status.UP);
}
@Test
void certainIndices() {
this.indicator = new ElasticsearchHealthIndicator(this.client, 100L, "test-index-1", "test-index-2");
PlainActionFuture<ClusterHealthResponse> responseFuture = new PlainActionFuture<>();
responseFuture.onResponse(new StubClusterHealthResponse());
ArgumentCaptor<ClusterHealthRequest> requestCaptor = ArgumentCaptor.forClass(ClusterHealthRequest.class);
given(this.cluster.health(requestCaptor.capture())).willReturn(responseFuture);
Health health = this.indicator.health();
assertThat(requestCaptor.getValue().indices()).contains("test-index-1", "test-index-2");
assertThat(health.getStatus()).isEqualTo(Status.UP);
}
@Test
void customTimeout() {
this.indicator = new ElasticsearchHealthIndicator(this.client, 1000L);
TestActionFuture responseFuture = new TestActionFuture();
responseFuture.onResponse(new StubClusterHealthResponse());
ArgumentCaptor<ClusterHealthRequest> requestCaptor = ArgumentCaptor.forClass(ClusterHealthRequest.class);
given(this.cluster.health(requestCaptor.capture())).willReturn(responseFuture);
this.indicator.health();
assertThat(responseFuture.getTimeout).isEqualTo(1000L);
}
@Test
void healthDetails() {
PlainActionFuture<ClusterHealthResponse> responseFuture = new PlainActionFuture<>();
responseFuture.onResponse(new StubClusterHealthResponse());
given(this.cluster.health(any(ClusterHealthRequest.class))).willReturn(responseFuture);
Health health = this.indicator.health();
assertThat(health.getStatus()).isEqualTo(Status.UP);
Map<String, Object> details = health.getDetails();
assertDetail(details, "clusterName", "test-cluster");
assertDetail(details, "activeShards", 1);
assertDetail(details, "relocatingShards", 2);
assertDetail(details, "activePrimaryShards", 3);
assertDetail(details, "initializingShards", 4);
assertDetail(details, "unassignedShards", 5);
assertDetail(details, "numberOfNodes", 6);
assertDetail(details, "numberOfDataNodes", 7);
}
@Test
void redResponseMapsToDown() {
PlainActionFuture<ClusterHealthResponse> responseFuture = new PlainActionFuture<>();
responseFuture.onResponse(new StubClusterHealthResponse(ClusterHealthStatus.RED));
given(this.cluster.health(any(ClusterHealthRequest.class))).willReturn(responseFuture);
assertThat(this.indicator.health().getStatus()).isEqualTo(Status.DOWN);
}
@Test
void yellowResponseMapsToUp() {
PlainActionFuture<ClusterHealthResponse> responseFuture = new PlainActionFuture<>();
responseFuture.onResponse(new StubClusterHealthResponse(ClusterHealthStatus.YELLOW));
given(this.cluster.health(any(ClusterHealthRequest.class))).willReturn(responseFuture);
assertThat(this.indicator.health().getStatus()).isEqualTo(Status.UP);
}
@Test
void responseTimeout() {
PlainActionFuture<ClusterHealthResponse> responseFuture = new PlainActionFuture<>();
given(this.cluster.health(any(ClusterHealthRequest.class))).willReturn(responseFuture);
Health health = this.indicator.health();
assertThat(health.getStatus()).isEqualTo(Status.DOWN);
assertThat((String) health.getDetails().get("error")).contains(ElasticsearchTimeoutException.class.getName());
}
@SuppressWarnings("unchecked")
private <T> void assertDetail(Map<String, Object> details, String detail, T value) {
assertThat((T) details.get(detail)).isEqualTo(value);
}
private static final class StubClusterHealthResponse extends ClusterHealthResponse {
private final ClusterHealthStatus status;
private StubClusterHealthResponse() {
this(ClusterHealthStatus.GREEN);
}
private StubClusterHealthResponse(ClusterHealthStatus status) {
super("test-cluster", new String[0], new ClusterState(null, 0, null, null, RoutingTable.builder().build(),
DiscoveryNodes.builder().build(), ClusterBlocks.builder().build(), null, 1, false));
this.status = status;
}
@Override
public int getActiveShards() {
return 1;
}
@Override
public int getRelocatingShards() {
return 2;
}
@Override
public int getActivePrimaryShards() {
return 3;
}
@Override
public int getInitializingShards() {
return 4;
}
@Override
public int getUnassignedShards() {
return 5;
}
@Override
public int getNumberOfNodes() {
return 6;
}
@Override
public int getNumberOfDataNodes() {
return 7;
}
@Override
public ClusterHealthStatus getStatus() {
return this.status;
}
}
static class TestActionFuture extends PlainActionFuture<ClusterHealthResponse> {
private long getTimeout = -1L;
@Override
public ClusterHealthResponse actionGet(long timeoutMillis) throws ElasticsearchException {
this.getTimeout = timeoutMillis;
return super.actionGet(timeoutMillis);
}
}
}
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/health/ApplicationHealthIndicatorTests.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link ApplicationHealthIndicator}.
*
* @author Phillip Webb
*/
@Deprecated
class ApplicationHealthIndicatorTests {
@Test
void indicatesUp() {
ApplicationHealthIndicator healthIndicator = new ApplicationHealthIndicator();
assertThat(healthIndicator.health().getStatus()).isEqualTo(Status.UP);
}
}
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/health/CompositeHealthIndicatorTests.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
/**
* Tests for {@link CompositeHealthIndicator}
*
* @author Tyler J. Frederick
* @author Phillip Webb
* @author Christian Dupuis
*/
@Deprecated
class CompositeHealthIndicatorTests {
private HealthAggregator healthAggregator;
@Mock
private HealthIndicator one;
@Mock
private HealthIndicator two;
@BeforeEach
void setup() {
MockitoAnnotations.initMocks(this);
given(this.one.health()).willReturn(new Health.Builder().unknown().withDetail("1", "1").build());
given(this.two.health()).willReturn(new Health.Builder().unknown().withDetail("2", "2").build());
this.healthAggregator = new OrderedHealthAggregator();
}
@Test
void createWithIndicators() {
Map<String, HealthIndicator> indicators = new HashMap<>();
indicators.put("one", this.one);
indicators.put("two", this.two);
CompositeHealthIndicator composite = new CompositeHealthIndicator(this.healthAggregator, indicators);
Health result = composite.health();
assertThat(result.getDetails()).hasSize(2);
assertThat(result.getDetails()).containsEntry("one",
new Health.Builder().unknown().withDetail("1", "1").build());
assertThat(result.getDetails()).containsEntry("two",
new Health.Builder().unknown().withDetail("2", "2").build());
}
@Test
void testSerialization() throws Exception {
Map<String, HealthIndicator> indicators = new LinkedHashMap<>();
indicators.put("db1", this.one);
indicators.put("db2", this.two);
CompositeHealthIndicator innerComposite = new CompositeHealthIndicator(this.healthAggregator, indicators);
CompositeHealthIndicator composite = new CompositeHealthIndicator(this.healthAggregator,
Collections.singletonMap("db", innerComposite));
Health result = composite.health();
ObjectMapper mapper = new ObjectMapper();
assertThat(mapper.writeValueAsString(result))
.isEqualTo("{\"status\":\"UNKNOWN\",\"details\":{\"db\":{\"status\":\"UNKNOWN\""
+ ",\"details\":{\"db1\":{\"status\":\"UNKNOWN\",\"details\""
+ ":{\"1\":\"1\"}},\"db2\":{\"status\":\"UNKNOWN\",\"details\":{\"2\":\"2\"}}}}}}");
}
}
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/health/CompositeReactiveHealthIndicatorTests.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.time.Duration;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import org.junit.jupiter.api.Test;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link CompositeReactiveHealthIndicator}.
*
* @author Stephane Nicoll
*/
@Deprecated
class CompositeReactiveHealthIndicatorTests {
private static final Health UNKNOWN_HEALTH = Health.unknown().withDetail("detail", "value").build();
private static final Health HEALTHY = Health.up().build();
private OrderedHealthAggregator healthAggregator = new OrderedHealthAggregator();
@Test
void singleIndicator() {
CompositeReactiveHealthIndicator indicator = new CompositeReactiveHealthIndicator(this.healthAggregator,
new DefaultReactiveHealthIndicatorRegistry(Collections.singletonMap("test", () -> Mono.just(HEALTHY))));
StepVerifier.create(indicator.health()).consumeNextWith((h) -> {
assertThat(h.getStatus()).isEqualTo(Status.UP);
assertThat(h.getDetails()).containsOnlyKeys("test");
assertThat(h.getDetails().get("test")).isEqualTo(HEALTHY);
}).verifyComplete();
}
@Test
void longHealth() {
Map<String, ReactiveHealthIndicator> indicators = new HashMap<>();
for (int i = 0; i < 50; i++) {
indicators.put("test" + i, new TimeoutHealth(10000, Status.UP));
}
CompositeReactiveHealthIndicator indicator = new CompositeReactiveHealthIndicator(this.healthAggregator,
new DefaultReactiveHealthIndicatorRegistry(indicators));
StepVerifier.withVirtualTime(indicator::health).expectSubscription().thenAwait(Duration.ofMillis(10000))
.consumeNextWith((h) -> {
assertThat(h.getStatus()).isEqualTo(Status.UP);
assertThat(h.getDetails()).hasSize(50);
}).verifyComplete();
}
@Test
void timeoutReachedUsesFallback() {
Map<String, ReactiveHealthIndicator> indicators = new HashMap<>();
indicators.put("slow", new TimeoutHealth(10000, Status.UP));
indicators.put("fast", new TimeoutHealth(10, Status.UP));
CompositeReactiveHealthIndicator indicator = new CompositeReactiveHealthIndicator(this.healthAggregator,
new DefaultReactiveHealthIndicatorRegistry(indicators)).timeoutStrategy(100, UNKNOWN_HEALTH);
StepVerifier.create(indicator.health()).consumeNextWith((h) -> {
assertThat(h.getStatus()).isEqualTo(Status.UP);
assertThat(h.getDetails()).containsOnlyKeys("slow", "fast");
assertThat(h.getDetails().get("slow")).isEqualTo(UNKNOWN_HEALTH);
assertThat(h.getDetails().get("fast")).isEqualTo(HEALTHY);
}).verifyComplete();
}
@Test
void timeoutNotReached() {
Map<String, ReactiveHealthIndicator> indicators = new HashMap<>();
indicators.put("slow", new TimeoutHealth(10000, Status.UP));
indicators.put("fast", new TimeoutHealth(10, Status.UP));
CompositeReactiveHealthIndicator indicator = new CompositeReactiveHealthIndicator(this.healthAggregator,
new DefaultReactiveHealthIndicatorRegistry(indicators)).timeoutStrategy(20000, null);
StepVerifier.withVirtualTime(indicator::health).expectSubscription().thenAwait(Duration.ofMillis(10000))
.consumeNextWith((h) -> {
assertThat(h.getStatus()).isEqualTo(Status.UP);
assertThat(h.getDetails()).containsOnlyKeys("slow", "fast");
assertThat(h.getDetails().get("slow")).isEqualTo(HEALTHY);
assertThat(h.getDetails().get("fast")).isEqualTo(HEALTHY);
}).verifyComplete();
}
static class TimeoutHealth implements ReactiveHealthIndicator {
private final long timeout;
private final Status status;
TimeoutHealth(long timeout, Status status) {
this.timeout = timeout;
this.status = status;
}
@Override
public Mono<Health> health() {
return Mono.delay(Duration.ofMillis(this.timeout)).map((l) -> Health.status(this.status).build());
}
}
}
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/health/DefaultHealthIndicatorRegistryTests.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.util.Map;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
/**
* Tests for {@link DefaultHealthIndicatorRegistry}.
*
* @author Vedran Pavic
* @author Stephane Nicoll
*/
@Deprecated
class DefaultHealthIndicatorRegistryTests {
private HealthIndicator one = mock(HealthIndicator.class);
private HealthIndicator two = mock(HealthIndicator.class);
private DefaultHealthIndicatorRegistry registry;
@BeforeEach
void setUp() {
given(this.one.health()).willReturn(new Health.Builder().unknown().withDetail("1", "1").build());
given(this.two.health()).willReturn(new Health.Builder().unknown().withDetail("2", "2").build());
this.registry = new DefaultHealthIndicatorRegistry();
}
@Test
void register() {
this.registry.register("one", this.one);
this.registry.register("two", this.two);
assertThat(this.registry.getAll()).hasSize(2);
assertThat(this.registry.get("one")).isSameAs(this.one);
assertThat(this.registry.get("two")).isSameAs(this.two);
}
@Test
void registerAlreadyUsedName() {
this.registry.register("one", this.one);
assertThatIllegalStateException().isThrownBy(() -> this.registry.register("one", this.two))
.withMessageContaining("HealthIndicator with name 'one' already registered");
}
@Test
void unregister() {
this.registry.register("one", this.one);
this.registry.register("two", this.two);
assertThat(this.registry.getAll()).hasSize(2);
HealthIndicator two = this.registry.unregister("two");
assertThat(two).isSameAs(this.two);
assertThat(this.registry.getAll()).hasSize(1);
}
@Test
void unregisterUnknown() {
this.registry.register("one", this.one);
assertThat(this.registry.getAll()).hasSize(1);
HealthIndicator two = this.registry.unregister("two");
assertThat(two).isNull();
assertThat(this.registry.getAll()).hasSize(1);
}
@Test
void getAllIsASnapshot() {
this.registry.register("one", this.one);
Map<String, HealthIndicator> snapshot = this.registry.getAll();
assertThat(snapshot).containsOnlyKeys("one");
this.registry.register("two", this.two);
assertThat(snapshot).containsOnlyKeys("one");
}
@Test
void getAllIsImmutable() {
this.registry.register("one", this.one);
Map<String, HealthIndicator> snapshot = this.registry.getAll();
assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(snapshot::clear);
}
}
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/health/DefaultReactiveHealthIndicatorRegistryTests.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.util.Map;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import reactor.core.publisher.Mono;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
/**
* Tests for {@link DefaultReactiveHealthIndicatorRegistry}.
*
* @author Vedran Pavic
* @author Stephane Nicoll
*/
@Deprecated
class DefaultReactiveHealthIndicatorRegistryTests {
private ReactiveHealthIndicator one = mock(ReactiveHealthIndicator.class);
private ReactiveHealthIndicator two = mock(ReactiveHealthIndicator.class);
private DefaultReactiveHealthIndicatorRegistry registry;
@BeforeEach
void setUp() {
given(this.one.health()).willReturn(Mono.just(new Health.Builder().unknown().withDetail("1", "1").build()));
given(this.two.health()).willReturn(Mono.just(new Health.Builder().unknown().withDetail("2", "2").build()));
this.registry = new DefaultReactiveHealthIndicatorRegistry();
}
@Test
void register() {
this.registry.register("one", this.one);
this.registry.register("two", this.two);
assertThat(this.registry.getAll()).hasSize(2);
assertThat(this.registry.get("one")).isSameAs(this.one);
assertThat(this.registry.get("two")).isSameAs(this.two);
}
@Test
void registerAlreadyUsedName() {
this.registry.register("one", this.one);
assertThatIllegalStateException().isThrownBy(() -> this.registry.register("one", this.two))
.withMessageContaining("HealthIndicator with name 'one' already registered");
}
@Test
void unregister() {
this.registry.register("one", this.one);
this.registry.register("two", this.two);
assertThat(this.registry.getAll()).hasSize(2);
ReactiveHealthIndicator two = this.registry.unregister("two");
assertThat(two).isSameAs(this.two);
assertThat(this.registry.getAll()).hasSize(1);
}
@Test
void unregisterUnknown() {
this.registry.register("one", this.one);
assertThat(this.registry.getAll()).hasSize(1);
ReactiveHealthIndicator two = this.registry.unregister("two");
assertThat(two).isNull();
assertThat(this.registry.getAll()).hasSize(1);
}
@Test
void getAllIsASnapshot() {
this.registry.register("one", this.one);
Map<String, ReactiveHealthIndicator> snapshot = this.registry.getAll();
assertThat(snapshot).containsOnlyKeys("one");
this.registry.register("two", this.two);
assertThat(snapshot).containsOnlyKeys("one");
}
@Test
void getAllIsImmutable() {
this.registry.register("one", this.one);
Map<String, ReactiveHealthIndicator> snapshot = this.registry.getAll();
assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(snapshot::clear);
}
}
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/health/HealthEndpointTests.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -24,7 +24,6 @@ import org.junit.jupiter.api.Test;
import org.springframework.boot.actuate.health.HealthEndpointSupport.HealthResult;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.mockito.Mockito.mock;
/**
......@@ -35,15 +34,6 @@ import static org.mockito.Mockito.mock;
class HealthEndpointTests
extends HealthEndpointSupportTests<HealthContributorRegistry, HealthContributor, HealthComponent> {
@Test
@SuppressWarnings("deprecation")
void createWhenUsingDeprecatedConstructorThrowsException() {
HealthIndicator healthIndicator = mock(HealthIndicator.class);
assertThatIllegalStateException().isThrownBy(() -> new HealthEndpoint(healthIndicator))
.withMessage("Unable to create class org.springframework.boot.actuate.health.HealthEndpoint "
+ "using deprecated constructor");
}
@Test
void healthReturnsSystemHealth() {
this.registry.registerContributor("test", createContributor(this.up));
......
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/health/HealthEndpointWebExtensionTests.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -27,7 +27,6 @@ import org.springframework.boot.actuate.endpoint.web.WebEndpointResponse;
import org.springframework.boot.actuate.health.HealthEndpointSupport.HealthResult;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.mockito.Mockito.mock;
/**
......@@ -38,16 +37,6 @@ import static org.mockito.Mockito.mock;
class HealthEndpointWebExtensionTests
extends HealthEndpointSupportTests<HealthContributorRegistry, HealthContributor, HealthComponent> {
@Test
@SuppressWarnings("deprecation")
void createWhenUsingDeprecatedConstructorThrowsException() {
HealthEndpoint delegate = mock(HealthEndpoint.class);
HealthWebEndpointResponseMapper responseMapper = mock(HealthWebEndpointResponseMapper.class);
assertThatIllegalStateException().isThrownBy(() -> new HealthEndpointWebExtension(delegate, responseMapper))
.withMessage("Unable to create class org.springframework.boot.actuate."
+ "health.HealthEndpointWebExtension using deprecated constructor");
}
@Test
void healthReturnsSystemHealth() {
this.registry.registerContributor("test", createContributor(this.up));
......
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/health/HealthIndicatorReactiveAdapterTests.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -29,7 +29,6 @@ import static org.mockito.Mockito.mock;
*
* @author Stephane Nicoll
*/
@SuppressWarnings("deprecation")
class HealthIndicatorReactiveAdapterTests {
@Test
......
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/health/HealthWebEndpointResponseMapperTests.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.security.Principal;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.function.Supplier;
import org.junit.jupiter.api.Test;
import org.mockito.stubbing.Answer;
import org.springframework.boot.actuate.endpoint.SecurityContext;
import org.springframework.boot.actuate.endpoint.web.WebEndpointResponse;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
/**
* Tests for {@link HealthWebEndpointResponseMapper}.
*
* @author Stephane Nicoll
*/
@Deprecated
class HealthWebEndpointResponseMapperTests {
private final HealthStatusHttpMapper statusHttpMapper = new HealthStatusHttpMapper();
private Set<String> authorizedRoles = Collections.singleton("ACTUATOR");
@Test
void mapDetailsWithDisableDetailsDoesNotInvokeSupplier() {
HealthWebEndpointResponseMapper mapper = createMapper(ShowDetails.NEVER);
Supplier<Health> supplier = mockSupplier();
SecurityContext securityContext = mock(SecurityContext.class);
WebEndpointResponse<Health> response = mapper.mapDetails(supplier, securityContext);
assertThat(response.getStatus()).isEqualTo(HttpStatus.NOT_FOUND.value());
verifyNoInteractions(supplier);
verifyNoInteractions(securityContext);
}
@Test
void mapDetailsWithUnauthorizedUserDoesNotInvokeSupplier() {
HealthWebEndpointResponseMapper mapper = createMapper(ShowDetails.WHEN_AUTHORIZED);
Supplier<Health> supplier = mockSupplier();
SecurityContext securityContext = mockSecurityContext("USER");
WebEndpointResponse<Health> response = mapper.mapDetails(supplier, securityContext);
assertThat(response.getStatus()).isEqualTo(HttpStatus.NOT_FOUND.value());
assertThat(response.getBody()).isNull();
verifyNoInteractions(supplier);
verify(securityContext).isUserInRole("ACTUATOR");
}
@Test
void mapDetailsWithAuthorizedUserInvokesSupplier() {
HealthWebEndpointResponseMapper mapper = createMapper(ShowDetails.WHEN_AUTHORIZED);
Supplier<Health> supplier = mockSupplier();
given(supplier.get()).willReturn(Health.down().build());
SecurityContext securityContext = mockSecurityContext("ACTUATOR");
WebEndpointResponse<Health> response = mapper.mapDetails(supplier, securityContext);
assertThat(response.getStatus()).isEqualTo(HttpStatus.SERVICE_UNAVAILABLE.value());
assertThat(response.getBody().getStatus()).isEqualTo(Status.DOWN);
verify(supplier).get();
verify(securityContext).isUserInRole("ACTUATOR");
}
@Test
void mapDetailsWithRightAuthoritiesInvokesSupplier() {
HealthWebEndpointResponseMapper mapper = createMapper(ShowDetails.WHEN_AUTHORIZED);
Supplier<Health> supplier = mockSupplier();
given(supplier.get()).willReturn(Health.down().build());
SecurityContext securityContext = getSecurityContext("ACTUATOR");
WebEndpointResponse<Health> response = mapper.mapDetails(supplier, securityContext);
assertThat(response.getStatus()).isEqualTo(HttpStatus.SERVICE_UNAVAILABLE.value());
assertThat(response.getBody().getStatus()).isEqualTo(Status.DOWN);
verify(supplier).get();
}
@Test
void mapDetailsWithOtherAuthoritiesShouldNotInvokeSupplier() {
HealthWebEndpointResponseMapper mapper = createMapper(ShowDetails.WHEN_AUTHORIZED);
Supplier<Health> supplier = mockSupplier();
given(supplier.get()).willReturn(Health.down().build());
SecurityContext securityContext = getSecurityContext("OTHER");
WebEndpointResponse<Health> response = mapper.mapDetails(supplier, securityContext);
assertThat(response.getStatus()).isEqualTo(HttpStatus.NOT_FOUND.value());
assertThat(response.getBody()).isNull();
verifyNoInteractions(supplier);
}
private SecurityContext getSecurityContext(String other) {
SecurityContext securityContext = mock(SecurityContext.class);
Authentication principal = mock(Authentication.class);
given(securityContext.getPrincipal()).willReturn(principal);
given(principal.getAuthorities())
.willAnswer((invocation) -> Collections.singleton(new SimpleGrantedAuthority(other)));
return securityContext;
}
@Test
void mapDetailsWithUnavailableHealth() {
HealthWebEndpointResponseMapper mapper = createMapper(ShowDetails.ALWAYS);
Supplier<Health> supplier = mockSupplier();
SecurityContext securityContext = mock(SecurityContext.class);
WebEndpointResponse<Health> response = mapper.mapDetails(supplier, securityContext);
assertThat(response.getStatus()).isEqualTo(HttpStatus.NOT_FOUND.value());
assertThat(response.getBody()).isNull();
verify(supplier).get();
verifyNoInteractions(securityContext);
}
@SuppressWarnings("unchecked")
private Supplier<Health> mockSupplier() {
return mock(Supplier.class);
}
private SecurityContext mockSecurityContext(String... roles) {
List<String> associatedRoles = Arrays.asList(roles);
SecurityContext securityContext = mock(SecurityContext.class);
given(securityContext.getPrincipal()).willReturn(mock(Principal.class));
given(securityContext.isUserInRole(anyString())).will((Answer<Boolean>) (invocation) -> {
String expectedRole = invocation.getArgument(0);
return associatedRoles.contains(expectedRole);
});
return securityContext;
}
private HealthWebEndpointResponseMapper createMapper(ShowDetails showDetails) {
return new HealthWebEndpointResponseMapper(this.statusHttpMapper, showDetails, this.authorizedRoles);
}
}
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/health/OrderedHealthAggregatorTests.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link OrderedHealthAggregator}.
*
* @author Christian Dupuis
*/
@Deprecated
class OrderedHealthAggregatorTests {
private OrderedHealthAggregator healthAggregator;
@BeforeEach
void setup() {
this.healthAggregator = new OrderedHealthAggregator();
}
@Test
void defaultOrder() {
Map<String, Health> healths = new HashMap<>();
healths.put("h1", new Health.Builder().status(Status.DOWN).build());
healths.put("h2", new Health.Builder().status(Status.UP).build());
healths.put("h3", new Health.Builder().status(Status.UNKNOWN).build());
healths.put("h4", new Health.Builder().status(Status.OUT_OF_SERVICE).build());
assertThat(this.healthAggregator.aggregate(healths).getStatus()).isEqualTo(Status.DOWN);
}
@Test
void customOrder() {
this.healthAggregator.setStatusOrder(Status.UNKNOWN, Status.UP, Status.OUT_OF_SERVICE, Status.DOWN);
Map<String, Health> healths = new HashMap<>();
healths.put("h1", new Health.Builder().status(Status.DOWN).build());
healths.put("h2", new Health.Builder().status(Status.UP).build());
healths.put("h3", new Health.Builder().status(Status.UNKNOWN).build());
healths.put("h4", new Health.Builder().status(Status.OUT_OF_SERVICE).build());
assertThat(this.healthAggregator.aggregate(healths).getStatus()).isEqualTo(Status.UNKNOWN);
}
@Test
void defaultOrderWithCustomStatus() {
Map<String, Health> healths = new HashMap<>();
healths.put("h1", new Health.Builder().status(Status.DOWN).build());
healths.put("h2", new Health.Builder().status(Status.UP).build());
healths.put("h3", new Health.Builder().status(Status.UNKNOWN).build());
healths.put("h4", new Health.Builder().status(Status.OUT_OF_SERVICE).build());
healths.put("h5", new Health.Builder().status(new Status("CUSTOM")).build());
assertThat(this.healthAggregator.aggregate(healths).getStatus()).isEqualTo(Status.DOWN);
}
@Test
void customOrderWithCustomStatus() {
this.healthAggregator.setStatusOrder(Arrays.asList("DOWN", "OUT_OF_SERVICE", "UP", "UNKNOWN", "CUSTOM"));
Map<String, Health> healths = new HashMap<>();
healths.put("h1", new Health.Builder().status(Status.DOWN).build());
healths.put("h2", new Health.Builder().status(Status.UP).build());
healths.put("h3", new Health.Builder().status(Status.UNKNOWN).build());
healths.put("h4", new Health.Builder().status(Status.OUT_OF_SERVICE).build());
healths.put("h5", new Health.Builder().status(new Status("CUSTOM")).build());
assertThat(this.healthAggregator.aggregate(healths).getStatus()).isEqualTo(Status.DOWN);
}
}
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/health/ReactiveHealthContributorTests.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -39,7 +39,6 @@ class ReactiveHealthContributorTests {
}
@Test
@SuppressWarnings("deprecation")
void adaptWhenHealthIndicatorReturnsHealthIndicatorReactiveAdapter() {
HealthIndicator indicator = () -> Health.outOfService().build();
ReactiveHealthContributor adapted = ReactiveHealthContributor.adapt(indicator);
......
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/health/ReactiveHealthEndpointWebExtensionTests.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -28,7 +28,6 @@ import org.springframework.boot.actuate.endpoint.web.WebEndpointResponse;
import org.springframework.boot.actuate.health.HealthEndpointSupport.HealthResult;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.mockito.Mockito.mock;
/**
......@@ -39,17 +38,6 @@ import static org.mockito.Mockito.mock;
class ReactiveHealthEndpointWebExtensionTests extends
HealthEndpointSupportTests<ReactiveHealthContributorRegistry, ReactiveHealthContributor, Mono<? extends HealthComponent>> {
@Test
@SuppressWarnings("deprecation")
void createWhenUsingDeprecatedConstructorThrowsException() {
ReactiveHealthIndicator delegate = mock(ReactiveHealthIndicator.class);
HealthWebEndpointResponseMapper responseMapper = mock(HealthWebEndpointResponseMapper.class);
assertThatIllegalStateException()
.isThrownBy(() -> new ReactiveHealthEndpointWebExtension(delegate, responseMapper)).withMessage(
"Unable to create class org.springframework.boot.actuate.health.ReactiveHealthEndpointWebExtension "
+ "using deprecated constructor");
}
@Test
void healthReturnsSystemHealth() {
this.registry.registerContributor("test", createContributor(this.up));
......
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/health/ReactiveHealthIndicatorRegistryFactoryTests.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.actuate.health;
import java.util.Collections;
import org.junit.jupiter.api.Test;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link ReactiveHealthIndicatorRegistryFactory}.
*
* @author Stephane Nicoll
*/
@Deprecated
class ReactiveHealthIndicatorRegistryFactoryTests {
private static final Health UP = new Health.Builder().status(Status.UP).build();
private static final Health DOWN = new Health.Builder().status(Status.DOWN).build();
private final ReactiveHealthIndicatorRegistryFactory factory = new ReactiveHealthIndicatorRegistryFactory();
@Test
void defaultHealthIndicatorNameFactory() {
ReactiveHealthIndicatorRegistry registry = this.factory.createReactiveHealthIndicatorRegistry(
Collections.singletonMap("myHealthIndicator", () -> Mono.just(UP)), null);
assertThat(registry.getAll()).containsOnlyKeys("my");
}
@Test
void healthIndicatorIsAdapted() {
ReactiveHealthIndicatorRegistry registry = this.factory.createReactiveHealthIndicatorRegistry(
Collections.singletonMap("test", () -> Mono.just(UP)), Collections.singletonMap("regular", () -> DOWN));
assertThat(registry.getAll()).containsOnlyKeys("test", "regular");
StepVerifier.create(registry.get("regular").health()).consumeNextWith((h) -> {
assertThat(h.getStatus()).isEqualTo(Status.DOWN);
assertThat(h.getDetails()).isEmpty();
}).verifyComplete();
}
}
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/logging/LogFileWebEndpointTests.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -74,16 +74,6 @@ class LogFileWebEndpointTests {
assertThat(contentOf(resource.getFile())).isEqualTo("--TEST--");
}
@Test
@Deprecated
void resourceResponseWithLogFileAndDeprecatedProperty() throws Exception {
this.environment.setProperty("logging.file", this.logFile.getAbsolutePath());
LogFileWebEndpoint endpoint = new LogFileWebEndpoint(LogFile.get(this.environment), null);
Resource resource = endpoint.logFile();
assertThat(resource).isNotNull();
assertThat(contentOf(resource.getFile())).isEqualTo("--TEST--");
}
@Test
void resourceResponseWithExternalLogFile() throws Exception {
LogFileWebEndpoint endpoint = new LogFileWebEndpoint(null, this.logFile);
......
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/logging/LogFileWebEndpointWebIntegrationTests.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -74,7 +74,7 @@ class LogFileWebEndpointWebIntegrationTests {
File logFile = new File(tempFile, "test.log");
FileCopyUtils.copy("--TEST--".getBytes(), logFile);
MockEnvironment environment = new MockEnvironment();
environment.setProperty("logging.file", logFile.getAbsolutePath());
environment.setProperty("logging.file.name", logFile.getAbsolutePath());
return new LogFileWebEndpoint(LogFile.get(environment), null);
}
......
spring-boot-project/spring-boot-autoconfigure/build.gradle
View file @ 33e414fc
......@@ -21,7 +21,6 @@ dependencies {
optional 'com.fasterxml.jackson.core:jackson-databind'
optional 'com.fasterxml.jackson.dataformat:jackson-dataformat-cbor'
optional 'com.fasterxml.jackson.dataformat:jackson-dataformat-xml'
optional 'com.fasterxml.jackson.datatype:jackson-datatype-joda'
optional 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310'
optional 'com.fasterxml.jackson.module:jackson-module-parameter-names'
optional 'com.google.code.gson:gson'
......
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitProperties.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -25,7 +25,6 @@ import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory.CacheMode;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory.ConfirmType;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.DeprecatedConfigurationProperty;
import org.springframework.boot.convert.DurationUnit;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
......@@ -289,17 +288,6 @@ public class RabbitProperties {
this.requestedChannelMax = requestedChannelMax;
}
@DeprecatedConfigurationProperty(reason = "replaced to support additional confirm types",
replacement = "spring.rabbitmq.publisher-confirm-type")
public boolean isPublisherConfirms() {
return ConfirmType.CORRELATED.equals(this.publisherConfirmType);
}
@Deprecated
public void setPublisherConfirms(boolean publisherConfirms) {
this.publisherConfirmType = (publisherConfirms) ? ConfirmType.CORRELATED : ConfirmType.NONE;
}
public boolean isPublisherReturns() {
return this.publisherReturns;
}
......@@ -732,28 +720,6 @@ public class RabbitProperties {
this.maxConcurrency = maxConcurrency;
}
/**
* Return the number of messages processed in one transaction.
* @return the number of messages
* @deprecated since 2.2.0 in favor of {@link SimpleContainer#getBatchSize()}
*/
@DeprecatedConfigurationProperty(replacement = "spring.rabbitmq.listener.simple.batch-size")
@Deprecated
public Integer getTransactionSize() {
return getBatchSize();
}
/**
* Set the number of messages processed in one transaction.
* @param transactionSize the number of messages
* @deprecated since 2.2.0 in favor of
* {@link SimpleContainer#setBatchSize(Integer)}
*/
@Deprecated
public void setTransactionSize(Integer transactionSize) {
setBatchSize(transactionSize);
}
public Integer getBatchSize() {
return this.batchSize;
}
......
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/batch/JobLauncherCommandLineRunner.java deleted 100644 → 0
View file @ 421c464d
/*
* Copyright 2012-2019 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.boot.autoconfigure.batch;
import org.springframework.batch.core.explore.JobExplorer;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.boot.ApplicationRunner;
/**
* {@link ApplicationRunner} to {@link JobLauncher launch} Spring Batch jobs. Runs all
* jobs in the surrounding context by default. Can also be used to launch a specific job
* by providing a jobName
*
* @author Dave Syer
* @author Jean-Pierre Bergamin
* @author Mahmoud Ben Hassine
* @since 1.0.0
* @deprecated since 2.2.0 in favor of {@link JobLauncherApplicationRunner}
*/
@Deprecated
public class JobLauncherCommandLineRunner extends JobLauncherApplicationRunner {
/**
* Create a new {@link JobLauncherCommandLineRunner}.
* @param jobLauncher to launch jobs
* @param jobExplorer to check the job repository for previous executions
* @param jobRepository to check if a job instance exists with the given parameters
* when running a job
*/
public JobLauncherCommandLineRunner(JobLauncher jobLauncher, JobExplorer jobExplorer, JobRepository jobRepository) {
super(jobLauncher, jobExplorer, jobRepository);
}
}
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jackson/JacksonAutoConfiguration.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -34,14 +34,7 @@ import com.fasterxml.jackson.databind.Module;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.datatype.joda.cfg.JacksonJodaDateFormat;
import com.fasterxml.jackson.datatype.joda.ser.DateTimeSerializer;
import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.BeanFactoryUtils;
......@@ -110,49 +103,6 @@ public class JacksonAutoConfiguration {
}
@Deprecated
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ Jackson2ObjectMapperBuilder.class, DateTime.class, DateTimeSerializer.class,
JacksonJodaDateFormat.class })
static class JodaDateTimeJacksonConfiguration {
private static final Log logger = LogFactory.getLog(JodaDateTimeJacksonConfiguration.class);
@Bean
SimpleModule jodaDateTimeSerializationModule(JacksonProperties jacksonProperties) {
logger.warn("Auto-configuration of Jackson's Joda-Time integration is deprecated in favor of using "
+ "java.time (JSR-310).");
SimpleModule module = new SimpleModule();
JacksonJodaDateFormat jacksonJodaFormat = getJacksonJodaDateFormat(jacksonProperties);
if (jacksonJodaFormat != null) {
module.addSerializer(DateTime.class, new DateTimeSerializer(jacksonJodaFormat, 0));
}
return module;
}
private JacksonJodaDateFormat getJacksonJodaDateFormat(JacksonProperties jacksonProperties) {
if (jacksonProperties.getJodaDateTimeFormat() != null) {
return new JacksonJodaDateFormat(
DateTimeFormat.forPattern(jacksonProperties.getJodaDateTimeFormat()).withZoneUTC());
}
if (jacksonProperties.getDateFormat() != null) {
try {
return new JacksonJodaDateFormat(
DateTimeFormat.forPattern(jacksonProperties.getDateFormat()).withZoneUTC());
}
catch (IllegalArgumentException ex) {
if (logger.isWarnEnabled()) {
logger.warn("spring.jackson.date-format could not be used to "
+ "configure formatting of Joda's DateTime. You may want "
+ "to configure spring.jackson.joda-date-time-format as well.");
}
}
}
return null;
}
}
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(ParameterNamesModule.class)
static class ParameterNamesModuleConfiguration {
......
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jackson/JacksonProperties.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -31,7 +31,6 @@ import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.SerializationFeature;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.DeprecatedConfigurationProperty;
/**
* Configuration properties to configure Jackson.
......@@ -50,12 +49,6 @@ public class JacksonProperties {
*/
private String dateFormat;
/**
* Joda date time format string. If not configured, "date-format" is used as a
* fallback if it is configured with a format string.
*/
private String jodaDateTimeFormat;
/**
* One of the constants on Jackson's PropertyNamingStrategy. Can also be a
* fully-qualified class name of a PropertyNamingStrategy subclass.
......@@ -118,18 +111,6 @@ public class JacksonProperties {
this.dateFormat = dateFormat;
}
@Deprecated
@DeprecatedConfigurationProperty(replacement = "dateFormat",
reason = "Auto-configuration for Jackson's Joda-Time integration is "
+ "deprecated in favor of its Java 8 Time integration")
public String getJodaDateTimeFormat() {
return this.jodaDateTimeFormat;
}
public void setJodaDateTimeFormat(String jodaDataTimeFormat) {
this.jodaDateTimeFormat = jodaDataTimeFormat;
}
public String getPropertyNamingStrategy() {
return this.propertyNamingStrategy;
}
......
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/orm/jpa/JpaProperties.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -21,8 +21,6 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.orm.jpa.vendor.Database;
......@@ -129,20 +127,4 @@ public class JpaProperties {
this.openInView = openInView;
}
/**
* Determine the {@link Database} to use based on this configuration and the primary
* {@link DataSource}.
* @param dataSource the auto-configured data source
* @return {@code Database}
* @deprecated since 2.2.0 in favor of letting the JPA container detect the database
* to use.
*/
@Deprecated
public Database determineDatabase(DataSource dataSource) {
if (this.database != null) {
return this.database;
}
return DatabaseLookup.getDatabase(dataSource);
}
}
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/web/format/WebConversionService.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -21,11 +21,9 @@ import java.time.format.ResolverStyle;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.joda.time.format.DateTimeFormatterBuilder;
import org.springframework.format.datetime.DateFormatter;
import org.springframework.format.datetime.DateFormatterRegistrar;
import org.springframework.format.datetime.joda.JodaTimeFormatterRegistrar;
import org.springframework.format.datetime.standard.DateTimeFormatterRegistrar;
import org.springframework.format.number.NumberFormatAnnotationFormatterFactory;
import org.springframework.format.number.money.CurrencyUnitFormatter;
......@@ -51,10 +49,6 @@ public class WebConversionService extends DefaultFormattingConversionService {
private static final boolean JSR_354_PRESENT = ClassUtils.isPresent("javax.money.MonetaryAmount",
WebConversionService.class.getClassLoader());
@Deprecated
private static final boolean JODA_TIME_PRESENT = ClassUtils.isPresent("org.joda.time.LocalDate",
WebConversionService.class.getClassLoader());
private static final Log logger = LogFactory.getLog(WebConversionService.class);
private final String dateFormat;
......@@ -83,9 +77,6 @@ public class WebConversionService extends DefaultFormattingConversionService {
addFormatterForFieldAnnotation(new Jsr354NumberFormatAnnotationFormatterFactory());
}
registerJsr310();
if (JODA_TIME_PRESENT) {
registerJodaTime();
}
registerJavaDate();
}
......@@ -98,16 +89,6 @@ public class WebConversionService extends DefaultFormattingConversionService {
dateTime.registerFormatters(this);
}
@Deprecated
private void registerJodaTime() {
logger.warn("Auto-configuration of Joda-Time formatters is deprecated in favor of using java.time (JSR-310).");
JodaTimeFormatterRegistrar jodaTime = new JodaTimeFormatterRegistrar();
if (this.dateFormat != null) {
jodaTime.setDateFormatter(new DateTimeFormatterBuilder().appendPattern(this.dateFormat).toFormatter());
}
jodaTime.registerFormatters(this);
}
private void registerJavaDate() {
DateFormatterRegistrar dateFormatterRegistrar = new DateFormatterRegistrar();
if (this.dateFormat != null) {
......
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/amqp/RabbitAutoConfigurationTests.java
View file @ 33e414fc
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 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.
......@@ -201,17 +201,6 @@ class RabbitAutoConfigurationTests {
});
}
@Test
@Deprecated
void testConnectionFactoryPublisherConfirmTypeUsingDeprecatedProperty() {
this.contextRunner.withUserConfiguration(TestConfiguration.class)
.withPropertyValues("spring.rabbitmq.publisher-confirms=true").run((context) -> {
CachingConnectionFactory connectionFactory = context.getBean(CachingConnectionFactory.class);
assertThat(connectionFactory.isPublisherConfirms()).isTrue();
assertThat(connectionFactory.isSimplePublisherConfirms()).isFalse();
});
}
@Test
void testConnectionFactoryPublisherConfirmTypeCorrelated() {
this.contextRunner.withUserConfiguration(TestConfiguration.class)
......@@ -459,18 +448,6 @@ class RabbitAutoConfigurationTests {
});
}
@Test
@Deprecated
void testRabbitListenerContainerFactoryWithDeprecatedTransactionSizeStillWorks() {
this.contextRunner
.withUserConfiguration(MessageConvertersConfiguration.class, MessageRecoverersConfiguration.class)
.withPropertyValues("spring.rabbitmq.listener.simple.transactionSize:20").run((context) -> {
SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory = context
.getBean("rabbitListenerContainerFactory", SimpleRabbitListenerContainerFactory.class);
assertThat(rabbitListenerContainerFactory).hasFieldOrPropertyWithValue("batchSize", 20);
});
}
@Test
void testDirectRabbitListenerContainerFactoryWithCustomSettings() {
this.contextRunner
......
spring-boot-project/spring-boot-cli/src/test/java/org/springframework/boot/cli/GrabCommandIntegrationTests.java
View file @ 33e414fc
......@@ -61,7 +61,7 @@ class GrabCommandIntegrationTests {
System.setProperty("groovy.grape.report.downloads", "true");
// Use --autoconfigure=false to limit the amount of downloaded dependencies
String output = this.cli.grab("grab.groovy", "--autoconfigure=false");
assertThat(new File(this.cli.getTemp(), "repository/joda-time/joda-time")).isDirectory();
assertThat(new File(this.cli.getTemp(), "repository/com/fasterxml/jackson/core/jackson-core")).isDirectory();
assertThat(output).contains("Downloading: ");
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment