/** * 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(); }
public void registerListener(RetryListener listener) { delegate.registerListener(listener); regular.registerListener(listener); }
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; }
public StatefulRetryOperationsInterceptor() { RetryTemplate retryTemplate = new RetryTemplate(); retryTemplate.setRetryPolicy(new NeverRetryPolicy()); this.retryOperations = 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; }
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; } }
public DefaultRetryPolicyAdvice(MessageRecoverer messageRecoverer, RetryPolicy retryPolicy) { RetryTemplate retryTemplate = new RetryTemplate(); retryTemplate.setBackOffPolicy(createBackOffPolicy()); retryTemplate.setRetryPolicy(retryPolicy); retryTemplate.registerListener(new RetryErrorListener()); StatefulRetryOperationsInterceptorFactoryBean factory = new StatefulRetryOperationsInterceptorFactoryBean(); factory.setRetryOperations(retryTemplate); factory.setMessageKeyGenerator(new DefaultMessageKeyGenerator()); factory.setMessageRecoverer(messageRecoverer); this.delegate = factory.getObject(); }
@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); }
@Before public void onSetUpInTransaction() throws Exception { retryTemplate = new RetryTemplate(); }
private MethodInterceptor getStatefulInterceptor(Object target, Method method, Retryable retryable) { RetryTemplate template = createTemplate(retryable.listeners()); template.setRetryContextCache(this.retryContextCache); breaker.setOpenTimeout(getOpenTimeout(circuit)); breaker.setResetTimeout(getResetTimeout(circuit)); template.setRetryPolicy(breaker); template.setBackOffPolicy(new NoBackOffPolicy()); String label = circuit.label(); if (!StringUtils.hasText(label)) { template.setRetryPolicy(policy); template.setBackOffPolicy(getBackoffPolicy(retryable.backoff())); String label = retryable.label(); return RetryInterceptorBuilder.stateful()
private MethodInterceptor getStatelessInterceptor(Object target, Method method, Retryable retryable) { RetryTemplate template = createTemplate(retryable.listeners()); template.setRetryPolicy(getRetryPolicy(retryable)); template.setBackOffPolicy(getBackoffPolicy(retryable.backoff())); return RetryInterceptorBuilder.stateless() .retryOperations(template) .label(retryable.label()) .recoverer(getRecoverer(target, method)) .build(); }
protected RetryOperations createRetryOperations(RetryListener listener, int maxAttempts, List<Class<? extends Throwable>> retryableErrors) { Map<Class<? extends Throwable>, Boolean> retryableExceptions = new HashMap<>(retryableErrors.size()); retryableErrors.forEach(error -> retryableExceptions.put(error, true)); SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(maxAttempts, retryableExceptions); RetryTemplate retryTemplate = new RetryTemplate(); retryTemplate.setRetryPolicy(retryPolicy); retryTemplate.registerListener(listener); return retryTemplate; }
public void setBackOffPolicy(BackOffPolicy backOffPolicy) { delegate.setBackOffPolicy(backOffPolicy); regular.setBackOffPolicy(backOffPolicy); }
public void setRetryPolicy(RetryPolicy retryPolicy) { this.retryPolicy = retryPolicy; delegate.setRetryPolicy(retryPolicy); regular.setRetryPolicy(retryPolicy); }
public void setListeners(RetryListener[] listeners) { delegate.setListeners(listeners); regular.setListeners(listeners); }
@Override public void afterPropertiesSet() throws Exception { // Validate all job parameters Assert.notNull(parser, "The 'parser' property must have a value"); Assert.notNull(request, "The 'request' property must have a value"); Assert.notNull(streamer, "The 'streamer' property must have a value"); Assert.notNull(retryPolicy, "The 'retryPolicy' property must have a value"); Assert.notNull(backOffPolicy, "The 'backOffPolicy' property must have a value"); retryTemplate = new RetryTemplate(); retryTemplate.setRetryPolicy(retryPolicy); retryTemplate.setBackOffPolicy(backOffPolicy); }
@Test public void testFailureAndRecovery() throws Exception { final RetryTemplate retryTemplate = new RetryTemplate(); retryTemplate.setRetryPolicy(new NeverRetryPolicy()); container.setMessageListener(new MessageListener() { @Override
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; } }
public DefaultRetryPolicyAdvice(MessageRecoverer messageRecoverer, RetryPolicy retryPolicy) { RetryTemplate retryTemplate = new RetryTemplate(); retryTemplate.setBackOffPolicy(createBackOffPolicy()); retryTemplate.setRetryPolicy(retryPolicy); retryTemplate.registerListener(new RetryErrorListener()); StatefulRetryOperationsInterceptorFactoryBean factory = new StatefulRetryOperationsInterceptorFactoryBean(); factory.setRetryOperations(retryTemplate); factory.setMessageKeyGenerator(new DefaultMessageKeyGenerator()); factory.setMessageRecoverer(messageRecoverer); this.delegate = factory.getObject(); }
@Override public final <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, RetryState retryState) throws E, ExhaustedRetryException { return regular.execute(retryCallback, retryState); }