Java Code Examples for org.springframework.util.backoff.FixedBackOff#start()

@Test
public void defaultInstance() {
	FixedBackOff backOff = new FixedBackOff();
	BackOffExecution execution = backOff.start();
	for (int i = 0; i < 100; i++) {
		assertEquals(FixedBackOff.DEFAULT_INTERVAL, execution.nextBackOff());
	}
}
 

@Test
public void maxAttemptsReached() {
	FixedBackOff backOff = new FixedBackOff(200L, 2);
	BackOffExecution execution = backOff.start();
	assertEquals(200L, execution.nextBackOff());
	assertEquals(200L, execution.nextBackOff());
	assertEquals(BackOffExecution.STOP, execution.nextBackOff());
}
 

@Test
public void startReturnDifferentInstances() {
	FixedBackOff backOff = new FixedBackOff(100L, 1);
	BackOffExecution execution = backOff.start();
	BackOffExecution execution2 = backOff.start();

	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);
	BackOffExecution execution = backOff.start();
	assertEquals(100L, execution.nextBackOff());

	backOff.setInterval(200L);
	backOff.setMaxAttempts(2);

	assertEquals(200L, execution.nextBackOff());
	assertEquals(BackOffExecution.STOP, execution.nextBackOff());
}
 

@Test
public void toStringContent() {
	FixedBackOff backOff = new FixedBackOff(200L, 10);
	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());
}
 

@Test
public void defaultInstance() {
	FixedBackOff backOff = new FixedBackOff();
	BackOffExecution execution = backOff.start();
	for (int i = 0; i < 100; i++) {
		assertEquals(FixedBackOff.DEFAULT_INTERVAL, execution.nextBackOff());
	}
}
 

@Test
public void toStringContent() {
	FixedBackOff backOff = new FixedBackOff(200L, 10);
	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());
}
 

@Test
public void maxAttemptsReached() {
	FixedBackOff backOff = new FixedBackOff(200L, 2);
	BackOffExecution execution = backOff.start();
	assertEquals(200L, execution.nextBackOff());
	assertEquals(200L, execution.nextBackOff());
	assertEquals(BackOffExecution.STOP, execution.nextBackOff());
}
 

@Test
public void startReturnDifferentInstances() {
	FixedBackOff backOff = new FixedBackOff(100L, 1);
	BackOffExecution execution = backOff.start();
	BackOffExecution execution2 = backOff.start();

	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);
	BackOffExecution execution = backOff.start();
	assertEquals(100L, execution.nextBackOff());

	backOff.setInterval(200L);
	backOff.setMaxAttempts(2);

	assertEquals(200L, execution.nextBackOff());
	assertEquals(BackOffExecution.STOP, execution.nextBackOff());
}
 

@Test
public void toStringContent() {
	FixedBackOff backOff = new FixedBackOff(200L, 10);
	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());
}
 

@Test
public void defaultInstance() {
	FixedBackOff backOff = new FixedBackOff();
	BackOffExecution execution = backOff.start();
	for (int i = 0; i < 100; i++) {
		assertEquals(FixedBackOff.DEFAULT_INTERVAL, execution.nextBackOff());
	}
}
 

@Test
public void liveUpdate() {
	FixedBackOff backOff = new FixedBackOff(100L, 1);
	BackOffExecution execution = backOff.start();
	assertEquals(100l, execution.nextBackOff());

	backOff.setInterval(200l);
	backOff.setMaxAttempts(2);

	assertEquals(200l, execution.nextBackOff());
	assertEquals(BackOffExecution.STOP, execution.nextBackOff());
}
 

@Test
public void maxAttemptsReached() {
	FixedBackOff backOff = new FixedBackOff(200L, 2);
	BackOffExecution execution = backOff.start();
	assertEquals(200l, execution.nextBackOff());
	assertEquals(200l, execution.nextBackOff());
	assertEquals(BackOffExecution.STOP, execution.nextBackOff());
}
 

@Test
public void startReturnDifferentInstances() {
	FixedBackOff backOff = new FixedBackOff(100L, 1);
	BackOffExecution execution = backOff.start();
	BackOffExecution execution2 = backOff.start();

	assertEquals(100l, execution.nextBackOff());
	assertEquals(100l, execution2.nextBackOff());
	assertEquals(BackOffExecution.STOP, execution.nextBackOff());
	assertEquals(BackOffExecution.STOP, execution2.nextBackOff());
}
 

public long syncAndReturn(List<String> roles) {
  FixedBackOff backoff = new FixedBackOff();
  backoff.setInterval(retryIntervalMs);
  backoff.setMaxAttempts(Math.floorDiv(syncDelayTimeoutMs, retryIntervalMs) + 1);
  BackOffExecution backOffExec = backoff.start();

  // after this point the execution will get rescheduled
  final long timeout = System.currentTimeMillis() + syncDelayTimeoutMs;

  if (!isServerHealthy()) {
    log.warn(
        "Server is currently UNHEALTHY. User permission role synchronization and "
            + "resolution may not complete until this server becomes healthy again.");
  }

  // Ensure we're going to reload app and service account definitions
  permissionsResolver.clearCache();

  while (true) {
    try {
      Map<String, UserPermission> combo = new HashMap<>();
      // force a refresh of the unrestricted user in case the backing repository is empty:
      combo.put(UnrestrictedResourceConfig.UNRESTRICTED_USERNAME, new UserPermission());
      Map<String, UserPermission> temp;
      if (!(temp = getUserPermissions(roles)).isEmpty()) {
        combo.putAll(temp);
      }
      if (!(temp = getServiceAccountsAsMap(roles)).isEmpty()) {
        combo.putAll(temp);
      }

      return updateUserPermissions(combo);
    } catch (ProviderException | PermissionResolutionException ex) {
      registry
          .counter(metricName("syncFailure"), "cause", ex.getClass().getSimpleName())
          .increment();
      Status status = healthIndicator.health().getStatus();
      long waitTime = backOffExec.nextBackOff();
      if (waitTime == BackOffExecution.STOP || System.currentTimeMillis() > timeout) {
        String cause = (waitTime == BackOffExecution.STOP) ? "backoff-exhausted" : "timeout";
        registry.counter("syncAborted", "cause", cause).increment();
        log.error("Unable to resolve service account permissions.", ex);
        return 0;
      }
      String message =
          new StringBuilder("User permission sync failed. ")
              .append("Server status is ")
              .append(status)
              .append(". Trying again in ")
              .append(waitTime)
              .append(" ms. Cause:")
              .append(ex.getMessage())
              .toString();
      if (log.isDebugEnabled()) {
        log.debug(message, ex);
      } else {
        log.warn(message);
      }

      try {
        Thread.sleep(waitTime);
      } catch (InterruptedException ignored) {
      }
    } finally {
      isServerHealthy();
    }
  }
}
 

@Test
public void noAttemptAtAll() {
	FixedBackOff backOff = new FixedBackOff(100L, 0L);
	BackOffExecution execution = backOff.start();
	assertEquals(BackOffExecution.STOP, execution.nextBackOff());
}
 

@Test
public void noAttemptAtAll() {
	FixedBackOff backOff = new FixedBackOff(100L, 0L);
	BackOffExecution execution = backOff.start();
	assertEquals(BackOffExecution.STOP, execution.nextBackOff());
}
 

@Test
public void noAttemptAtAll() {
	FixedBackOff backOff = new FixedBackOff(100L, 0L);
	BackOffExecution execution = backOff.start();
	assertEquals(BackOffExecution.STOP, execution.nextBackOff());
}