@Override public final <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, RetryState retryState) throws E, ExhaustedRetryException { return regular.execute(retryCallback, retryState); }
@Override public final <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, RecoveryCallback<T> recoveryCallback) throws E { return regular.execute(retryCallback, recoveryCallback); }
@Override public final <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback) throws E { return regular.execute(retryCallback); }
@Override public final <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, RecoveryCallback<T> recoveryCallback, RetryState retryState) throws E { return regular.execute(retryCallback, recoveryCallback, retryState); }
@EventListener @Async public void handleEvent(ProjectRequestEvent event) { String json = null; try { ProjectRequestDocument document = this.documentFactory.createDocument(event); if (log.isDebugEnabled()) { log.debug("Publishing " + document); } json = toJson(document); RequestEntity<String> request = RequestEntity.post(this.requestUrl) .contentType(MediaType.APPLICATION_JSON).body(json); this.retryTemplate.execute((context) -> { this.restTemplate.exchange(request, String.class); return null; }); } catch (Exception ex) { log.warn(String.format( "Failed to publish stat to index, document follows %n%n%s%n", json), ex); } }
@Override public String doInTransaction(TransactionStatus status) { try { return retryTemplate.execute(callback, recoveryCallback, new DefaultRetryState(item)); } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } });
try { if (enableRetry) { return RocketMQInboundChannelAdapter.this.retryTemplate.execute( (RetryCallback<Acknowledgement, Exception>) context -> doSendMsgs( msgs, context),
@Override public Object doInTransaction(TransactionStatus status) { try { final String item = provider.read(); RetryCallback<Object, Exception> callback = new RetryCallback<Object, Exception>() { @Override public Object doWithRetry(RetryContext context) throws Exception { writer.write(Collections.singletonList(item)); return null; } }; return retryTemplate.execute(callback, new DefaultRetryState(item)); } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } });
@Override public Object doInTransaction(TransactionStatus status) { try { final Object item = provider.read(); RetryCallback<Object, Exception> callback = new RetryCallback<Object, Exception>() { @Override public Object doWithRetry(RetryContext context) throws Exception { writer.write(Collections.singletonList(item)); return null; } }; return retryTemplate.execute(callback, new DefaultRetryState(item)); } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } });
/** * 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(); }
retryTemplate.execute(new RetryCallback<String, Exception>() { @Override public String doWithRetry(RetryContext status) throws Exception {
retryTemplate.execute(callback, recoveryCallback, new DefaultRetryState(msg.getJMSMessageID()));
retryTemplate.execute(new RetryCallback<String, Exception>() { @Override public String doWithRetry(RetryContext status) throws Exception {
retryTemplate.execute(new RetryCallback<String, Exception>() { @Override public String doWithRetry(RetryContext status) throws Exception {
assertNotNull(text); retryTemplate.execute(new RetryCallback<String, Exception>() { @Override public String doWithRetry(RetryContext status) throws Exception {
retryTemplate.execute(new RetryCallback<String, Exception>() { @Override public String doWithRetry(RetryContext context) throws Exception {
@SuppressWarnings("unchecked") @Override public void onMessage(final Message message, final Channel channel) throws Exception { if (AmqpInboundGateway.this.retryTemplate == null) { try { org.springframework.messaging.Message<Object> converted = convert(message, channel); if (converted != null) { process(message, converted); } } finally { attributesHolder.remove(); } } else { org.springframework.messaging.Message<Object> converted = convert(message, channel); if (converted != null) { AmqpInboundGateway.this.retryTemplate.execute(context -> { StaticMessageHeaderAccessor.getDeliveryAttempt(converted).incrementAndGet(); process(message, converted); return null; }, (RecoveryCallback<Object>) AmqpInboundGateway.this.recoveryCallback); } } }
@Override protected Object doInvoke(final ExecutionCallback callback, Object target, final Message<?> message) throws Exception { RetryState retryState = null; retryState = this.retryStateGenerator.determineRetryState(message); messageHolder.set(message); try { return this.retryTemplate.execute(context -> callback.cloneAndExecute(), this.recoveryCallback, retryState); } catch (MessagingException e) { if (e.getFailedMessage() == null) { throw new MessagingException(message, "Failed to invoke handler", e); } throw e; } catch (Exception e) { throw new MessagingException(message, "Failed to invoke handler", unwrapExceptionIfNecessary(e)); } finally { messageHolder.remove(); } }
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; }); }
@Override public void onMessage(final ConsumerRecord<K, V> record, final Acknowledgment acknowledgment, final Consumer<?, ?> consumer) { RetryState retryState = null; if (this.stateful) { retryState = new DefaultRetryState(record.topic() + "-" + record.partition() + "-" + record.offset()); } getRetryTemplate().execute(context -> { context.setAttribute(CONTEXT_RECORD, record); switch (RetryingMessageListenerAdapter.this.delegateType) { case ACKNOWLEDGING_CONSUMER_AWARE: context.setAttribute(CONTEXT_ACKNOWLEDGMENT, acknowledgment); context.setAttribute(CONTEXT_CONSUMER, consumer); RetryingMessageListenerAdapter.this.delegate.onMessage(record, acknowledgment, consumer); break; case ACKNOWLEDGING: context.setAttribute(CONTEXT_ACKNOWLEDGMENT, acknowledgment); RetryingMessageListenerAdapter.this.delegate.onMessage(record, acknowledgment); break; case CONSUMER_AWARE: context.setAttribute(CONTEXT_CONSUMER, consumer); RetryingMessageListenerAdapter.this.delegate.onMessage(record, consumer); break; case SIMPLE: RetryingMessageListenerAdapter.this.delegate.onMessage(record); } return null; }, getRecoveryCallback(), retryState); }