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 -> { 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)
chain.prefix(prefix, chain1 -> { chain1.get("events", ctx -> Promise.<RetryEventsEndpointResponse>async(d -> { List<RetryEventDTO> eventsList = eventConsumerRegistry.getAllEventConsumer() .flatMap(CircularEventConsumer::getBufferedEvents) chain1.get("events/:name", ctx -> { String retryName = ctx.getPathTokens().get("name"); Promise.<RetryEventsEndpointResponse>async(d -> { List<RetryEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(retryName) .getBufferedEvents() String retryName = ctx.getPathTokens().get("name"); String eventType = ctx.getPathTokens().get("type"); Promise.<RetryEventsEndpointResponse>async(d -> { List<RetryEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(retryName) .getBufferedEvents()
chain.prefix(prefix, chain1 -> { chain1.get("events", ctx -> Promise.<RateLimiterEventsEndpointResponse>async(d -> { List<RateLimiterEventDTO> eventsList = eventConsumerRegistry.getAllEventConsumer() .flatMap(CircularEventConsumer::getBufferedEvents) chain1.get("events/:name", ctx -> { String rateLimiterName = ctx.getPathTokens().get("name"); Promise.<RateLimiterEventsEndpointResponse>async(d -> { List<RateLimiterEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(rateLimiterName) .getBufferedEvents() String rateLimiterName = ctx.getPathTokens().get("name"); String eventType = ctx.getPathTokens().get("type"); Promise.<RateLimiterEventsEndpointResponse>async(d -> { List<RateLimiterEventDTO> eventsList = eventConsumerRegistry.getEventConsumer(rateLimiterName) .getBufferedEvents()
chain.prefix(prefix, chain1 -> { chain1.get("events", ctx -> Promise.<BulkheadEventsEndpointResponse>async(d -> { BulkheadEventsEndpointResponse response = new BulkheadEventsEndpointResponse(eventConsumerRegistry .getAllEventConsumer() chain1.get("events/:name", ctx -> { String bulkheadName = ctx.getPathTokens().get("name"); Promise.<BulkheadEventsEndpointResponse>async(d -> { BulkheadEventsEndpointResponse response = new BulkheadEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(bulkheadName) String bulkheadName = ctx.getPathTokens().get("name"); String eventType = ctx.getPathTokens().get("type"); Promise.<BulkheadEventsEndpointResponse>async(d -> { BulkheadEventsEndpointResponse response = new BulkheadEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(bulkheadName)
chain.prefix(prefix, chain1 -> { chain1.get("events", ctx -> Promise.<CircuitBreakerEventsEndpointResponse>async(d -> { CircuitBreakerEventsEndpointResponse response = new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry .getAllEventConsumer() chain1.get("events/:name", ctx -> { String circuitBreakerName = ctx.getPathTokens().get("name"); Promise.<CircuitBreakerEventsEndpointResponse>async(d -> { CircuitBreakerEventsEndpointResponse response = new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(circuitBreakerName) String circuitBreakerName = ctx.getPathTokens().get("name"); String eventType = ctx.getPathTokens().get("type"); Promise.<CircuitBreakerEventsEndpointResponse>async(d -> { CircuitBreakerEventsEndpointResponse response = new CircuitBreakerEventsEndpointResponse(eventConsumerRegistry .getEventConsumer(circuitBreakerName)
/** * @param single * @param <T> * @return * @throws UnmanagedThreadException */ public static <T> Promise<T> promise(Single<T> single) throws UnmanagedThreadException { return Promise.async(f -> single.subscribe(f::success, f::error)); }
/** * Deprecated. * * @param upstream the producer of the value * @param <T> the type of promised value * @return a promise for the asynchronously created value * @deprecated replaced by {@link #async(Upstream)} */ @Deprecated static <T> Promise<T> of(Upstream<T> upstream) { return async(upstream); }
/** * 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)); }
/** * Creates a promise for the given publisher's items as a List. * * @param publisher the stream to collect to a list * @param <T> the type of item in the stream * @return a promise for the streams contents as a list */ public static <T> Promise<List<T>> toList(Publisher<T> publisher) { return Promise.async(f -> publisher.subscribe(new CollectingSubscriber<>(f::accept, s -> s.request(Long.MAX_VALUE)))); }
/** * Creates a new promise for the eventual value. * * @return a new promise for the eventual value */ public Promise<T> promise() { return Promise.async(downstream -> { ExecResult<? extends T> result = ref.get(); if (result == null) { listeners.add(downstream); drain(); } else { downstream.accept(result); } }); }
@Override public Promise<List<? extends ExecResult<T>>> yieldAll() { List<Promise<T>> promises = Lists.newArrayList(this.promises); List<ExecResult<T>> results = Types.cast(promises); return Promise.async(d -> yieldPromise(promises.iterator(), 0, results::set, (i, r) -> { results.set(i, r); return true; }, () -> d.success(results) ) ); }
@Override public void connect(Downstream<? super T> downstream) throws Exception { Cached<? extends T> cached = this.ref.get(); if (needsFetch(cached)) { Promise.<T>async(d -> { waiting.add(d); tryDrain(); }).result(downstream::accept); } else { downstream.accept(cached.result); } }
@Override public Promise<List<T>> yield() { List<T> results = new ArrayList<>(); return Promise.async(d -> forEach((i, r) -> results.add(r)) .onError(d::error) .then(() -> d.success(results)) ); }
/** * Creates a promise for the given publisher's single item. * <p> * The given publisher is expected to produce zero or one items. * If it produces zero, the promised value will be {@code null}. * The it produces exactly one item, the promised value will be that item. * <p> * If the stream produces more than one item, the promise will fail with an {@link IllegalStateException}. * As soon as a second item is received, the subscription to the given publisher will be cancelled. * <p> * The single item is not provided to the promise subscriber until the stream completes, to ensure that it is indeed a one element stream. * If the stream errors before sending a second item, the promise will fail with that error. * If it fails after sending a second item, that error will be ignored. * * @param publisher the publiser the convert to a promise * @param <T> the type of promised value * @return a promise for the publisher's single item */ public static <T> Promise<T> toPromise(Publisher<T> publisher) { return Promise.async(f -> publisher.subscribe(SingleElementSubscriber.to(f::accept))); }
@Override public Promise<List<T>> yield() { List<Promise<T>> promises = Lists.newArrayList(this.promises); if (promises.isEmpty()) { return Promise.value(Collections.emptyList()); } List<T> results = Types.cast(promises); return Promise.async(d -> forEach(results::set).onError(d::error).then(() -> d.success(results))); }
private Promise<ByteBuf> invoke() { return Promise.async(f -> { ByteBuf byteBuf = bufferAllocator.ioBuffer(); try { CompiledTextTemplate fromCache = getFromCache(compiledTemplateCache, templateSource); Render.this.execute(fromCache, model, byteBuf); f.success(byteBuf); } catch (Throwable e) { byteBuf.release(); f.error(e); } } ); }
@Override public Promise<ReceivedResponse> request(URI uri, final Action<? super RequestSpec> requestConfigurer) { return intercept( Promise.async(downstream -> new ContentAggregatingRequestAction(uri, this, 0, Execution.current(), requestConfigurer.append(spec.requestInterceptor)).connect(downstream)), spec.responseInterceptor, spec.errorInterceptor ); }
@Override public Promise<StreamedResponse> requestStream(URI uri, Action<? super RequestSpec> requestConfigurer) { return intercept( Promise.async(downstream -> new ContentStreamingRequestAction(uri, this, 0, Execution.current(), requestConfigurer.append(spec.requestInterceptor)).connect(downstream)), spec.responseInterceptor, spec.errorInterceptor ); }
@Override public Operation forEach(BiAction<? super Integer, ? super T> consumer) { return Promise.<Void>async(d -> yieldPromise(promises.iterator(), 0, (i, r) -> consumer.execute(i, r.getValue()), (i, r) -> { d.error(r.getThrowable()); return false; }, () -> d.success(null)) ).operation(); }
private void drainRequestBody(Consumer<Throwable> next) { if (requestBody == null || !requestBody.isUnread()) { next.accept(null); } else { if (Execution.isActive()) { Promise.async(down -> requestBody.drain(e -> { if (e == null) { down.success(null); } else { down.error(e); } }) ) .onError(next::accept) .then(n -> next.accept(null)); } else { requestBody.drain(next); } } }