MirrorMirror
/
Signal-Server
mirror of https://github.com/signalapp/Signal-Server.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update deprecated `CircuitBreakerConfig` usage

This commit is contained in:
Chris Eager 2022-08-24 12:34:39 -05:00 committed by Chris Eager
parent 1e7aa89664
commit c05692e417
5 changed files with 97 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
service/src/main/java/org/whispersystems/textsecuregcm/configuration/CircuitBreakerConfiguration.java
View File

@ -27,12 +27,17 @@ public class CircuitBreakerConfiguration {
@JsonProperty @JsonProperty
@NotNull @NotNull
@Min(1) @Min(1)
private int ringBufferSizeInHalfOpenState = 10; private int permittedNumberOfCallsInHalfOpenState = 10;
@JsonProperty @JsonProperty
@NotNull @NotNull
@Min(1) @Min(1)
private int ringBufferSizeInClosedState = 100; private int slidingWindowSize = 100;
@JsonProperty
@NotNull
@Min(1)
private int slidingWindowMinimumNumberOfCalls = 100;
@JsonProperty @JsonProperty
@NotNull @NotNull
@ -47,28 +52,32 @@ public class CircuitBreakerConfiguration {
return failureRateThreshold; return failureRateThreshold;
} }
public int getRingBufferSizeInHalfOpenState() { public int getPermittedNumberOfCallsInHalfOpenState() {
return ringBufferSizeInHalfOpenState; return permittedNumberOfCallsInHalfOpenState;
} }
public int getRingBufferSizeInClosedState() { public int getSlidingWindowSize() {
return ringBufferSizeInClosedState; return slidingWindowSize;
}
public int getSlidingWindowMinimumNumberOfCalls() {
return slidingWindowMinimumNumberOfCalls;
} }
public long getWaitDurationInOpenStateInSeconds() { public long getWaitDurationInOpenStateInSeconds() {
return waitDurationInOpenStateInSeconds; return waitDurationInOpenStateInSeconds;
} }
public List<Class> getIgnoredExceptions() { public List<Class<?>> getIgnoredExceptions() {
return ignoredExceptions.stream() return ignoredExceptions.stream()
.map(name -> { .map(name -> {
try { try {
return Class.forName(name); return Class.forName(name);
} catch (final ClassNotFoundException e) { } catch (final ClassNotFoundException e) {
throw new RuntimeException(e); throw new RuntimeException(e);
} }
}) })
.collect(Collectors.toList()); .collect(Collectors.toList());
} }
@VisibleForTesting @VisibleForTesting
@ -77,13 +86,18 @@ public class CircuitBreakerConfiguration {
} }
@VisibleForTesting @VisibleForTesting
public void setRingBufferSizeInClosedState(int size) { public void setSlidingWindowSize(int size) {
this.ringBufferSizeInClosedState = size; this.slidingWindowSize = size;
} }
@VisibleForTesting @VisibleForTesting
public void setRingBufferSizeInHalfOpenState(int size) { public void setSlidingWindowMinimumNumberOfCalls(int size) {
this.ringBufferSizeInHalfOpenState = size; this.slidingWindowMinimumNumberOfCalls = size;
}
@VisibleForTesting
public void setPermittedNumberOfCallsInHalfOpenState(int size) {
this.permittedNumberOfCallsInHalfOpenState = size;
} }
@VisibleForTesting @VisibleForTesting
@ -98,11 +112,12 @@ public class CircuitBreakerConfiguration {
public CircuitBreakerConfig toCircuitBreakerConfig() { public CircuitBreakerConfig toCircuitBreakerConfig() {
return CircuitBreakerConfig.custom() return CircuitBreakerConfig.custom()
.failureRateThreshold(getFailureRateThreshold()) .failureRateThreshold(getFailureRateThreshold())
.ignoreExceptions(getIgnoredExceptions().toArray(new Class[0])) .ignoreExceptions(getIgnoredExceptions().toArray(new Class[0]))
.ringBufferSizeInHalfOpenState(getRingBufferSizeInHalfOpenState()) .permittedNumberOfCallsInHalfOpenState(getPermittedNumberOfCallsInHalfOpenState())
.waitDurationInOpenState(Duration.ofSeconds(getWaitDurationInOpenStateInSeconds())) .waitDurationInOpenState(Duration.ofSeconds(getWaitDurationInOpenStateInSeconds()))
.ringBufferSizeInClosedState(getRingBufferSizeInClosedState()) .slidingWindow(getSlidingWindowSize(), getSlidingWindowMinimumNumberOfCalls(),
.build(); CircuitBreakerConfig.SlidingWindowType.COUNT_BASED)
.build();
} }
} }

