root
/
spring-boot
mirror of https://github.com/spring-projects/spring-boot.git
1
0
Fork 0
Code Issues Actions 15 Packages Projects Releases Wiki Activity

Polish "Mark Redis as down when cluster_state is fail" 

See gh-27300
This commit is contained in:
Andy Wilkinson 2021-07-13 14:36:39 +01:00
parent f31141de09
commit 49baacbc1c
5 changed files with 93 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealth.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2012-2020 the original author or authors. * Copyright 2012-2021 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -38,14 +38,15 @@ final class RedisHealth {
return builder.up(); return builder.up();
} }
static Builder info(Health.Builder builder, ClusterInfo clusterInfo) { static Builder fromClusterInfo(Health.Builder builder, ClusterInfo clusterInfo) {
builder.withDetail("cluster_size", clusterInfo.getClusterSize()); builder.withDetail("cluster_size", clusterInfo.getClusterSize());
builder.withDetail("slots_up", clusterInfo.getSlotsOk()); builder.withDetail("slots_up", clusterInfo.getSlotsOk());
builder.withDetail("slots_fail", clusterInfo.getSlotsFail()); builder.withDetail("slots_fail", clusterInfo.getSlotsFail());
if ("fail".equalsIgnoreCase(clusterInfo.getState())) { if ("fail".equalsIgnoreCase(clusterInfo.getState())) {
return builder.down(); return builder.down();
} else { }
else {
return builder.up(); return builder.up();
} }
} }

