Update deprecated `CircuitBreakerConfig` usage

service/src/main/java/org/whispersystems/textsecuregcm/configuration/CircuitBreakerConfiguration.java

@@ -27,12 +27,17 @@ public class CircuitBreakerConfiguration {
   @JsonProperty
   @NotNull
   @Min(1)
-  private int ringBufferSizeInHalfOpenState = 10;
+  private int permittedNumberOfCallsInHalfOpenState = 10;
 
   @JsonProperty
   @NotNull
   @Min(1)
-  private int ringBufferSizeInClosedState = 100;
+  private int slidingWindowSize = 100;
+
+  @JsonProperty
+  @NotNull
+  @Min(1)
+  private int slidingWindowMinimumNumberOfCalls = 100;
 
   @JsonProperty
   @NotNull
@@ -47,19 +52,23 @@ public class CircuitBreakerConfiguration {
     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() {
     return waitDurationInOpenStateInSeconds;
   }
 
-  public List<Class> getIgnoredExceptions() {
+  public List<Class<?>> getIgnoredExceptions() {
     return ignoredExceptions.stream()
         .map(name -> {
           try {
@@ -77,13 +86,18 @@ public class CircuitBreakerConfiguration {
   }
 
   @VisibleForTesting
-  public void setRingBufferSizeInClosedState(int size) {
+  public void setSlidingWindowSize(int size) {
-    this.ringBufferSizeInClosedState = size;
+    this.slidingWindowSize = size;
   }
 
   @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
@@ -100,9 +114,10 @@ public class CircuitBreakerConfiguration {
     return CircuitBreakerConfig.custom()
         .failureRateThreshold(getFailureRateThreshold())
         .ignoreExceptions(getIgnoredExceptions().toArray(new Class[0]))
-                        .ringBufferSizeInHalfOpenState(getRingBufferSizeInHalfOpenState())
+        .permittedNumberOfCallsInHalfOpenState(getPermittedNumberOfCallsInHalfOpenState())
         .waitDurationInOpenState(Duration.ofSeconds(getWaitDurationInOpenStateInSeconds()))
-                        .ringBufferSizeInClosedState(getRingBufferSizeInClosedState())
+        .slidingWindow(getSlidingWindowSize(), getSlidingWindowMinimumNumberOfCalls(),
+            CircuitBreakerConfig.SlidingWindowType.COUNT_BASED)
         .build();
   }
 }

service/src/test/java/org/whispersystems/textsecuregcm/redis/FaultTolerantPubSubConnectionTest.java

@@ -19,8 +19,8 @@ import io.lettuce.core.RedisCommandTimeoutException;
 import io.lettuce.core.RedisException;
 import io.lettuce.core.cluster.pubsub.StatefulRedisClusterPubSubConnection;
 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.Test;
 import org.whispersystems.textsecuregcm.configuration.CircuitBreakerConfiguration;
 import org.whispersystems.textsecuregcm.configuration.RetryConfiguration;
 
@@ -32,7 +32,8 @@ class FaultTolerantPubSubConnectionTest {
     @SuppressWarnings("unchecked")
     @BeforeEach
     public void setUp() {
-        final StatefulRedisClusterPubSubConnection<String, String> pubSubConnection = mock(StatefulRedisClusterPubSubConnection.class);
+      final StatefulRedisClusterPubSubConnection<String, String> pubSubConnection = mock(
+          StatefulRedisClusterPubSubConnection.class);
 
       pubSubCommands = mock(RedisClusterPubSubCommands.class);
 
@@ -40,7 +41,8 @@ class FaultTolerantPubSubConnectionTest {
 
       final CircuitBreakerConfiguration breakerConfiguration = new CircuitBreakerConfiguration();
       breakerConfiguration.setFailureRateThreshold(100);
-        breakerConfiguration.setRingBufferSizeInClosedState(1);
+      breakerConfiguration.setSlidingWindowSize(1);
+      breakerConfiguration.setSlidingWindowMinimumNumberOfCalls(1);
       breakerConfiguration.setWaitDurationInOpenStateInSeconds(Integer.MAX_VALUE);
 
       final RetryConfiguration retryConfiguration = new RetryConfiguration();
@@ -50,7 +52,8 @@ class FaultTolerantPubSubConnectionTest {
       final CircuitBreaker circuitBreaker = CircuitBreaker.of("test", breakerConfiguration.toCircuitBreakerConfig());
       final Retry retry = Retry.of("test", retryConfiguration.toRetryConfig());
 
-        faultTolerantPubSubConnection = new FaultTolerantPubSubConnection<>("test", pubSubConnection, circuitBreaker, retry);
+      faultTolerantPubSubConnection = new FaultTolerantPubSubConnection<>("test", pubSubConnection, circuitBreaker,
+          retry);
     }
 
     @Test

service/src/test/java/org/whispersystems/textsecuregcm/redis/FaultTolerantRedisClusterTest.java

@@ -22,8 +22,8 @@ import io.lettuce.core.cluster.pubsub.StatefulRedisClusterPubSubConnection;
 import io.lettuce.core.event.EventBus;
 import io.lettuce.core.resource.ClientResources;
 import java.time.Duration;
-import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.whispersystems.textsecuregcm.configuration.CircuitBreakerConfiguration;
 import org.whispersystems.textsecuregcm.configuration.RetryConfiguration;
 import reactor.core.publisher.Flux;
@@ -53,14 +53,16 @@ class FaultTolerantRedisClusterTest {
 
       final CircuitBreakerConfiguration breakerConfiguration = new CircuitBreakerConfiguration();
       breakerConfiguration.setFailureRateThreshold(100);
-        breakerConfiguration.setRingBufferSizeInClosedState(1);
+      breakerConfiguration.setSlidingWindowSize(1);
+      breakerConfiguration.setSlidingWindowMinimumNumberOfCalls(1);
       breakerConfiguration.setWaitDurationInOpenStateInSeconds(Integer.MAX_VALUE);
 
       final RetryConfiguration retryConfiguration = new RetryConfiguration();
       retryConfiguration.setMaxAttempts(3);
       retryConfiguration.setWaitDuration(0);
 
-        faultTolerantCluster = new FaultTolerantRedisCluster("test", clusterClient, Duration.ofSeconds(2), breakerConfiguration, retryConfiguration);
+      faultTolerantCluster = new FaultTolerantRedisCluster("test", clusterClient, Duration.ofSeconds(2),
+          breakerConfiguration, retryConfiguration);
     }
 
     @Test

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

@@ -95,8 +95,9 @@ class FaultTolerantHttpClientTest {
   @Test
   void testNetworkFailureCircuitBreaker() throws InterruptedException {
     CircuitBreakerConfiguration circuitBreakerConfiguration = new CircuitBreakerConfiguration();
-    circuitBreakerConfiguration.setRingBufferSizeInClosedState(2);
+    circuitBreakerConfiguration.setSlidingWindowSize(2);
-    circuitBreakerConfiguration.setRingBufferSizeInHalfOpenState(1);
+    circuitBreakerConfiguration.setSlidingWindowMinimumNumberOfCalls(2);
+    circuitBreakerConfiguration.setPermittedNumberOfCallsInHalfOpenState(1);
     circuitBreakerConfiguration.setFailureRateThreshold(50);
     circuitBreakerConfiguration.setWaitDurationInOpenStateInSeconds(1);
 

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

@@ -118,7 +118,8 @@ class ReplicatedJedisPoolTest {
   void testCircuitBreakerOpen() {
     CircuitBreakerConfiguration configuration = new CircuitBreakerConfiguration();
     configuration.setFailureRateThreshold(50);
-    configuration.setRingBufferSizeInClosedState(2);
+    configuration.setSlidingWindowSize(2);
+    configuration.setSlidingWindowMinimumNumberOfCalls(2);
 
     JedisPool master = mock(JedisPool.class);
     JedisPool slaveOne = mock(JedisPool.class);
@@ -128,7 +129,8 @@ class ReplicatedJedisPoolTest {
     when(slaveOne.getResource()).thenThrow(new JedisException("Connection 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();
 
     when(master.getResource()).thenThrow(new JedisException("Master broken!"));
@@ -152,8 +154,9 @@ class ReplicatedJedisPoolTest {
   void testCircuitBreakerHalfOpen() throws InterruptedException {
     CircuitBreakerConfiguration configuration = new CircuitBreakerConfiguration();
     configuration.setFailureRateThreshold(50);
-    configuration.setRingBufferSizeInClosedState(2);
+    configuration.setSlidingWindowSize(2);
-    configuration.setRingBufferSizeInHalfOpenState(1);
+    configuration.setSlidingWindowMinimumNumberOfCalls(2);
+    configuration.setPermittedNumberOfCallsInHalfOpenState(1);
     configuration.setWaitDurationInOpenStateInSeconds(1);
 
     JedisPool master = mock(JedisPool.class);