org.springframework.util.backoff.FixedBackOff Java Examples

/**
 * Configure a {@link BackOff} for the after rollback processor, based on the consumer
 * retry properties. If retry is disabled, return a {@link BackOff} that disables
 * retry. Otherwise calculate the {@link ExponentialBackOff#setMaxElapsedTime(long)}
 * so that the {@link BackOff} stops after the configured
 * {@link ExtendedConsumerProperties#getMaxAttempts()}.
 * @param extendedConsumerProperties the properties.
 * @return the backoff.
 */
private BackOff createBackOff(
		final ExtendedConsumerProperties<KafkaConsumerProperties> extendedConsumerProperties) {

	int maxAttempts = extendedConsumerProperties.getMaxAttempts();
	if (maxAttempts < 2) {
		return new FixedBackOff(0L, 0L);
	}
	int initialInterval = extendedConsumerProperties.getBackOffInitialInterval();
	double multiplier = extendedConsumerProperties.getBackOffMultiplier();
	int maxInterval = extendedConsumerProperties.getBackOffMaxInterval();
	ExponentialBackOff backOff = new ExponentialBackOff(initialInterval, multiplier);
	backOff.setMaxInterval(maxInterval);
	long maxElapsed = extendedConsumerProperties.getBackOffInitialInterval();
	double accum = maxElapsed;
	for (int i = 1; i < maxAttempts - 1; i++) {
		accum = accum * multiplier;
		if (accum > maxInterval) {
			accum = maxInterval;
		}
		maxElapsed += accum;
	}
	backOff.setMaxElapsedTime(maxElapsed);
	return backOff;
}
 

@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 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 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 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 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 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 backOffOverridesRecoveryInterval() {
	DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
	BackOff backOff = new FixedBackOff();
	factory.setBackOff(backOff);
	factory.setRecoveryInterval(2000L);

	SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
	MessageListener messageListener = new MessageListenerAdapter();
	endpoint.setMessageListener(messageListener);
	endpoint.setDestination("myQueue");
	DefaultMessageListenerContainer container = factory.createListenerContainer(endpoint);

	assertSame(backOff, new DirectFieldAccessor(container).getPropertyValue("backOff"));
}
 

@Test
public void backOffOverridesRecoveryInterval() {
	DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
	BackOff backOff = new FixedBackOff();
	factory.setBackOff(backOff);
	factory.setRecoveryInterval(2000L);

	SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
	MessageListener messageListener = new MessageListenerAdapter();
	endpoint.setMessageListener(messageListener);
	endpoint.setDestination("myQueue");
	DefaultMessageListenerContainer container = factory.createListenerContainer(endpoint);

	assertSame(backOff, new DirectFieldAccessor(container).getPropertyValue("backOff"));
}
 

@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 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());
}
 

@Bean
public ListenerContainerCustomizer<AbstractMessageListenerContainer<?, ?>> customizer() {
	return (container, dest, group) -> {
		container.setAfterRollbackProcessor(new DefaultAfterRollbackProcessor<>(new FixedBackOff(0L, 1L)));
		if ("input2".equals(dest)) {
			this.input2Container = container;
		}
	};
}
 

@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 backOffOverridesRecoveryInterval() {
	DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
	BackOff backOff = new FixedBackOff();
	factory.setBackOff(backOff);
	factory.setRecoveryInterval(2000L);

	SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
	MessageListener messageListener = new MessageListenerAdapter();
	endpoint.setMessageListener(messageListener);
	endpoint.setDestination("myQueue");
	DefaultMessageListenerContainer container = factory.createListenerContainer(endpoint);

	assertSame(backOff, new DirectFieldAccessor(container).getPropertyValue("backOff"));
}
 

@Bean
public ListenerContainerCustomizer<AbstractMessageListenerContainer<byte[], byte[]>> customizer() {
    // Disable retry in the AfterRollbackProcessor
    return (container, destination, group) -> container.setAfterRollbackProcessor(
            new DefaultAfterRollbackProcessor<byte[], byte[]>(
                    (record, exception) -> System.out.println("Discarding failed record: " + record),
                    new FixedBackOff(0L, 0)));
}
 

@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 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 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 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 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 noAttemptAtAll() {
	FixedBackOff backOff = new FixedBackOff(100L, 0L);
	BackOffExecution execution = backOff.start();
	assertEquals(BackOffExecution.STOP, execution.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();
    }
  }
}
 

private long getRecoveryInterval(String containerBeanName) {
	BackOff backOff = getBackOff(containerBeanName);
	assertEquals(FixedBackOff.class, backOff.getClass());
	return ((FixedBackOff)backOff).getInterval();
}
 

private FixedBackOff createDefaultBackOff(long interval) {
	return new FixedBackOff(interval, Long.MAX_VALUE);
}
 

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

private long getRecoveryInterval(String containerBeanName) {
	BackOff backOff = getBackOff(containerBeanName);
	assertEquals(FixedBackOff.class, backOff.getClass());
	return ((FixedBackOff)backOff).getInterval();
}
 

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

private long getRecoveryInterval(String containerBeanName) {
	BackOff backOff = getBackOff(containerBeanName);
	assertEquals(FixedBackOff.class, backOff.getClass());
	return ((FixedBackOff)backOff).getInterval();
}
 

/**
 * Specify the interval between recovery attempts, in <b>milliseconds</b>.
 * The default is 5000 ms, that is, 5 seconds. This is a convenience method
 * to create a {@link FixedBackOff} with the specified interval.
 * <p>For more recovery options, consider specifying a {@link BackOff}
 * instance instead.
 * @see #setBackOff(BackOff)
 * @see #handleListenerSetupFailure
 */
public void setRecoveryInterval(long recoveryInterval) {
	this.backOff = new FixedBackOff(recoveryInterval, Long.MAX_VALUE);
}