Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add BackOffExecution to isolate state

Browse Source 
This commit separates the BackOff configuration from an actual
 execution. BackOffExecution now contains all the state of a
 particular execution and BackOff is only meant to start (i.e.
 create) a new execution.

 The method "reset" has been removed as its no longer necessary:
 when an execution does not need to be used for a given operation
 anymore it can be simply discarded.

 Issue: SPR-11746
This commit is contained in:
Stephane Nicoll
2014-05-09 16:39:01 +02:00
parent 49040a2925
commit 89fc3c0257
10 changed files with 270 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
spring-core/src/test/java/org/springframework/util/ExponentialBackOffTests.java
View File

@@ -34,64 +34,73 @@ public class ExponentialBackOffTests {
@Test
public void defaultInstance() {
ExponentialBackOff backOff = new ExponentialBackOff();
assertEquals(2000l, backOff.nextBackOff());
assertEquals(3000l, backOff.nextBackOff());
assertEquals(4500l, backOff.nextBackOff());
BackOffExecution execution = backOff.start();
assertEquals(2000l, execution.nextBackOff());
assertEquals(3000l, execution.nextBackOff());
assertEquals(4500l, execution.nextBackOff());
}
@Test
public void simpleIncrease() {
ExponentialBackOff backOff = new ExponentialBackOff(100L, 2.0);
assertEquals(100l, backOff.nextBackOff());
assertEquals(200l, backOff.nextBackOff());
assertEquals(400l, backOff.nextBackOff());
assertEquals(800l, backOff.nextBackOff());
BackOffExecution execution = backOff.start();
assertEquals(100l, execution.nextBackOff());
assertEquals(200l, execution.nextBackOff());
assertEquals(400l, execution.nextBackOff());
assertEquals(800l, execution.nextBackOff());
}
@Test
public void fixedIncrease() {
ExponentialBackOff backOff = new ExponentialBackOff(100L, 1.0);
backOff.setMaxElapsedTime(300l);
assertEquals(100l, backOff.nextBackOff());
assertEquals(100l, backOff.nextBackOff());
assertEquals(100l, backOff.nextBackOff());
assertEquals(BackOff.STOP, backOff.nextBackOff());
BackOffExecution execution = backOff.start();
assertEquals(100l, execution.nextBackOff());
assertEquals(100l, execution.nextBackOff());
assertEquals(100l, execution.nextBackOff());
assertEquals(BackOffExecution.STOP, execution.nextBackOff());
}
@Test
public void maxIntervalReached() {
ExponentialBackOff backOff = new ExponentialBackOff(2000L, 2.0);
backOff.setMaxInterval(4000L);
assertEquals(2000l, backOff.nextBackOff());
assertEquals(4000l, backOff.nextBackOff());
assertEquals(4000l, backOff.nextBackOff()); // max reached
assertEquals(4000l, backOff.nextBackOff());
BackOffExecution execution = backOff.start();
assertEquals(2000l, execution.nextBackOff());
assertEquals(4000l, execution.nextBackOff());
assertEquals(4000l, execution.nextBackOff()); // max reached
assertEquals(4000l, execution.nextBackOff());
}
@Test
public void maxAttemptsReached() {
ExponentialBackOff backOff = new ExponentialBackOff(2000L, 2.0);
backOff.setMaxElapsedTime(4000L);
assertEquals(2000l, backOff.nextBackOff());
assertEquals(4000l, backOff.nextBackOff());
assertEquals(BackOff.STOP, backOff.nextBackOff()); // > 4 sec wait in total
BackOffExecution execution = backOff.start();
assertEquals(2000l, execution.nextBackOff());
assertEquals(4000l, execution.nextBackOff());
assertEquals(BackOffExecution.STOP, execution.nextBackOff()); // > 4 sec wait in total
}
@Test
public void resetInstance() {
public void startReturnDifferentInstances() {
ExponentialBackOff backOff = new ExponentialBackOff();
backOff.setInitialInterval(2000L);
backOff.setMultiplier(2.0);
backOff.setMaxElapsedTime(4000L);
assertEquals(2000l, backOff.nextBackOff());
assertEquals(4000l, backOff.nextBackOff());
assertEquals(BackOff.STOP, backOff.nextBackOff());
backOff.reset();
BackOffExecution execution = backOff.start();
BackOffExecution execution2 = backOff.start();
assertEquals(2000l, backOff.nextBackOff());
assertEquals(4000l, backOff.nextBackOff());
assertEquals(BackOff.STOP, backOff.nextBackOff());
assertEquals(2000l, execution.nextBackOff());
assertEquals(2000l, execution2.nextBackOff());
assertEquals(4000l, execution.nextBackOff());
assertEquals(4000l, execution2.nextBackOff());
assertEquals(BackOffExecution.STOP, execution.nextBackOff());
assertEquals(BackOffExecution.STOP, execution2.nextBackOff());
}
@Test
@@ -107,18 +116,20 @@ public class ExponentialBackOffTests {
ExponentialBackOff backOff = new ExponentialBackOff(1000L, 2.0);
backOff.setMaxInterval(50L);
assertEquals(50L, backOff.nextBackOff());
assertEquals(50L, backOff.nextBackOff());
BackOffExecution execution = backOff.start();
assertEquals(50L, execution.nextBackOff());
assertEquals(50L, execution.nextBackOff());
}
@Test
public void toStringContent() {
ExponentialBackOff backOff = new ExponentialBackOff(2000L, 2.0);
assertEquals("ExponentialBackOff{currentInterval=n/a, multiplier=2.0}", backOff.toString());
backOff.nextBackOff();
assertEquals("ExponentialBackOff{currentInterval=2000ms, multiplier=2.0}", backOff.toString());
backOff.nextBackOff();
assertEquals("ExponentialBackOff{currentInterval=4000ms, multiplier=2.0}", backOff.toString());
BackOffExecution execution = backOff.start();
assertEquals("ExponentialBackOff{currentInterval=n/a, multiplier=2.0}", execution.toString());
execution.nextBackOff();
assertEquals("ExponentialBackOff{currentInterval=2000ms, multiplier=2.0}", execution.toString());
execution.nextBackOff();
assertEquals("ExponentialBackOff{currentInterval=4000ms, multiplier=2.0}", execution.toString());
}
}

45
spring-core/src/test/java/org/springframework/util/FixedBackOffTests.java
View File

@@ -28,57 +28,62 @@ public class FixedBackOffTests {
@Test
public void defaultInstance() {
FixedBackOff backOff = new FixedBackOff();
BackOffExecution execution = backOff.start();
for (int i = 0; i < 100; i++) {
assertEquals(FixedBackOff.DEFAULT_INTERVAL, backOff.nextBackOff());
assertEquals(FixedBackOff.DEFAULT_INTERVAL, execution.nextBackOff());
}
}
@Test
public void noAttemptAtAll() {
FixedBackOff backOff = new FixedBackOff(100L, 0L);
assertEquals(BackOff.STOP, backOff.nextBackOff());
BackOffExecution execution = backOff.start();
assertEquals(BackOffExecution.STOP, execution.nextBackOff());
}
@Test
public void maxAttemptsReached() {
FixedBackOff backOff = new FixedBackOff(200L, 2);
assertEquals(200l, backOff.nextBackOff());
assertEquals(200l, backOff.nextBackOff());
assertEquals(BackOff.STOP, backOff.nextBackOff());
BackOffExecution execution = backOff.start();
assertEquals(200l, execution.nextBackOff());
assertEquals(200l, execution.nextBackOff());
assertEquals(BackOffExecution.STOP, execution.nextBackOff());
}
@Test
public void resetOnInstance() {
public void startReturnDifferentInstances() {
FixedBackOff backOff = new FixedBackOff(100L, 1);
assertEquals(100l, backOff.nextBackOff());
assertEquals(BackOff.STOP, backOff.nextBackOff());
BackOffExecution execution = backOff.start();
BackOffExecution execution2 = backOff.start();
backOff.reset();
assertEquals(100l, backOff.nextBackOff());
assertEquals(BackOff.STOP, backOff.nextBackOff());
assertEquals(100l, execution.nextBackOff());
assertEquals(100l, execution2.nextBackOff());
assertEquals(BackOffExecution.STOP, execution.nextBackOff());
assertEquals(BackOffExecution.STOP, execution2.nextBackOff());
}
@Test
public void liveUpdate() {
FixedBackOff backOff = new FixedBackOff(100L, 1);
assertEquals(100l, backOff.nextBackOff());
BackOffExecution execution = backOff.start();
assertEquals(100l, execution.nextBackOff());
backOff.setInterval(200l);
backOff.setMaxAttempts(2);
assertEquals(200l, backOff.nextBackOff());
assertEquals(BackOff.STOP, backOff.nextBackOff());
assertEquals(200l, execution.nextBackOff());
assertEquals(BackOffExecution.STOP, execution.nextBackOff());
}
@Test
public void toStringContent() {
FixedBackOff backOff = new FixedBackOff(200L, 10);
assertEquals("FixedBackOff{interval=200, currentAttempts=0, maxAttempts=10}", backOff.toString());
backOff.nextBackOff();
assertEquals("FixedBackOff{interval=200, currentAttempts=1, maxAttempts=10}", backOff.toString());
backOff.nextBackOff();
assertEquals("FixedBackOff{interval=200, currentAttempts=2, maxAttempts=10}", backOff.toString());
BackOffExecution execution = backOff.start();
assertEquals("FixedBackOff{interval=200, currentAttempts=0, maxAttempts=10}", execution.toString());
execution.nextBackOff();
assertEquals("FixedBackOff{interval=200, currentAttempts=1, maxAttempts=10}", execution.toString());
execution.nextBackOff();
assertEquals("FixedBackOff{interval=200, currentAttempts=2, maxAttempts=10}", execution.toString());
}
}