31
service/src/test/java/org/whispersystems/textsecuregcm/redis/FaultTolerantPubSubConnectionTest.java
View File

@ -19,8 +19,8 @@ import io.lettuce.core.RedisCommandTimeoutException;
import io.lettuce.core.RedisException; import io.lettuce.core.RedisException;
import io.lettuce.core.cluster.pubsub.StatefulRedisClusterPubSubConnection; import io.lettuce.core.cluster.pubsub.StatefulRedisClusterPubSubConnection;
import io.lettuce.core.cluster.pubsub.api.sync.RedisClusterPubSubCommands; import io.lettuce.core.cluster.pubsub.api.sync.RedisClusterPubSubCommands;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.whispersystems.textsecuregcm.configuration.CircuitBreakerConfiguration; import org.whispersystems.textsecuregcm.configuration.CircuitBreakerConfiguration;
import org.whispersystems.textsecuregcm.configuration.RetryConfiguration; import org.whispersystems.textsecuregcm.configuration.RetryConfiguration;
@ -32,25 +32,28 @@ class FaultTolerantPubSubConnectionTest {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@BeforeEach @BeforeEach
public void setUp() { public void setUp() {
final StatefulRedisClusterPubSubConnection<String, String> pubSubConnection = mock(StatefulRedisClusterPubSubConnection.class); final StatefulRedisClusterPubSubConnection<String, String> pubSubConnection = mock(
StatefulRedisClusterPubSubConnection.class);
pubSubCommands = mock(RedisClusterPubSubCommands.class); pubSubCommands = mock(RedisClusterPubSubCommands.class);
when(pubSubConnection.sync()).thenReturn(pubSubCommands); when(pubSubConnection.sync()).thenReturn(pubSubCommands);
final CircuitBreakerConfiguration breakerConfiguration = new CircuitBreakerConfiguration(); final CircuitBreakerConfiguration breakerConfiguration = new CircuitBreakerConfiguration();
breakerConfiguration.setFailureRateThreshold(100); breakerConfiguration.setFailureRateThreshold(100);
breakerConfiguration.setRingBufferSizeInClosedState(1); breakerConfiguration.setSlidingWindowSize(1);
breakerConfiguration.setWaitDurationInOpenStateInSeconds(Integer.MAX_VALUE); breakerConfiguration.setSlidingWindowMinimumNumberOfCalls(1);
breakerConfiguration.setWaitDurationInOpenStateInSeconds(Integer.MAX_VALUE);
final RetryConfiguration retryConfiguration = new RetryConfiguration(); final RetryConfiguration retryConfiguration = new RetryConfiguration();
retryConfiguration.setMaxAttempts(3); retryConfiguration.setMaxAttempts(3);
retryConfiguration.setWaitDuration(0); retryConfiguration.setWaitDuration(0);
final CircuitBreaker circuitBreaker = CircuitBreaker.of("test", breakerConfiguration.toCircuitBreakerConfig()); final CircuitBreaker circuitBreaker = CircuitBreaker.of("test", breakerConfiguration.toCircuitBreakerConfig());
final Retry retry = Retry.of("test", retryConfiguration.toRetryConfig()); final Retry retry = Retry.of("test", retryConfiguration.toRetryConfig());
faultTolerantPubSubConnection = new FaultTolerantPubSubConnection<>("test", pubSubConnection, circuitBreaker, retry); faultTolerantPubSubConnection = new FaultTolerantPubSubConnection<>("test", pubSubConnection, circuitBreaker,
retry);
} }
@Test @Test

32
service/src/test/java/org/whispersystems/textsecuregcm/redis/FaultTolerantRedisClusterTest.java
View File

@ -22,8 +22,8 @@ import io.lettuce.core.cluster.pubsub.StatefulRedisClusterPubSubConnection;
import io.lettuce.core.event.EventBus; import io.lettuce.core.event.EventBus;
import io.lettuce.core.resource.ClientResources; import io.lettuce.core.resource.ClientResources;
import java.time.Duration; import java.time.Duration;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.whispersystems.textsecuregcm.configuration.CircuitBreakerConfiguration; import org.whispersystems.textsecuregcm.configuration.CircuitBreakerConfiguration;
import org.whispersystems.textsecuregcm.configuration.RetryConfiguration; import org.whispersystems.textsecuregcm.configuration.RetryConfiguration;
import reactor.core.publisher.Flux; import reactor.core.publisher.Flux;
@ -44,23 +44,25 @@ class FaultTolerantRedisClusterTest {
clusterCommands = mock(RedisAdvancedClusterCommands.class); clusterCommands = mock(RedisAdvancedClusterCommands.class);
when(clusterClient.connect()).thenReturn(clusterConnection); when(clusterClient.connect()).thenReturn(clusterConnection);
when(clusterClient.connectPubSub()).thenReturn(pubSubConnection); when(clusterClient.connectPubSub()).thenReturn(pubSubConnection);
when(clusterClient.getResources()).thenReturn(clientResources); when(clusterClient.getResources()).thenReturn(clientResources);
when(clusterConnection.sync()).thenReturn(clusterCommands); when(clusterConnection.sync()).thenReturn(clusterCommands);
when(clientResources.eventBus()).thenReturn(eventBus); when(clientResources.eventBus()).thenReturn(eventBus);
when(eventBus.get()).thenReturn(mock(Flux.class)); when(eventBus.get()).thenReturn(mock(Flux.class));
final CircuitBreakerConfiguration breakerConfiguration = new CircuitBreakerConfiguration(); final CircuitBreakerConfiguration breakerConfiguration = new CircuitBreakerConfiguration();
breakerConfiguration.setFailureRateThreshold(100); breakerConfiguration.setFailureRateThreshold(100);
breakerConfiguration.setRingBufferSizeInClosedState(1); breakerConfiguration.setSlidingWindowSize(1);
breakerConfiguration.setWaitDurationInOpenStateInSeconds(Integer.MAX_VALUE); breakerConfiguration.setSlidingWindowMinimumNumberOfCalls(1);
breakerConfiguration.setWaitDurationInOpenStateInSeconds(Integer.MAX_VALUE);
final RetryConfiguration retryConfiguration = new RetryConfiguration(); final RetryConfiguration retryConfiguration = new RetryConfiguration();
retryConfiguration.setMaxAttempts(3); retryConfiguration.setMaxAttempts(3);
retryConfiguration.setWaitDuration(0); retryConfiguration.setWaitDuration(0);
faultTolerantCluster = new FaultTolerantRedisCluster("test", clusterClient, Duration.ofSeconds(2), breakerConfiguration, retryConfiguration); faultTolerantCluster = new FaultTolerantRedisCluster("test", clusterClient, Duration.ofSeconds(2),
breakerConfiguration, retryConfiguration);
} }
@Test @Test

