upstream.connect(downstream); };
chain.prefix(prefix, chain1 -> { chain1.get("events", ctx -> Promise.<RetryEventsEndpointResponse>async(d -> { List<RetryEventDTO> eventsList = eventConsumerRegistry.getAllEventConsumer() .flatMap(CircularEventConsumer::getBufferedEvents) .sorted(Comparator.comparing(RetryEvent::getCreationTime)) .map(RetryEventDTO::createRetryEventDTO).toJavaList(); d.success(new RetryEventsEndpointResponse(eventsList)); }).then(r -> ctx.render(Jackson.json(r))) ); chain1.get("stream/events", ctx -> { chain1.get("events/:name", ctx -> { String retryName = ctx.getPathTokens().get("name"); Promise.<RetryEventsEndpointResponse>async(d -> { List<RetryEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(retryName) .getBufferedEvents() .sorted(Comparator.comparing(RetryEvent::getCreationTime)) .map(RetryEventDTO::createRetryEventDTO).toJavaList(); d.success(new RetryEventsEndpointResponse(eventsList)); }).then(r -> ctx.render(Jackson.json(r))); String retryName = ctx.getPathTokens().get("name"); String eventType = ctx.getPathTokens().get("type"); Promise.<RetryEventsEndpointResponse>async(d -> { List<RetryEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(retryName) .getBufferedEvents() .filter(event -> event.getEventType() == RetryEvent.Type.valueOf(eventType.toUpperCase()))
if (result != null) { RetryTransformer transformer = RetryTransformer.of(retry).recover(recoveryFunction); result = result.transform(transformer); RetryTransformer transformer = RetryTransformer.of(retry).recover(recoveryFunction); final Flux<?> temp = result; Promise<?> promise = Promise.async(f -> temp.collectList().subscribe(f::success, f::error)).transform(transformer); Flux next = Flux.create(subscriber -> promise.onError(subscriber::error).then(value -> { subscriber.next(value); subscriber.complete(); RetryTransformer transformer = RetryTransformer.of(retry).recover(recoveryFunction); final Mono<?> temp = result; Promise<?> promise = Promise.async(f -> temp.subscribe(f::success, f::error)).transform(transformer); Mono next = Mono.create(subscriber -> promise.onError(subscriber::error).then(subscriber::success) ); result = recoveryFunction.onErrorResume(next);
/** * Signals this downstream, based on the given result. * * @param result the result to signal */ default void accept(Result<? extends T> result) { if (result.isError()) { error(result.getThrowable()); } else { success(result.getValue()); } }
/** * Signals this downstream, based on the given result. * * @param result the result to signal */ default void accept(ExecResult<? extends T> result) { if (result.isComplete()) { complete(); } else if (result.isError()) { error(result.getThrowable()); } else { success(result.getValue()); } }
/** * Convert a {@link CompletableFuture} into a promise. * <p> * @param future the {@link CompletableFuture} to convert into a {@link Promise} * @param <T> The type of the promised value * @return a {@link Promise} that will be consumed on the current execution thread. * @since 1.6 */ static <T> Promise<T> toPromise(CompletableFuture<T> future) { return async(downstream -> downstream.accept(future)); }
/** * Executes the given action with the promise value, on a blocking thread. * <p> * Similar to {@link #blockingMap(Function)}, but does not provide a new value. * This can be used to do something with the value, without terminating the promise. * * @param action the action to to perform with the value, on a blocking thread * @return a promise for the same value given to the action */ default Promise<T> blockingOp(Action<? super T> action) { return flatMap(t -> Blocking.op(action.curry(t)).map(() -> t)); }
if (result != null) { CircuitBreakerTransformer transformer = CircuitBreakerTransformer.of(breaker).recover(recoveryFunction); result = result.transform(transformer);
/** * A ref to the execution that forked this execution, if it has a parent. * * @return a ref to the execution that forked this execution * @since 1.6 */ default Optional<ExecutionRef> maybeParent() { return getRef().maybeParent(); }
/** * A ref to the execution that forked this execution. * * @throws IllegalStateException if this is a top level exception with no parent * @return a ref to the execution that forked this execution * @see #maybeParent() * @since 1.6 */ default ExecutionRef getParent() { return getRef().getParent(); }
chain.prefix(prefix, chain1 -> { chain1.get("events", ctx -> Promise.<RateLimiterEventsEndpointResponse>async(d -> { List<RateLimiterEventDTO> eventsList = eventConsumerRegistry.getAllEventConsumer() .flatMap(CircularEventConsumer::getBufferedEvents) .sorted(Comparator.comparing(RateLimiterEvent::getCreationTime)) .map(RateLimiterEventDTO::createRateLimiterEventDTO).toJavaList(); d.success(new RateLimiterEventsEndpointResponse(eventsList)); }).then(r -> ctx.render(Jackson.json(r))) ); chain1.get("stream/events", ctx -> { chain1.get("events/:name", ctx -> { String rateLimiterName = ctx.getPathTokens().get("name"); Promise.<RateLimiterEventsEndpointResponse>async(d -> { List<RateLimiterEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(rateLimiterName) .getBufferedEvents() .sorted(Comparator.comparing(RateLimiterEvent::getCreationTime)) .map(RateLimiterEventDTO::createRateLimiterEventDTO).toJavaList(); d.success(new RateLimiterEventsEndpointResponse(eventsList)); }).then(r -> ctx.render(Jackson.json(r))); String rateLimiterName = ctx.getPathTokens().get("name"); String eventType = ctx.getPathTokens().get("type"); Promise.<RateLimiterEventsEndpointResponse>async(d -> { List<RateLimiterEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(rateLimiterName) .getBufferedEvents() .filter(event -> event.getEventType() == RateLimiterEvent.Type.valueOf(eventType.toUpperCase()))
@Override public Upstream<T> apply(Upstream<? extends T> upstream) throws Exception { return down -> { long start; if (circuitBreaker.isCallPermitted()) { start = System.nanoTime(); upstream.connect(new Downstream<T>() { @Override public void success(T value) { long durationInNanos = System.nanoTime() - start; circuitBreaker.onSuccess(durationInNanos); down.success(value); } @Override public void error(Throwable throwable) { long durationInNanos = System.nanoTime() - start; circuitBreaker.onError(durationInNanos, throwable); handleRecovery(down, throwable); } @Override public void complete() { down.complete(); } }); } else { Throwable t = new CircuitBreakerOpenException(String.format("CircuitBreaker '%s' is open", circuitBreaker.getName())); handleRecovery(down, t); } }; }
if (result != null) { BulkheadTransformer transformer = BulkheadTransformer.of(bulkhead).recover(recoveryFunction); result = result.transform(transformer);
chain.prefix(prefix, chain1 -> { chain1.get("events", ctx -> Promise.<CircuitBreakerEventsEndpointResponse>async(d -> { CircuitBreakerEventsEndpointResponse response = new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry .getAllEventConsumer() .sorted(Comparator.comparing(CircuitBreakerEvent::getCreationTime)) .map(CircuitBreakerEventDTOFactory::createCircuitBreakerEventDTO).toJavaList()); d.success(response); }).then(r -> ctx.render(Jackson.json(r))) ); chain1.get("stream/events", ctx -> { chain1.get("events/:name", ctx -> { String circuitBreakerName = ctx.getPathTokens().get("name"); Promise.<CircuitBreakerEventsEndpointResponse>async(d -> { CircuitBreakerEventsEndpointResponse response = new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(circuitBreakerName) .getBufferedEvents() .map(CircuitBreakerEventDTOFactory::createCircuitBreakerEventDTO).toJavaList()); d.success(response); }).then(r -> ctx.render(Jackson.json(r))); String circuitBreakerName = ctx.getPathTokens().get("name"); String eventType = ctx.getPathTokens().get("type"); Promise.<CircuitBreakerEventsEndpointResponse>async(d -> { CircuitBreakerEventsEndpointResponse response = new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(circuitBreakerName)
if (bulkhead.isCallPermitted()) { upstream.connect(new Downstream<T>() {
if (result != null) { RateLimiterTransformer transformer = RateLimiterTransformer.of(rateLimiter).recover(recoveryFunction); result = result.transform(transformer);
chain.prefix(prefix, chain1 -> { chain1.get("events", ctx -> Promise.<BulkheadEventsEndpointResponse>async(d -> { BulkheadEventsEndpointResponse response = new BulkheadEventsEndpointResponse(eventConsumerRegistry .getAllEventConsumer() .sorted(Comparator.comparing(BulkheadEvent::getCreationTime)) .map(BulkheadEventDTO::createEventDTO).toJavaList()); d.success(response); }).then(r -> ctx.render(Jackson.json(r))) ); chain1.get("stream/events", ctx -> { chain1.get("events/:name", ctx -> { String bulkheadName = ctx.getPathTokens().get("name"); Promise.<BulkheadEventsEndpointResponse>async(d -> { BulkheadEventsEndpointResponse response = new BulkheadEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(bulkheadName) .getBufferedEvents() .map(BulkheadEventDTO::createEventDTO).toJavaList()); d.success(response); }).then(r -> ctx.render(Jackson.json(r))); String bulkheadName = ctx.getPathTokens().get("name"); String eventType = ctx.getPathTokens().get("type"); Promise.<BulkheadEventsEndpointResponse>async(d -> { BulkheadEventsEndpointResponse response = new BulkheadEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(bulkheadName)