org.springframework.util.backoff.BackOff Java Examples

@Test
public void applyBackOff() {
	BackOff mock = mock(BackOff.class);
	BackOffExecution execution = mock(BackOffExecution.class);
	given(execution.nextBackOff()).willReturn(BackOffExecution.STOP);
	given(mock.start()).willReturn(execution);

	DefaultMessageListenerContainer container = createContainer(mock, createFailingContainerFactory());
	container.start();
	assertEquals(true, container.isRunning());

	container.refreshConnectionUntilSuccessful();

	assertEquals(false, container.isRunning());
	verify(mock).start();
	verify(execution).nextBackOff();
}
 

@Test
public void applyBackOff() {
	BackOff backOff = mock(BackOff.class);
	BackOffExecution execution = mock(BackOffExecution.class);
	given(execution.nextBackOff()).willReturn(BackOffExecution.STOP);
	given(backOff.start()).willReturn(execution);

	DefaultMessageListenerContainer container = createContainer(createFailingContainerFactory());
	container.setBackOff(backOff);
	container.start();
	assertEquals(true, container.isRunning());

	container.refreshConnectionUntilSuccessful();

	assertEquals(false, container.isRunning());
	verify(backOff).start();
	verify(execution).nextBackOff();
}
 

@Test
public void applyBackOffRetry() {
	BackOff backOff = mock(BackOff.class);
	BackOffExecution execution = mock(BackOffExecution.class);
	given(execution.nextBackOff()).willReturn(50L, BackOffExecution.STOP);
	given(backOff.start()).willReturn(execution);

	DefaultMessageListenerContainer container = createContainer(createFailingContainerFactory());
	container.setBackOff(backOff);
	container.start();
	container.refreshConnectionUntilSuccessful();

	assertEquals(false, container.isRunning());
	verify(backOff).start();
	verify(execution, times(2)).nextBackOff();
}
 

@Test
public void recoverResetBackOff() {
	BackOff backOff = mock(BackOff.class);
	BackOffExecution execution = mock(BackOffExecution.class);
	given(execution.nextBackOff()).willReturn(50L, 50L, 50L);  // 3 attempts max
	given(backOff.start()).willReturn(execution);

	DefaultMessageListenerContainer container = createContainer(createRecoverableContainerFactory(1));
	container.setBackOff(backOff);
	container.start();
	container.refreshConnectionUntilSuccessful();

	assertEquals(true, container.isRunning());
	verify(backOff).start();
	verify(execution, times(1)).nextBackOff();  // only on attempt as the second one lead to a recovery
}
 

