public StatefulRetryOperationsInterceptor() { RetryTemplate retryTemplate = new RetryTemplate(); retryTemplate.setRetryPolicy(new NeverRetryPolicy()); this.retryOperations = retryTemplate; }
private RetryTemplate createTemplate(String[] listenersBeanNames) { RetryTemplate template = new RetryTemplate(); if (listenersBeanNames.length > 0) { template.setListeners(getListenersBeans(listenersBeanNames)); } else if (globalListeners !=null) { template.setListeners(globalListeners); } return template; }
@Before public void onSetUpInTransaction() throws Exception { retryTemplate = new RetryTemplate(); }
@Bean @ConditionalOnMissingBean(name = "statsRetryTemplate") public RetryTemplate statsRetryTemplate() { RetryTemplate retryTemplate = new RetryTemplate(); ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy(); backOffPolicy.setInitialInterval(3000L); backOffPolicy.setMultiplier(3); SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy( this.statsProperties.getElastic().getMaxAttempts(), Collections.singletonMap(Exception.class, true)); retryTemplate.setBackOffPolicy(backOffPolicy); retryTemplate.setRetryPolicy(retryPolicy); return retryTemplate; }
/** * Execute a single simulation * @return The sleeps which occurred within the single simulation. */ public List<Long> executeSingleSimulation() { StealingSleeper stealingSleeper = new StealingSleeper(); SleepingBackOffPolicy<?> stealingBackoff = backOffPolicy.withSleeper(stealingSleeper); RetryTemplate template = new RetryTemplate(); template.setBackOffPolicy(stealingBackoff); template.setRetryPolicy(retryPolicy); try { template.execute(new FailingRetryCallback()); } catch(FailingRetryException e) { } catch(Throwable e) { throw new RuntimeException("Unexpected exception", e); } return stealingSleeper.getSleeps(); }
@Before public void onSetUp() throws Exception { getMessages(); // drain queue jdbcTemplate.execute("delete from T_BARS"); jmsTemplate.convertAndSend("queue", "foo"); provider = new ItemReader<String>() { @Override public String read() { String text = (String) jmsTemplate.receiveAndConvert("queue"); list.add(text); return text; } }; retryTemplate = new RetryTemplate(); }
@Before public void onSetUp() throws Exception { getMessages(); // drain queue jdbcTemplate.execute("delete from T_BARS"); jmsTemplate.convertAndSend("queue", "foo"); jmsTemplate.convertAndSend("queue", "bar"); provider = new ItemReader<String>() { @Override public String read() { String text = (String) jmsTemplate.receiveAndConvert("queue"); list.add(text); return text; } }; retryTemplate = new RetryTemplate(); }
@Test public void testFailureAndRecovery() throws Exception { final RetryTemplate retryTemplate = new RetryTemplate(); retryTemplate.setRetryPolicy(new NeverRetryPolicy()); container.setMessageListener(new MessageListener() {
@Test public void testRecoveryCallbackSimple() { final AtomicReference<RetryContext> context = new AtomicReference<>(); RetryingMessageListenerAdapter<String, String> adapter = new RetryingMessageListenerAdapter<>( r -> { throw new RuntimeException(); }, new RetryTemplate(), c -> { context.set(c); return null; }); @SuppressWarnings("unchecked") ConsumerRecord<String, String> record = mock(ConsumerRecord.class); adapter.onMessage(record, mock(Acknowledgment.class), mock(Consumer.class)); assertThat(context.get()).isNotNull(); assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_ACKNOWLEDGMENT)).isNull(); assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_RECORD)).isSameAs(record); assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_CONSUMER)).isNull(); }
@Test public void testRecoveryCallbackAckOnly() { final AtomicReference<RetryContext> context = new AtomicReference<>(); RetryingMessageListenerAdapter<String, String> adapter = new RetryingMessageListenerAdapter<>( (AcknowledgingMessageListener<String, String>) (r, a) -> { throw new RuntimeException(); }, new RetryTemplate(), c -> { context.set(c); return null; }); @SuppressWarnings("unchecked") ConsumerRecord<String, String> record = mock(ConsumerRecord.class); Acknowledgment ack = mock(Acknowledgment.class); adapter.onMessage(record, ack, mock(Consumer.class)); assertThat(context.get()).isNotNull(); assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_ACKNOWLEDGMENT)).isSameAs(ack); assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_RECORD)).isSameAs(record); assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_CONSUMER)).isNull(); }
public void restart(final int index) throws Exception { //NOSONAR // retry restarting repeatedly, first attempts may fail SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(10, // NOSONAR magic # Collections.singletonMap(Exception.class, true)); ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy(); backOffPolicy.setInitialInterval(100); // NOSONAR magic # backOffPolicy.setMaxInterval(1000); // NOSONAR magic # backOffPolicy.setMultiplier(2); // NOSONAR magic # RetryTemplate retryTemplate = new RetryTemplate(); retryTemplate.setRetryPolicy(retryPolicy); retryTemplate.setBackOffPolicy(backOffPolicy); retryTemplate.execute(context -> { this.kafkaServers.get(index).startup(); return null; }); }
@Test public void testRecoveryCallbackConsumerOnly() { final AtomicReference<RetryContext> context = new AtomicReference<>(); RetryingMessageListenerAdapter<String, String> adapter = new RetryingMessageListenerAdapter<>( (ConsumerAwareMessageListener<String, String>) (r, c) -> { throw new RuntimeException(); }, new RetryTemplate(), c -> { context.set(c); return null; }); @SuppressWarnings("unchecked") ConsumerRecord<String, String> record = mock(ConsumerRecord.class); Consumer<?, ?> consumer = mock(Consumer.class); adapter.onMessage(record, mock(Acknowledgment.class), consumer); assertThat(context.get()).isNotNull(); assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_ACKNOWLEDGMENT)).isNull(); assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_RECORD)).isSameAs(record); assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_CONSUMER)).isSameAs(consumer); }
@Test public void testRecoveryCallbackAckAndConsumer() { final AtomicReference<RetryContext> context = new AtomicReference<>(); RetryingMessageListenerAdapter<String, String> adapter = new RetryingMessageListenerAdapter<>( (AcknowledgingConsumerAwareMessageListener<String, String>) (r, a, c) -> { throw new RuntimeException(); }, new RetryTemplate(), c -> { context.set(c); return null; }); @SuppressWarnings("unchecked") ConsumerRecord<String, String> record = mock(ConsumerRecord.class); Acknowledgment ack = mock(Acknowledgment.class); Consumer<?, ?> consumer = mock(Consumer.class); adapter.onMessage(record, ack, consumer); assertThat(context.get()).isNotNull(); assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_ACKNOWLEDGMENT)).isSameAs(ack); assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_RECORD)).isSameAs(record); assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_CONSUMER)).isSameAs(consumer); }
@Bean public KafkaListenerContainerFactory<?> kafkaListenerContainerFactory() { ConcurrentKafkaListenerContainerFactory<Integer, String> factory = new ConcurrentKafkaListenerContainerFactory<>(); factory.setConsumerFactory(consumerFactory()); factory.setErrorHandler(new SeekToCurrentErrorHandler() { @Override public void handle(Exception thrownException, List<ConsumerRecord<?, ?>> records, Consumer<?, ?> consumer, MessageListenerContainer container) { Config.this.seekPerformed = true; super.handle(thrownException, records, consumer, container); } }); factory.setStatefulRetry(true); factory.setRetryTemplate(new RetryTemplate()); factory.setRecoveryCallback(c -> { this.latch2.countDown(); return null; }); return factory; }
RequestHandlerRetryAdvice advice = new RequestHandlerRetryAdvice(); RetryTemplate retryTemplate = new RetryTemplate();
private RetryTemplate createRetryTemplate(String serviceName, HttpRequest request, LoadBalancedRetryPolicy retryPolicy) { RetryTemplate template = new RetryTemplate(); BackOffPolicy backOffPolicy = lbRetryFactory.createBackOffPolicy(serviceName); template.setBackOffPolicy(backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy); template.setThrowLastExceptionOnExhausted(true); RetryListener[] retryListeners = lbRetryFactory.createRetryListeners(serviceName); if (retryListeners != null && retryListeners.length != 0) { template.setListeners(retryListeners); } template.setRetryPolicy( !lbProperties.isEnabled() || retryPolicy == null ? new NeverRetryPolicy() : new InterceptorRetryPolicy(request, retryPolicy, loadBalancer, serviceName)); return template; } }
@Test public void testRetryWithinOnMessageGateway() throws Exception { ConnectionFactory connectionFactory = mock(ConnectionFactory.class); AbstractMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory); AmqpInboundGateway adapter = new AmqpInboundGateway(container); adapter.setRequestChannel(new DirectChannel()); adapter.setRetryTemplate(new RetryTemplate()); QueueChannel errors = new QueueChannel(); ErrorMessageSendingRecoverer recoveryCallback = new ErrorMessageSendingRecoverer(errors); recoveryCallback.setErrorMessageStrategy(new AmqpMessageHeaderErrorMessageStrategy()); adapter.setRecoveryCallback(recoveryCallback); adapter.afterPropertiesSet(); ChannelAwareMessageListener listener = (ChannelAwareMessageListener) container.getMessageListener(); listener.onMessage(org.springframework.amqp.core.MessageBuilder.withBody("foo".getBytes()) .andProperties(new MessageProperties()).build(), null); Message<?> errorMessage = errors.receive(0); assertNotNull(errorMessage); assertThat(errorMessage.getPayload(), instanceOf(MessagingException.class)); MessagingException payload = (MessagingException) errorMessage.getPayload(); assertThat(payload.getMessage(), containsString("Dispatcher has no")); assertThat(StaticMessageHeaderAccessor.getDeliveryAttempt(payload.getFailedMessage()).get(), equalTo(3)); org.springframework.amqp.core.Message amqpMessage = errorMessage.getHeaders() .get(AmqpMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE, org.springframework.amqp.core.Message.class); assertThat(amqpMessage, notNullValue()); assertNull(errors.receive(0)); }
@Test public void testRetryWithinOnMessageAdapter() throws Exception { ConnectionFactory connectionFactory = mock(ConnectionFactory.class); AbstractMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory); AmqpInboundChannelAdapter adapter = new AmqpInboundChannelAdapter(container); adapter.setOutputChannel(new DirectChannel()); adapter.setRetryTemplate(new RetryTemplate()); QueueChannel errors = new QueueChannel(); ErrorMessageSendingRecoverer recoveryCallback = new ErrorMessageSendingRecoverer(errors); recoveryCallback.setErrorMessageStrategy(new AmqpMessageHeaderErrorMessageStrategy()); adapter.setRecoveryCallback(recoveryCallback); adapter.afterPropertiesSet(); ChannelAwareMessageListener listener = (ChannelAwareMessageListener) container.getMessageListener(); listener.onMessage(org.springframework.amqp.core.MessageBuilder.withBody("foo".getBytes()) .andProperties(new MessageProperties()).build(), null); Message<?> errorMessage = errors.receive(0); assertNotNull(errorMessage); assertThat(errorMessage.getPayload(), instanceOf(MessagingException.class)); MessagingException payload = (MessagingException) errorMessage.getPayload(); assertThat(payload.getMessage(), containsString("Dispatcher has no")); assertThat(StaticMessageHeaderAccessor.getDeliveryAttempt(payload.getFailedMessage()).get(), equalTo(3)); org.springframework.amqp.core.Message amqpMessage = errorMessage.getHeaders() .get(AmqpMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE, org.springframework.amqp.core.Message.class); assertThat(amqpMessage, notNullValue()); assertNull(errors.receive(0)); }
@Bean public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<Integer, String>> kafkaManualAckListenerContainerFactory() { ConcurrentKafkaListenerContainerFactory<Integer, String> factory = new ConcurrentKafkaListenerContainerFactory<>(); factory.setConsumerFactory(configuredConsumerFactory("clientIdViaProps3")); ContainerProperties props = factory.getContainerProperties(); props.setAckMode(AckMode.MANUAL_IMMEDIATE); props.setIdleEventInterval(100L); factory.setRecordFilterStrategy(manualFilter()); factory.setAckDiscarded(true); factory.setRetryTemplate(new RetryTemplate()); factory.setRecoveryCallback(c -> null); return factory; }
ErrorMessageSendingRecoverer recoverer = new ErrorMessageSendingRecoverer(errors); advice.setRecoveryCallback(recoverer); RetryTemplate retryTemplate = new RetryTemplate(); retryTemplate.setRetryPolicy(new SimpleRetryPolicy() {