public FallbackHandler create()

in safeguard-impl/src/main/java/org/apache/safeguard/impl/fallback/FallbackInterceptor.java [137:227]
88 lines of code
16 McCabe index (conditional complexity)

        public FallbackHandler<?> create(final InvocationContext context) {
            if (!mapper.isEnabled(context.getMethod(), Fallback.class)) {
                return (FallbackHandler<Object>) context13 -> {
                    final Throwable failure = context13.getFailure();
                    if (RuntimeException.class.isInstance(failure)) {
                        throw RuntimeException.class.cast(failure);
                    }
                    if (Error.class.isInstance(failure)) {
                        throw Error.class.cast(failure);
                    }
                    throw new IllegalStateException(failure);
                };
            }

            final Fallback fallback = mapper.map(finder.findAnnotation(Fallback.class, context), context.getMethod(), Fallback.class);
            final Class<? extends FallbackHandler<?>> value = fallback.value();
            final String method = fallback.fallbackMethod();
            if (!method.isEmpty() && value != Fallback.DEFAULT.class) {
                throw new FaultToleranceDefinitionException("You can't set a method and handler as fallback on " + context.getMethod());
            }

            FallbackHandler<?> handler;
            if (value != Fallback.DEFAULT.class) {
                Stream.of(value.getGenericInterfaces())
                        .filter(ParameterizedType.class::isInstance)
                        .map(ParameterizedType.class::cast)
                        .filter(it -> FallbackHandler.class == it.getRawType())
                        .findFirst()
                        .filter(it -> it.getActualTypeArguments().length == 1)
                        .filter(it -> {
                            final Class<?> expected = extension.toClass(context.getMethod().getReturnType());
                            final Class<?> actual = extension.toClass(it.getActualTypeArguments()[0]);
                            return expected.isAssignableFrom(actual);
                        })
                        .orElseThrow(() -> new FaultToleranceDefinitionException("handler does not match method: " + context.getMethod()));
                final Set<Bean<?>> beans = beanManager.getBeans(value);
                final Bean<?> handlerBean = beanManager.resolve(beans);
                final CreationalContext<Object> creationalContext = beanManager.createCreationalContext(null);
                if (!beanManager.isNormalScope(handlerBean.getScope())) {
                    contexts.add(creationalContext);
                }
                final FallbackHandler fallbackHandler = FallbackHandler.class.cast(
                        beanManager.getReference(handlerBean, FallbackHandler.class, creationalContext));
                handler = fallbackHandler;
            } else {
                try {
                    final Method fallbackMethod = ofNullable(context.getTarget())
                            .map(Object::getClass)
                            .orElseGet(() -> Class.class.cast(context.getMethod().getDeclaringClass()))
                            .getMethod(method, context.getMethod().getParameterTypes());
                    if (!extension.toClass(context.getMethod()
                                                  .getReturnType())
                                  .isAssignableFrom(extension.toClass(fallbackMethod.getReturnType())) || !Arrays.equals(
                            context.getMethod()
                                   .getParameterTypes(), fallbackMethod.getParameterTypes())) {
                        throw new FaultToleranceDefinitionException("handler method does not match method: " + context.getMethod());
                    }
                    if (!fallbackMethod.isAccessible()) {
                        fallbackMethod.setAccessible(true);
                    }
                    handler = (FallbackHandler<Object>) context1 -> {
                        try {
                            return fallbackMethod.invoke(
                                    EnrichedExecutionContext.class.cast(context1).getTarget(), context1.getParameters());
                        } catch (final IllegalAccessException e) {
                            throw new IllegalStateException(e);
                        } catch (final InvocationTargetException e) {
                            final Throwable targetException = e.getTargetException();
                            if (RuntimeException.class.isInstance(targetException)) {
                                throw RuntimeException.class.cast(targetException);
                            }
                            if (Error.class.isInstance(targetException)) {
                                throw Error.class.cast(targetException);
                            }
                            throw new IllegalStateException(targetException);
                        }
                    };
                } catch (final NoSuchMethodException e) {
                    throw new FaultToleranceDefinitionException("No method " + method + " in " + context.getTarget());
                }
            }

            final String metricsName = "ft." + context.getMethod().getDeclaringClass().getCanonicalName() + "."
                    + context.getMethod().getName() + ".fallback.calls.total";
            final FaultToleranceMetrics.Counter counter = metrics.counter(metricsName,
                    "Number of times the fallback handler or method was called");
            return (FallbackHandler<Object>) context12 -> {
                counter.inc();
                return handler.handle(context12);
            };
        }