Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright 2017-2019 original authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.micronaut.retry.intercept;
import io.micronaut.aop.InterceptPhase;
import io.micronaut.aop.MethodInterceptor;
import io.micronaut.aop.MethodInvocationContext;
import io.micronaut.context.event.ApplicationEventPublisher;
import io.micronaut.core.annotation.AnnotationValue;
import io.micronaut.core.async.publisher.Publishers;
import io.micronaut.core.convert.ConversionService;
import io.micronaut.core.convert.value.MutableConvertibleValues;
import io.micronaut.core.type.ReturnType;
import io.micronaut.inject.ExecutableMethod;
import io.micronaut.retry.RetryState;
import io.micronaut.retry.annotation.CircuitBreaker;
import io.micronaut.retry.annotation.Retryable;
import io.micronaut.retry.event.RetryEvent;
import io.micronaut.scheduling.TaskExecutors;
import io.micronaut.scheduling.executor.ExecutorType;
import io.micronaut.scheduling.executor.UserExecutorConfiguration;
import io.reactivex.Flowable;
import io.reactivex.functions.Function;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
import java.time.Duration;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.*;
import java.util.function.BiConsumer;
/**
* A {@link MethodInterceptor} that retries an operation according to the specified
* {@link Retryable} annotation.
*
* @author graemerocher
* @since 1.0
*/
@Singleton
public class DefaultRetryInterceptor implements MethodInterceptor {
private static final Logger LOG = LoggerFactory.getLogger(DefaultRetryInterceptor.class);
private static final int DEFAULT_CIRCUIT_BREAKER_TIMEOUT_IN_MILLIS = 20;
private final ApplicationEventPublisher eventPublisher;
private final ScheduledExecutorService executorService;
private final Map circuitContexts = new ConcurrentHashMap<>();
/**
* Construct a default retry method interceptor with the event publisher.
*
* @param eventPublisher The event publisher to publish retry events
* @deprecated Use {@link #DefaultRetryInterceptor(ApplicationEventPublisher, ExecutorService)} instead
*/
@Deprecated
public DefaultRetryInterceptor(ApplicationEventPublisher eventPublisher) {
this.eventPublisher = eventPublisher;
UserExecutorConfiguration configuration = UserExecutorConfiguration.of(ExecutorType.SCHEDULED);
this.executorService = Executors.newScheduledThreadPool(configuration.getCorePoolSize());
}
/**
* Construct a default retry method interceptor with the event publisher.
*
* @param eventPublisher The event publisher to publish retry events
* @param executorService The executor service to use for completable futures
*/
@Inject
public DefaultRetryInterceptor(ApplicationEventPublisher eventPublisher, @Named(TaskExecutors.SCHEDULED) ExecutorService executorService) {
this.eventPublisher = eventPublisher;
this.executorService = (ScheduledExecutorService) executorService;
}
@Override
public int getOrder() {
return InterceptPhase.RETRY.getPosition();
}
@Override
public Object intercept(MethodInvocationContext context) {
Optional> opt = context.findAnnotation(Retryable.class);
if (!opt.isPresent()) {
return context.proceed();
}
AnnotationValue retry = opt.get();
boolean isCircuitBreaker = context.hasStereotype(CircuitBreaker.class);
MutableRetryState retryState;
AnnotationRetryStateBuilder retryStateBuilder = new AnnotationRetryStateBuilder(
context
);
if (isCircuitBreaker) {
long timeout = context
.getValue(CircuitBreaker.class, "reset", Duration.class)
.map(Duration::toMillis).orElse(Duration.ofSeconds(DEFAULT_CIRCUIT_BREAKER_TIMEOUT_IN_MILLIS).toMillis());
retryState = circuitContexts.computeIfAbsent(
context.getExecutableMethod(),
method -> new CircuitBreakerRetry(timeout, retryStateBuilder, context, eventPublisher)
);
} else {
retryState = (MutableRetryState) retryStateBuilder.build();
}
retryState.open();
MutableConvertibleValues