17
service/src/test/java/org/whispersystems/textsecuregcm/tests/http/FaultTolerantHttpClientTest.java
View File

@ -95,18 +95,19 @@ class FaultTolerantHttpClientTest {
@Test @Test
void testNetworkFailureCircuitBreaker() throws InterruptedException { void testNetworkFailureCircuitBreaker() throws InterruptedException {
CircuitBreakerConfiguration circuitBreakerConfiguration = new CircuitBreakerConfiguration(); CircuitBreakerConfiguration circuitBreakerConfiguration = new CircuitBreakerConfiguration();
circuitBreakerConfiguration.setRingBufferSizeInClosedState(2); circuitBreakerConfiguration.setSlidingWindowSize(2);
circuitBreakerConfiguration.setRingBufferSizeInHalfOpenState(1); circuitBreakerConfiguration.setSlidingWindowMinimumNumberOfCalls(2);
circuitBreakerConfiguration.setPermittedNumberOfCallsInHalfOpenState(1);
circuitBreakerConfiguration.setFailureRateThreshold(50); circuitBreakerConfiguration.setFailureRateThreshold(50);
circuitBreakerConfiguration.setWaitDurationInOpenStateInSeconds(1); circuitBreakerConfiguration.setWaitDurationInOpenStateInSeconds(1);
FaultTolerantHttpClient client = FaultTolerantHttpClient.newBuilder() FaultTolerantHttpClient client = FaultTolerantHttpClient.newBuilder()
.withCircuitBreaker(circuitBreakerConfiguration) .withCircuitBreaker(circuitBreakerConfiguration)
.withRetry(new RetryConfiguration()) .withRetry(new RetryConfiguration())
.withExecutor(Executors.newSingleThreadExecutor()) .withExecutor(Executors.newSingleThreadExecutor())
.withName("test") .withName("test")
.withVersion(HttpClient.Version.HTTP_2) .withVersion(HttpClient.Version.HTTP_2)
.build(); .build();
HttpRequest request = HttpRequest.newBuilder() HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("http://localhost:" + 39873 + "/failure")) .uri(URI.create("http://localhost:" + 39873 + "/failure"))

23
service/src/test/java/org/whispersystems/textsecuregcm/tests/redis/ReplicatedJedisPoolTest.java
View File

@ -118,17 +118,19 @@ class ReplicatedJedisPoolTest {
void testCircuitBreakerOpen() { void testCircuitBreakerOpen() {
CircuitBreakerConfiguration configuration = new CircuitBreakerConfiguration(); CircuitBreakerConfiguration configuration = new CircuitBreakerConfiguration();
configuration.setFailureRateThreshold(50); configuration.setFailureRateThreshold(50);
configuration.setRingBufferSizeInClosedState(2); configuration.setSlidingWindowSize(2);
configuration.setSlidingWindowMinimumNumberOfCalls(2);
JedisPool master = mock(JedisPool.class); JedisPool master = mock(JedisPool.class);
JedisPool slaveOne = mock(JedisPool.class); JedisPool slaveOne = mock(JedisPool.class);
JedisPool slaveTwo = mock(JedisPool.class); JedisPool slaveTwo = mock(JedisPool.class);
when(master.getResource()).thenReturn(null); when(master.getResource()).thenReturn(null);
when(slaveOne.getResource()).thenThrow(new JedisException("Connection failed!")); when(slaveOne.getResource()).thenThrow(new JedisException("Connection failed!"));
when(slaveTwo.getResource()).thenThrow(new JedisException("Also failed!")); when(slaveTwo.getResource()).thenThrow(new JedisException("Also failed!"));
ReplicatedJedisPool replicatedJedisPool = new ReplicatedJedisPool("testCircuitBreakerOpen", master, Arrays.asList(slaveOne, slaveTwo), configuration); ReplicatedJedisPool replicatedJedisPool = new ReplicatedJedisPool("testCircuitBreakerOpen", master,
Arrays.asList(slaveOne, slaveTwo), configuration);
replicatedJedisPool.getWriteResource(); replicatedJedisPool.getWriteResource();
when(master.getResource()).thenThrow(new JedisException("Master broken!")); when(master.getResource()).thenThrow(new JedisException("Master broken!"));
@ -152,13 +154,14 @@ class ReplicatedJedisPoolTest {
void testCircuitBreakerHalfOpen() throws InterruptedException { void testCircuitBreakerHalfOpen() throws InterruptedException {
CircuitBreakerConfiguration configuration = new CircuitBreakerConfiguration(); CircuitBreakerConfiguration configuration = new CircuitBreakerConfiguration();
configuration.setFailureRateThreshold(50); configuration.setFailureRateThreshold(50);
configuration.setRingBufferSizeInClosedState(2); configuration.setSlidingWindowSize(2);
configuration.setRingBufferSizeInHalfOpenState(1); configuration.setSlidingWindowMinimumNumberOfCalls(2);
configuration.setPermittedNumberOfCallsInHalfOpenState(1);
configuration.setWaitDurationInOpenStateInSeconds(1); configuration.setWaitDurationInOpenStateInSeconds(1);
JedisPool master = mock(JedisPool.class); JedisPool master = mock(JedisPool.class);
JedisPool slaveOne = mock(JedisPool.class); JedisPool slaveOne = mock(JedisPool.class);
JedisPool slaveTwo = mock(JedisPool.class); JedisPool slaveTwo = mock(JedisPool.class);
when(master.getResource()).thenThrow(new JedisException("Master broken!")); when(master.getResource()).thenThrow(new JedisException("Master broken!"));
when(slaveOne.getResource()).thenThrow(new JedisException("Connection failed!")); when(slaveOne.getResource()).thenThrow(new JedisException("Connection failed!"));