use of io.github.resilience4j.ratpack.recovery.RecoveryFunction in project resilience4j by resilience4j.
the class RateLimiterMethodInterceptor method invoke.
@SuppressWarnings("unchecked")
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
RateLimiter annotation = invocation.getMethod().getAnnotation(RateLimiter.class);
RecoveryFunction<?> recoveryFunction = annotation.recovery().newInstance();
if (registry == null) {
registry = RateLimiterRegistry.ofDefaults();
}
io.github.resilience4j.ratelimiter.RateLimiter rateLimiter = registry.rateLimiter(annotation.name());
if (rateLimiter == null) {
return invocation.proceed();
}
Class<?> returnType = invocation.getMethod().getReturnType();
if (Promise.class.isAssignableFrom(returnType)) {
Promise<?> result = (Promise<?>) proceed(invocation, rateLimiter, recoveryFunction);
if (result != null) {
RateLimiterTransformer transformer = RateLimiterTransformer.of(rateLimiter).recover(recoveryFunction);
result = result.transform(transformer);
}
return result;
} else if (Observable.class.isAssignableFrom(returnType)) {
Observable<?> result = (Observable<?>) proceed(invocation, rateLimiter, recoveryFunction);
if (result != null) {
RateLimiterOperator operator = RateLimiterOperator.of(rateLimiter);
result = result.lift(operator).onErrorReturn(t -> recoveryFunction.apply((Throwable) t));
}
return result;
} else if (Flowable.class.isAssignableFrom(returnType)) {
Flowable<?> result = (Flowable<?>) proceed(invocation, rateLimiter, recoveryFunction);
if (result != null) {
RateLimiterOperator operator = RateLimiterOperator.of(rateLimiter);
result = result.lift(operator).onErrorReturn(t -> recoveryFunction.apply((Throwable) t));
}
return result;
} else if (Single.class.isAssignableFrom(returnType)) {
Single<?> result = (Single<?>) proceed(invocation, rateLimiter, recoveryFunction);
if (result != null) {
RateLimiterOperator operator = RateLimiterOperator.of(rateLimiter);
result = result.lift(operator).onErrorReturn(t -> recoveryFunction.apply((Throwable) t));
}
return result;
} else if (CompletionStage.class.isAssignableFrom(returnType)) {
RateLimiterConfig rateLimiterConfig = rateLimiter.getRateLimiterConfig();
Duration timeoutDuration = rateLimiterConfig.getTimeoutDuration();
if (rateLimiter.getPermission(timeoutDuration)) {
return proceed(invocation, rateLimiter, recoveryFunction);
} else {
final CompletableFuture promise = new CompletableFuture<>();
Throwable t = new RequestNotPermitted("Request not permitted for limiter: " + rateLimiter.getName());
try {
promise.complete(recoveryFunction.apply(t));
} catch (Throwable t2) {
promise.completeExceptionally(t2);
}
return promise;
}
}
return handleProceedWithException(invocation, rateLimiter, recoveryFunction);
}
use of io.github.resilience4j.ratpack.recovery.RecoveryFunction in project resilience4j by resilience4j.
the class RetryMethodInterceptor method invoke.
@SuppressWarnings("unchecked")
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
Retry annotation = invocation.getMethod().getAnnotation(Retry.class);
io.github.resilience4j.retry.Retry retry = registry.retry(annotation.name());
if (retry == null) {
return invocation.proceed();
}
RecoveryFunction<?> recoveryFunction = annotation.recovery().newInstance();
if (registry == null) {
registry = RetryRegistry.ofDefaults();
}
Class<?> returnType = invocation.getMethod().getReturnType();
if (Promise.class.isAssignableFrom(returnType)) {
Promise<?> result = (Promise<?>) proceed(invocation, retry, recoveryFunction);
if (result != null) {
RetryTransformer transformer = RetryTransformer.of(retry).recover(recoveryFunction);
result = result.transform(transformer);
}
return result;
} else if (Observable.class.isAssignableFrom(returnType)) {
Observable<?> result = (Observable<?>) proceed(invocation, retry, recoveryFunction);
if (result != null) {
io.github.resilience4j.retry.transformer.RetryTransformer transformer = io.github.resilience4j.retry.transformer.RetryTransformer.of(retry);
result = result.compose(transformer).onErrorReturn(t -> recoveryFunction.apply((Throwable) t));
}
return result;
} else if (Flowable.class.isAssignableFrom(returnType)) {
Flowable<?> result = (Flowable<?>) proceed(invocation, retry, recoveryFunction);
if (result != null) {
io.github.resilience4j.retry.transformer.RetryTransformer transformer = io.github.resilience4j.retry.transformer.RetryTransformer.of(retry);
result = result.compose(transformer).onErrorReturn(t -> recoveryFunction.apply((Throwable) t));
}
return result;
} else if (Single.class.isAssignableFrom(returnType)) {
Single<?> result = (Single<?>) proceed(invocation, retry, recoveryFunction);
if (result != null) {
io.github.resilience4j.retry.transformer.RetryTransformer transformer = io.github.resilience4j.retry.transformer.RetryTransformer.of(retry);
result = result.compose(transformer).onErrorReturn(t -> recoveryFunction.apply((Throwable) t));
}
return result;
} else if (CompletionStage.class.isAssignableFrom(returnType)) {
CompletionStage stage = (CompletionStage) proceed(invocation, retry, recoveryFunction);
return executeCompletionStage(invocation, stage, retry.context(), recoveryFunction);
}
return proceed(invocation, retry, recoveryFunction);
}
use of io.github.resilience4j.ratpack.recovery.RecoveryFunction in project resilience4j by resilience4j.
the class CircuitBreakerMethodInterceptor method invoke.
@SuppressWarnings("unchecked")
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
CircuitBreaker annotation = invocation.getMethod().getAnnotation(CircuitBreaker.class);
RecoveryFunction<?> recoveryFunction = annotation.recovery().newInstance();
if (registry == null) {
registry = CircuitBreakerRegistry.ofDefaults();
}
io.github.resilience4j.circuitbreaker.CircuitBreaker breaker = registry.circuitBreaker(annotation.name());
if (breaker == null) {
return invocation.proceed();
}
Class<?> returnType = invocation.getMethod().getReturnType();
if (Promise.class.isAssignableFrom(returnType)) {
Promise<?> result = (Promise<?>) proceed(invocation, breaker, recoveryFunction);
if (result != null) {
CircuitBreakerTransformer transformer = CircuitBreakerTransformer.of(breaker).recover(recoveryFunction);
result = result.transform(transformer);
}
return result;
} else if (Observable.class.isAssignableFrom(returnType)) {
Observable<?> result = (Observable<?>) proceed(invocation, breaker, recoveryFunction);
if (result != null) {
CircuitBreakerOperator operator = CircuitBreakerOperator.of(breaker);
result = result.lift(operator).onErrorReturn(t -> recoveryFunction.apply((Throwable) t));
}
return result;
} else if (Flowable.class.isAssignableFrom(returnType)) {
Flowable<?> result = (Flowable<?>) proceed(invocation, breaker, recoveryFunction);
if (result != null) {
CircuitBreakerOperator operator = CircuitBreakerOperator.of(breaker);
result = result.lift(operator).onErrorReturn(t -> recoveryFunction.apply((Throwable) t));
}
return result;
} else if (Single.class.isAssignableFrom(returnType)) {
Single<?> result = (Single<?>) proceed(invocation, breaker, recoveryFunction);
if (result != null) {
CircuitBreakerOperator operator = CircuitBreakerOperator.of(breaker);
result = result.lift(operator).onErrorReturn(t -> recoveryFunction.apply((Throwable) t));
}
return result;
} else if (CompletionStage.class.isAssignableFrom(returnType)) {
final CompletableFuture promise = new CompletableFuture<>();
if (breaker.isCallPermitted()) {
CompletionStage<?> result = (CompletionStage<?>) proceed(invocation, breaker, recoveryFunction);
if (result != null) {
long start = System.nanoTime();
result.whenComplete((v, t) -> {
long durationInNanos = System.nanoTime() - start;
if (t != null) {
breaker.onError(durationInNanos, t);
try {
promise.complete(recoveryFunction.apply((Throwable) t));
} catch (Exception e) {
promise.completeExceptionally(e);
}
} else {
breaker.onSuccess(durationInNanos);
promise.complete(v);
}
});
}
} else {
Throwable t = new CircuitBreakerOpenException(String.format("CircuitBreaker '%s' is open", breaker.getName()));
try {
promise.complete(recoveryFunction.apply((Throwable) t));
} catch (Throwable t2) {
promise.completeExceptionally(t2);
}
}
return promise;
}
return proceed(invocation, breaker, recoveryFunction);
}
use of io.github.resilience4j.ratpack.recovery.RecoveryFunction in project resilience4j by resilience4j.
the class BulkheadMethodInterceptor method invoke.
@SuppressWarnings("unchecked")
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
Bulkhead annotation = invocation.getMethod().getAnnotation(Bulkhead.class);
RecoveryFunction<?> recoveryFunction = annotation.recovery().newInstance();
if (registry == null) {
registry = BulkheadRegistry.ofDefaults();
}
io.github.resilience4j.bulkhead.Bulkhead bulkhead = registry.bulkhead(annotation.name());
if (bulkhead == null) {
return invocation.proceed();
}
Class<?> returnType = invocation.getMethod().getReturnType();
if (Promise.class.isAssignableFrom(returnType)) {
Promise<?> result = (Promise<?>) invocation.proceed();
if (result != null) {
BulkheadTransformer transformer = BulkheadTransformer.of(bulkhead).recover(recoveryFunction);
result = result.transform(transformer);
}
return result;
} else if (Observable.class.isAssignableFrom(returnType)) {
Observable<?> result = (Observable<?>) invocation.proceed();
if (result != null) {
BulkheadOperator operator = BulkheadOperator.of(bulkhead);
result = result.lift(operator).onErrorReturn(t -> recoveryFunction.apply((Throwable) t));
}
return result;
} else if (Flowable.class.isAssignableFrom(returnType)) {
Flowable<?> result = (Flowable<?>) invocation.proceed();
if (result != null) {
BulkheadOperator operator = BulkheadOperator.of(bulkhead);
result = result.lift(operator).onErrorReturn(t -> recoveryFunction.apply((Throwable) t));
}
return result;
} else if (Single.class.isAssignableFrom(returnType)) {
Single<?> result = (Single<?>) invocation.proceed();
if (result != null) {
BulkheadOperator operator = BulkheadOperator.of(bulkhead);
result = result.lift(operator).onErrorReturn(t -> recoveryFunction.apply((Throwable) t));
}
return result;
} else if (CompletionStage.class.isAssignableFrom(returnType)) {
if (bulkhead.isCallPermitted()) {
return ((CompletionStage<?>) invocation.proceed()).handle((o, throwable) -> {
bulkhead.onComplete();
if (throwable != null) {
try {
return recoveryFunction.apply(throwable);
} catch (Exception e) {
throw Exceptions.uncheck(throwable);
}
} else {
return o;
}
});
} else {
final CompletableFuture promise = new CompletableFuture<>();
Throwable t = new BulkheadFullException(String.format("Bulkhead '%s' is full", bulkhead.getName()));
try {
promise.complete(recoveryFunction.apply(t));
} catch (Throwable t2) {
promise.completeExceptionally(t2);
}
return promise;
}
}
return handleOther(invocation, bulkhead, recoveryFunction);
}
Aggregations