4
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealthIndicator.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2012-2020 the original author or authors. * Copyright 2012-2021 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -57,7 +57,7 @@ public class RedisHealthIndicator extends AbstractHealthIndicator {
private void doHealthCheck(Health.Builder builder, RedisConnection connection) { private void doHealthCheck(Health.Builder builder, RedisConnection connection) {
if (connection instanceof RedisClusterConnection) { if (connection instanceof RedisClusterConnection) {
RedisHealth.info(builder, ((RedisClusterConnection) connection).clusterGetClusterInfo()); RedisHealth.fromClusterInfo(builder, ((RedisClusterConnection) connection).clusterGetClusterInfo());
} }
else { else {
RedisHealth.up(builder, connection.info("server")); RedisHealth.up(builder, connection.info("server"));

8
spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicator.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2012-2020 the original author or authors. * Copyright 2012-2021 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -65,7 +65,7 @@ public class RedisReactiveHealthIndicator extends AbstractReactiveHealthIndicato
private Mono<Health> getHealth(Health.Builder builder, ReactiveRedisConnection connection) { private Mono<Health> getHealth(Health.Builder builder, ReactiveRedisConnection connection) {
if (connection instanceof ReactiveRedisClusterConnection) { if (connection instanceof ReactiveRedisClusterConnection) {
return ((ReactiveRedisClusterConnection) connection).clusterGetClusterInfo() return ((ReactiveRedisClusterConnection) connection).clusterGetClusterInfo()
.map(info -> info(builder, info)); .map((info) -> fromClusterInfo(builder, info));
} }
return connection.serverCommands().info("server").map((info) -> up(builder, info)); return connection.serverCommands().info("server").map((info) -> up(builder, info));
} }
@ -74,8 +74,8 @@ public class RedisReactiveHealthIndicator extends AbstractReactiveHealthIndicato
return RedisHealth.up(builder, info).build(); return RedisHealth.up(builder, info).build();
} }
private Health info(Health.Builder builder, ClusterInfo clusterInfo) { private Health fromClusterInfo(Health.Builder builder, ClusterInfo clusterInfo) {
return RedisHealth.info(builder, clusterInfo).build(); return RedisHealth.fromClusterInfo(builder, clusterInfo).build();
} }
} }

80
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisHealthIndicatorTests.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2012-2020 the original author or authors. * Copyright 2012-2021 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -68,22 +68,11 @@ class RedisHealthIndicatorTests {
assertThat((String) health.getDetails().get("error")).contains("Connection failed"); assertThat((String) health.getDetails().get("error")).contains("Connection failed");
} }
private RedisHealthIndicator createHealthIndicator(RedisConnection redisConnection) {
RedisConnectionFactory redisConnectionFactory = mock(RedisConnectionFactory.class);
given(redisConnectionFactory.getConnection()).willReturn(redisConnection);
return new RedisHealthIndicator(redisConnectionFactory);
}
@Test @Test
void redisClusterIsUpWithoutState() { void healthWhenClusterStateIsAbsentShouldBeUp() {
final Properties clusterProperties = new Properties(); RedisConnectionFactory redisConnectionFactory = createClusterConnectionFactory(null);
clusterProperties.setProperty("cluster_size", "4"); RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory);
clusterProperties.setProperty("cluster_slots_ok", "4"); Health health = healthIndicator.health();
clusterProperties.setProperty("cluster_slots_fail", "0");
final RedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties);
final RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory);
final Health health = healthIndicator.health();
assertThat(health.getStatus()).isEqualTo(Status.UP); assertThat(health.getStatus()).isEqualTo(Status.UP);
assertThat(health.getDetails().get("cluster_size")).isEqualTo(4L); assertThat(health.getDetails().get("cluster_size")).isEqualTo(4L);
assertThat(health.getDetails().get("slots_up")).isEqualTo(4L); assertThat(health.getDetails().get("slots_up")).isEqualTo(4L);
@ -92,41 +81,52 @@ class RedisHealthIndicatorTests {
} }
@Test @Test
void redisClusterIsUpWithState() { void healthWhenClusterStateIsOkShouldBeUp() {
final Properties clusterProperties = new Properties(); RedisConnectionFactory redisConnectionFactory = createClusterConnectionFactory("ok");
clusterProperties.setProperty("cluster_state", "ok"); RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory);
clusterProperties.setProperty("cluster_size", "4"); Health health = healthIndicator.health();
clusterProperties.setProperty("cluster_slots_ok", "4");
clusterProperties.setProperty("cluster_slots_fail", "0");
final RedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties);
final RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory);
final Health health = healthIndicator.health();
assertThat(health.getStatus()).isEqualTo(Status.UP); assertThat(health.getStatus()).isEqualTo(Status.UP);
assertThat(health.getDetails().get("cluster_size")).isEqualTo(4L);
assertThat(health.getDetails().get("slots_up")).isEqualTo(4L);
assertThat(health.getDetails().get("slots_fail")).isEqualTo(0L);
verify(redisConnectionFactory, atLeastOnce()).getConnection();
} }
@Test @Test
void redisClusterIsDown() { void healthWhenClusterStateIsFailShouldBeDown() {
final Properties clusterProperties = new Properties(); RedisConnectionFactory redisConnectionFactory = createClusterConnectionFactory("fail");
clusterProperties.setProperty("cluster_state", "fail"); RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory);
clusterProperties.setProperty("cluster_size", "3"); Health health = healthIndicator.health();
clusterProperties.setProperty("cluster_slots_ok", "4");
clusterProperties.setProperty("cluster_slots_fail", "0");
final RedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties);
final RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory);
final Health health = healthIndicator.health();
assertThat(health.getStatus()).isEqualTo(Status.DOWN); assertThat(health.getStatus()).isEqualTo(Status.DOWN);
assertThat(health.getDetails().get("cluster_size")).isEqualTo(4L);
assertThat(health.getDetails().get("slots_up")).isEqualTo(3L);
assertThat(health.getDetails().get("slots_fail")).isEqualTo(1L);
verify(redisConnectionFactory, atLeastOnce()).getConnection();
} }
private static RedisConnectionFactory mockRedisClusterConnectionFactory(Properties clusterProperties) { private RedisHealthIndicator createHealthIndicator(RedisConnection redisConnection) {
final List<RedisClusterNode> redisMasterNodes = Arrays.asList(new RedisClusterNode("127.0.0.1", 7001), RedisConnectionFactory redisConnectionFactory = mock(RedisConnectionFactory.class);
given(redisConnectionFactory.getConnection()).willReturn(redisConnection);
return new RedisHealthIndicator(redisConnectionFactory);
}
private RedisConnectionFactory createClusterConnectionFactory(String state) {
Properties clusterProperties = new Properties();
if (state != null) {
clusterProperties.setProperty("cluster_state", state);
}
clusterProperties.setProperty("cluster_size", "4");
boolean failure = "fail".equals(state);
clusterProperties.setProperty("cluster_slots_ok", failure ? "3" : "4");
clusterProperties.setProperty("cluster_slots_fail", failure ? "1" : "0");
List<RedisClusterNode> redisMasterNodes = Arrays.asList(new RedisClusterNode("127.0.0.1", 7001),
new RedisClusterNode("127.0.0.2", 7001)); new RedisClusterNode("127.0.0.2", 7001));
final RedisClusterConnection redisConnection = mock(RedisClusterConnection.class); RedisClusterConnection redisConnection = mock(RedisClusterConnection.class);
given(redisConnection.clusterGetNodes()).willReturn(redisMasterNodes); given(redisConnection.clusterGetNodes()).willReturn(redisMasterNodes);
given(redisConnection.clusterGetClusterInfo()).willReturn(new ClusterInfo(clusterProperties)); given(redisConnection.clusterGetClusterInfo()).willReturn(new ClusterInfo(clusterProperties));
final RedisConnectionFactory redisConnectionFactory = mock(RedisConnectionFactory.class); RedisConnectionFactory redisConnectionFactory = mock(RedisConnectionFactory.class);
given(redisConnectionFactory.getConnection()).willReturn(redisConnection); given(redisConnectionFactory.getConnection()).willReturn(redisConnection);
return redisConnectionFactory; return redisConnectionFactory;
} }
} }