/**
 * 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 applyBackOff() {
	BackOff backOff = mock(BackOff.class);
	BackOffExecution execution = mock(BackOffExecution.class);
	given(execution.nextBackOff()).willReturn(BackOffExecution.STOP);
	given(backOff.start()).willReturn(execution);

	DefaultMessageListenerContainer container = createContainer(createFailingContainerFactory());
	container.setBackOff(backOff);
	container.start();
	assertEquals(true, container.isRunning());

	container.refreshConnectionUntilSuccessful();

	assertEquals(false, container.isRunning());
	verify(backOff).start();
	verify(execution).nextBackOff();
}
 

@Test
public void applyBackOffRetry() {
	BackOff backOff = mock(BackOff.class);
	BackOffExecution execution = mock(BackOffExecution.class);
	given(execution.nextBackOff()).willReturn(50L, BackOffExecution.STOP);
	given(backOff.start()).willReturn(execution);

	DefaultMessageListenerContainer container = createContainer(createFailingContainerFactory());
	container.setBackOff(backOff);
	container.start();
	container.refreshConnectionUntilSuccessful();

	assertEquals(false, container.isRunning());
	verify(backOff).start();
	verify(execution, times(2)).nextBackOff();
}
 

@Test
public void recoverResetBackOff() {
	BackOff backOff = mock(BackOff.class);
	BackOffExecution execution = mock(BackOffExecution.class);
	given(execution.nextBackOff()).willReturn(50L, 50L, 50L);  // 3 attempts max
	given(backOff.start()).willReturn(execution);

	DefaultMessageListenerContainer container = createContainer(createRecoverableContainerFactory(1));
	container.setBackOff(backOff);
	container.start();
	container.refreshConnectionUntilSuccessful();

	assertEquals(true, container.isRunning());
	verify(backOff).start();
	verify(execution, times(1)).nextBackOff();  // only on attempt as the second one lead to a recovery
}
 

public ClientConfig registerClient() {
    BackOff exponentialBackOff = new ExponentialBackOff();
    BackOffExecution backOffExecution = exponentialBackOff.start();

    while (true) {
        try {
            return new CommandRegisterClient(artifactId, configServiceClient, clientName, clientId).execute();
        } catch (HystrixRuntimeException e) {
            RegisterClientExceptionHandler.handleRegisterClientException(e, exponentialBackOff, backOffExecution,
                    configServiceClient.getUrl());
        }
    }
}
 

@Test
public void applyBackOffRetry() {
	BackOff mock = mock(BackOff.class);
	BackOffExecution execution = mock(BackOffExecution.class);
	given(execution.nextBackOff()).willReturn(50L, BackOffExecution.STOP);
	given(mock.start()).willReturn(execution);

	DefaultMessageListenerContainer container = createContainer(mock, createFailingContainerFactory());
	container.start();
	container.refreshConnectionUntilSuccessful();

	assertEquals(false, container.isRunning());
	verify(mock).start();
	verify(execution, times(2)).nextBackOff();
}
 

@Test
public void recoverResetBackOff() {
	BackOff mock = mock(BackOff.class);
	BackOffExecution execution = mock(BackOffExecution.class);
	given(execution.nextBackOff()).willReturn(50L, 50L, 50L); // 3 attempts max
	given(mock.start()).willReturn(execution);

	DefaultMessageListenerContainer container = createContainer(mock, createRecoverableContainerFactory(1));
	container.start();
	container.refreshConnectionUntilSuccessful();

	assertEquals(true, container.isRunning());
	verify(mock).start();
	verify(execution, times(1)).nextBackOff(); // only on attempt as the second one lead to a recovery
}
 

@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 testRecoveryInterval() {
	Object testBackOff = context.getBean("testBackOff");
	BackOff backOff1 = getBackOff("listener1");
	BackOff backOff2 = getBackOff("listener2");
	long recoveryInterval3 = getRecoveryInterval(DefaultMessageListenerContainer.class.getName() + "#0");

	assertSame(testBackOff, backOff1);
	assertSame(testBackOff, backOff2);
	assertEquals(DefaultMessageListenerContainer.DEFAULT_RECOVERY_INTERVAL, recoveryInterval3);
}
 

@Test
public void testRecoveryInterval() {
	Object testBackOff = context.getBean("testBackOff");
	BackOff backOff1 = getBackOff("listener1");
	BackOff backOff2 = getBackOff("listener2");
	long recoveryInterval3 = getRecoveryInterval(DefaultMessageListenerContainer.class.getName() + "#0");

	assertSame(testBackOff, backOff1);
	assertSame(testBackOff, backOff2);
	assertEquals(DefaultMessageListenerContainer.DEFAULT_RECOVERY_INTERVAL, recoveryInterval3);
}
 

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

public static void handleRegisterClientException(HystrixRuntimeException e, BackOff exponentialBackOff,
                                                 BackOffExecution backOffExecution, String configServiceUrl) {
    Throwable cause = e.getCause();
    log.debug("Exception registering client, exception getMessage={}", e.getMessage());
    log.debug("Exception registering client, cause getMessage={}", cause.getMessage());

    if (cause instanceof ConnectException) {
        log.debug("Connection refused to ConfigService url={}", configServiceUrl);
    } else if (cause instanceof InternalServerErrorException) {
        log.debug("Internal server error in ConfigService url={}", configServiceUrl);
    } else if(cause instanceof NotFoundException) {
        log.debug("404 not found to ConfigService url={}", configServiceUrl);
    } else if (cause instanceof BadRequestException) {
        log.error("400 Bad Request. Probably need to fix something on the client. Exiting after a" +
                " wait, so as to not DDoS the server.");

        // TODO  Do a sensible BackOff implementation class comparissmnet before this!!!  
        SleepUtil.sleepWithLogging(((ExponentialBackOff)exponentialBackOff).getMaxInterval() * 2);
        System.exit(1);
    } else if (cause instanceof TimeoutException) {
        log.debug("CommandRegisterClient timed out.");
    } else {
        log.error("Couldn't handle exception: {}", e);
    }

    SleepUtil.sleepWithLogging(backOffExecution.nextBackOff());
}
 

@Test
public void testRecoveryInterval() {
	Object testBackOff = context.getBean("testBackOff");
	BackOff backOff1 = getBackOff("listener1");
	BackOff backOff2 = getBackOff("listener2");
	long recoveryInterval3 = getRecoveryInterval(DefaultMessageListenerContainer.class.getName() + "#0");

	assertSame(testBackOff, backOff1);
	assertSame(testBackOff, backOff2);
	assertEquals(DefaultMessageListenerContainer.DEFAULT_RECOVERY_INTERVAL, recoveryInterval3);
}
 

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

private BackOff getBackOff(String containerBeanName) {
	DefaultMessageListenerContainer container = this.context.getBean(containerBeanName, DefaultMessageListenerContainer.class);
	return (BackOff) new DirectFieldAccessor(container).getPropertyValue("backOff");
}
 

private BackOff getBackOff(String containerBeanName) {
	DefaultMessageListenerContainer container = this.context.getBean(containerBeanName, DefaultMessageListenerContainer.class);
	return (BackOff) new DirectFieldAccessor(container).getPropertyValue("backOff");
}
 

/**
 * @see DefaultMessageListenerContainer#setBackOff
 */
