@Override public void onComplete() { if (this.completionMono != null) { this.completionMono.onComplete(); } close(); }
private <T> Consumer<T> updateConnectMono(MonoProcessor<Void> connectMono) { return o -> { if (!connectMono.isTerminated()) { if (o instanceof Throwable) { connectMono.onError((Throwable) o); } else { connectMono.onComplete(); } } }; }
@GetMapping("/infinite") Flux<String> infinite() { return Flux.just(0, 1).map(l -> "foo " + l) .mergeWith(Flux.never()) .doOnCancel(() -> cancellation.onComplete()); } }
private StatusAssertions statusAssertions(HttpStatus status) { MockClientHttpRequest request = new MockClientHttpRequest(HttpMethod.GET, URI.create("/")); MockClientHttpResponse response = new MockClientHttpResponse(status); MonoProcessor<byte[]> emptyContent = MonoProcessor.create(); emptyContent.onComplete(); ExchangeResult result = new ExchangeResult(request, response, emptyContent, emptyContent, Duration.ZERO, null); return new StatusAssertions(result, mock(WebTestClient.ResponseSpec.class)); }
public WiretapRecorder(@Nullable Publisher<? extends DataBuffer> publisher, @Nullable Publisher<? extends Publisher<? extends DataBuffer>> publisherNested) { if (publisher != null && publisherNested != null) { throw new IllegalArgumentException("At most one publisher expected"); } this.publisher = publisher != null ? Flux.from(publisher) .doOnSubscribe(s -> this.hasContentConsumer = true) .doOnNext(this.buffer::write) .doOnError(this::handleOnError) .doOnCancel(this::handleOnComplete) .doOnComplete(this::handleOnComplete) : null; this.publisherNested = publisherNested != null ? Flux.from(publisherNested) .doOnSubscribe(s -> this.hasContentConsumer = true) .map(p -> Flux.from(p).doOnNext(this.buffer::write).doOnError(this::handleOnError)) .doOnError(this::handleOnError) .doOnCancel(this::handleOnComplete) .doOnComplete(this::handleOnComplete) : null; if (publisher == null && publisherNested == null) { this.content.onComplete(); } }
private HeaderAssertions headerAssertions(HttpHeaders responseHeaders) { MockClientHttpRequest request = new MockClientHttpRequest(HttpMethod.GET, URI.create("/")); MockClientHttpResponse response = new MockClientHttpResponse(HttpStatus.OK); response.getHeaders().putAll(responseHeaders); MonoProcessor<byte[]> emptyContent = MonoProcessor.create(); emptyContent.onComplete(); ExchangeResult result = new ExchangeResult(request, response, emptyContent, emptyContent, Duration.ZERO, null); return new HeaderAssertions(result, mock(WebTestClient.ResponseSpec.class)); }
@Test public void scanProcessor() { MonoProcessor<String> test = MonoProcessor.create(); Subscription subscription = Operators.emptySubscription(); test.onSubscribe(subscription); assertThat(test.scan(Scannable.Attr.PREFETCH)).isEqualTo(Integer.MAX_VALUE); assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse(); assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse(); test.onComplete(); assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue(); assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse(); }
@Override public void onComplete() { processor.onComplete(); }
@Override public void dispose() { onClose.onComplete(); }
private <C, B> Flux<Message<C, B>> doReceive(SerializationPair<C> channelSerializer, SerializationPair<B> messageSerializer, Mono<ReactiveSubscription> subscription, ByteBuffer[] patterns, ByteBuffer[] channels) { Flux<Message<ByteBuffer, ByteBuffer>> messageStream = subscription.flatMapMany(it -> { Mono<Void> subscribe = subscribe(patterns, channels, it); MonoProcessor<ChannelMessage<ByteBuffer, ByteBuffer>> terminalProcessor = MonoProcessor.create(); return it.receive().mergeWith(subscribe.then(Mono.defer(() -> { getSubscribers(it).registered(); return Mono.empty(); }))).doOnCancel(() -> { Subscribers subscribers = getSubscribers(it); if (subscribers.unregister()) { subscriptions.remove(it); it.unsubscribe().subscribe(v -> terminalProcessor.onComplete(), terminalProcessor::onError); } }).mergeWith(terminalProcessor); }); return messageStream .map(message -> readMessage(channelSerializer.getReader(), messageSerializer.getReader(), message)); }
@Override public void dispose() { synchronized (this) {; activeSockets.forEach(WeightedSocket::dispose); activeSockets.clear(); onClose.onComplete(); } }
@Test public void asyncFusion() { AssertSubscriber<Object> ts = AssertSubscriber.create(); MonoProcessor<Integer> up = MonoProcessor.create(); up.filter(v -> (v & 1) == 0) .subscribe(ts); up.onNext(2); up.onComplete(); ts.assertValues(2) .assertNoError() .assertComplete(); }
@Override public void dispose() { out.onComplete(); onClose.onComplete(); }
@Override public void dispose() { if (!registry.remove(address.getName(), this)) { throw new AssertionError(); } onClose.onComplete(); }
@Override public void dispose() { onClose.onComplete(); }
@Override public void dispose() { onClose.onComplete(); }
@Test public void timeoutRequested() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); MonoProcessor<Integer> source = MonoProcessor.create(); DirectProcessor<Integer> tp = DirectProcessor.create(); source.timeout(tp) .subscribe(ts); tp.onNext(1); source.onNext(2); source.onComplete(); ts.assertNoValues() .assertError(TimeoutException.class) .assertNotComplete(); }
@Override public void dispose() { sent.onComplete(); timeout.onComplete(); intervalDisposable.dispose(); }
private <T> Consumer<T> updateConnectMono(MonoProcessor<Void> connectMono) { return o -> { if (!connectMono.isTerminated()) { if (o instanceof Throwable) { connectMono.onError((Throwable) o); } else { connectMono.onComplete(); } } }; }
@Override public void dispose() { if (!onClose.isDisposed()) { onClose.onComplete(); close(factoryPool); close(leasedSuppliers); } }