86
spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicatorTests.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2012-2020 the original author or authors. * Copyright 2012-2021 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -16,14 +16,13 @@
package org.springframework.boot.actuate.redis; package org.springframework.boot.actuate.redis;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import java.util.Properties; import java.util.Properties;
import io.lettuce.core.RedisConnectionException;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import org.springframework.boot.actuate.health.Health; import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.Status; import org.springframework.boot.actuate.health.Status;
import org.springframework.data.redis.RedisConnectionFailureException; import org.springframework.data.redis.RedisConnectionFailureException;
@ -33,9 +32,10 @@ import org.springframework.data.redis.connection.ReactiveRedisConnection;
import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory; import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory;
import org.springframework.data.redis.connection.ReactiveServerCommands; import org.springframework.data.redis.connection.ReactiveServerCommands;
import io.lettuce.core.RedisConnectionException; import static org.assertj.core.api.Assertions.assertThat;
import reactor.core.publisher.Mono; import static org.mockito.BDDMockito.given;
import reactor.test.StepVerifier; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
/** /**
* Tests for {@link RedisReactiveHealthIndicator}. * Tests for {@link RedisReactiveHealthIndicator}.
@ -67,16 +67,11 @@ class RedisReactiveHealthIndicatorTests {
} }
@Test @Test
void redisClusterIsUpWithoutState() { void healthWhenClusterStateIsAbsentShouldBeUp() {
final Properties clusterProperties = new Properties(); ReactiveRedisConnectionFactory redisConnectionFactory = createClusterConnectionFactory(null);
clusterProperties.setProperty("cluster_size", "4"); RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory);
clusterProperties.setProperty("cluster_slots_ok", "4"); Mono<Health> health = healthIndicator.health();
clusterProperties.setProperty("cluster_slots_fail", "0"); StepVerifier.create(health).consumeNextWith((h) -> {
final ReactiveRedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties);
final RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory);
final Mono<Health> health = healthIndicator.health();
StepVerifier.create(health).consumeNextWith(h -> {
assertThat(h.getStatus()).isEqualTo(Status.UP); assertThat(h.getStatus()).isEqualTo(Status.UP);
assertThat(h.getDetails().get("cluster_size")).isEqualTo(4L); assertThat(h.getDetails().get("cluster_size")).isEqualTo(4L);
assertThat(h.getDetails().get("slots_up")).isEqualTo(4L); assertThat(h.getDetails().get("slots_up")).isEqualTo(4L);
@ -86,34 +81,29 @@ class RedisReactiveHealthIndicatorTests {
} }
@Test @Test
void redisClusterIsUpWithState() { void healthWhenClusterStateIsOkShouldBeUp() {
final Properties clusterProperties = new Properties(); ReactiveRedisConnectionFactory redisConnectionFactory = createClusterConnectionFactory("ok");
clusterProperties.setProperty("cluster_state", "ok"); RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory);
clusterProperties.setProperty("cluster_size", "4"); Mono<Health> health = healthIndicator.health();
clusterProperties.setProperty("cluster_slots_ok", "4"); StepVerifier.create(health).consumeNextWith((h) -> {
clusterProperties.setProperty("cluster_slots_fail", "0");
final ReactiveRedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties);
final RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory);
final Mono<Health> health = healthIndicator.health();
StepVerifier.create(health).consumeNextWith(h -> {
assertThat(h.getStatus()).isEqualTo(Status.UP); assertThat(h.getStatus()).isEqualTo(Status.UP);
assertThat(h.getDetails().get("cluster_size")).isEqualTo(4L);
assertThat(h.getDetails().get("slots_up")).isEqualTo(4L);
assertThat(h.getDetails().get("slots_fail")).isEqualTo(0L);
}).verifyComplete(); }).verifyComplete();
} }
@Test @Test
void redisClusterIsDown() { void healthWhenClusterStateIsFailShouldBeDown() {
final Properties clusterProperties = new Properties(); Properties clusterProperties = new Properties();
clusterProperties.setProperty("cluster_state", "fail"); clusterProperties.setProperty("cluster_state", "fail");
clusterProperties.setProperty("cluster_size", "3"); ReactiveRedisConnectionFactory redisConnectionFactory = createClusterConnectionFactory("fail");
clusterProperties.setProperty("cluster_slots_ok", "4"); RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory);
clusterProperties.setProperty("cluster_slots_fail", "0"); Mono<Health> health = healthIndicator.health();
final ReactiveRedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties); StepVerifier.create(health).consumeNextWith((h) -> {
final RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory);
final Mono<Health> health = healthIndicator.health();
StepVerifier.create(health).consumeNextWith(h -> {
assertThat(h.getStatus()).isEqualTo(Status.DOWN); assertThat(h.getStatus()).isEqualTo(Status.DOWN);
assertThat(h.getDetails().get("slots_up")).isEqualTo(3L);
assertThat(h.getDetails().get("slots_fail")).isEqualTo(1L);
}).verifyComplete(); }).verifyComplete();
} }
@ -143,19 +133,27 @@ class RedisReactiveHealthIndicatorTests {
private RedisReactiveHealthIndicator createHealthIndicator(ReactiveRedisConnection redisConnection, private RedisReactiveHealthIndicator createHealthIndicator(ReactiveRedisConnection redisConnection,
ReactiveServerCommands serverCommands) { ReactiveServerCommands serverCommands) {
ReactiveRedisConnectionFactory redisConnectionFactory = mock(ReactiveRedisConnectionFactory.class); ReactiveRedisConnectionFactory redisConnectionFactory = mock(ReactiveRedisConnectionFactory.class);
given(redisConnectionFactory.getReactiveConnection()).willReturn(redisConnection); given(redisConnectionFactory.getReactiveConnection()).willReturn(redisConnection);
given(redisConnection.serverCommands()).willReturn(serverCommands); given(redisConnection.serverCommands()).willReturn(serverCommands);
return new RedisReactiveHealthIndicator(redisConnectionFactory); return new RedisReactiveHealthIndicator(redisConnectionFactory);
} }
private static ReactiveRedisConnectionFactory mockRedisClusterConnectionFactory(Properties clusterProperties) { private ReactiveRedisConnectionFactory createClusterConnectionFactory(String state) {
final ReactiveRedisClusterConnection redisConnection = mock(ReactiveRedisClusterConnection.class); Properties clusterProperties = new Properties();
if (state != null) {
clusterProperties.setProperty("cluster_state", state);
}
clusterProperties.setProperty("cluster_size", "4");
boolean failure = "fail".equals(state);
clusterProperties.setProperty("cluster_slots_ok", failure ? "3" : "4");
clusterProperties.setProperty("cluster_slots_fail", failure ? "1" : "0");
ReactiveRedisClusterConnection redisConnection = mock(ReactiveRedisClusterConnection.class);
given(redisConnection.closeLater()).willReturn(Mono.empty()); given(redisConnection.closeLater()).willReturn(Mono.empty());
given(redisConnection.clusterGetClusterInfo()).willReturn(Mono.just(new ClusterInfo(clusterProperties))); given(redisConnection.clusterGetClusterInfo()).willReturn(Mono.just(new ClusterInfo(clusterProperties)));
final ReactiveRedisConnectionFactory redisConnectionFactory = mock(ReactiveRedisConnectionFactory.class); ReactiveRedisConnectionFactory redisConnectionFactory = mock(ReactiveRedisConnectionFactory.class);
given(redisConnectionFactory.getReactiveConnection()).willReturn(redisConnection); given(redisConnectionFactory.getReactiveConnection()).willReturn(redisConnection);
return redisConnectionFactory; return redisConnectionFactory;
} }
} }