public void setBackOff(BackOff backOff) {
	this.backOff = backOff;
}
 

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

/**
 * @see DefaultMessageListenerContainer#setBackOff
 */
public void setBackOff(BackOff backOff) {
	this.backOff = backOff;
}
 

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

private BackOff getBackOff(String containerBeanName) {
	DefaultMessageListenerContainer container = this.context.getBean(containerBeanName, DefaultMessageListenerContainer.class);
	return (BackOff) new DirectFieldAccessor(container).getPropertyValue("backOff");
}
 

/**
 * @see DefaultMessageListenerContainer#setBackOff
 */
public void setBackOff(BackOff backOff) {
	this.backOff = backOff;
}
 

private DefaultMessageListenerContainer createContainer(BackOff backOff, ConnectionFactory connectionFactory) {

		Destination destination = new Destination() {};


		DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
		container.setConnectionFactory(connectionFactory);
		container.setCacheLevel(DefaultMessageListenerContainer.CACHE_NONE);
		container.setDestination(destination);
		container.setBackOff(backOff);
		return container;

	}
 

/**
 * Specify the {@link BackOff} instance to use to compute the interval
 * between recovery attempts. If the {@link BackOffExecution} implementation
 * returns {@link BackOffExecution#STOP}, this listener container will not further
 * attempt to recover.
 * <p>The {@link #setRecoveryInterval(long) recovery interval} is ignored
 * when this property is set.
 */
public void setBackOff(BackOff backOff) {
	this.backOff = backOff;
}
 

/**
 * Specify the {@link BackOff} instance to use to compute the interval
 * between recovery attempts. If the {@link BackOffExecution} implementation
 * returns {@link BackOffExecution#STOP}, this listener container will not further
 * attempt to recover.
 * <p>The {@link #setRecoveryInterval(long) recovery interval} is ignored
 * when this property is set.
 * @since 4.1
 */
public void setBackOff(BackOff backOff) {
	this.backOff = backOff;
}