@Override public FluxSink<T> onCancel(Disposable d) { sink.onCancel(d); return sink; }
/** * Register cancel and onDemand callbacks. */ public void register() { this.sink.onRequest(this::onDemand); this.sink.onCancel(this::canceled); }
/** * Creates a {@link Publisher} emitting {@link DataBuffer}s by reading binary chunks from {@link AsyncInputStream}. * Closes the {@link AsyncInputStream} once the {@link Publisher} terminates. * * @param inputStream must not be {@literal null}. * @param dataBufferFactory must not be {@literal null}. * @return the resulting {@link Publisher}. */ static Flux<DataBuffer> createBinaryStream(AsyncInputStream inputStream, DataBufferFactory dataBufferFactory) { State state = new State(inputStream, dataBufferFactory); return Flux.usingWhen(Mono.just(inputStream), it -> { return Flux.<DataBuffer> create((sink) -> { sink.onDispose(state::close); sink.onCancel(state::close); sink.onRequest(n -> { state.request(sink, n); }); }); }, AsyncInputStream::close, AsyncInputStream::close, AsyncInputStream::close) // .concatMap(Flux::just, 1); }
@Test public void fluxCreateDisposables() { AtomicInteger dispose1 = new AtomicInteger(); AtomicInteger dispose2 = new AtomicInteger(); AtomicInteger cancel1 = new AtomicInteger(); AtomicInteger cancel2 = new AtomicInteger(); AtomicInteger cancellation = new AtomicInteger(); Flux<String> created = Flux.create(s -> { s.onDispose(dispose1::getAndIncrement) .onCancel(cancel1::getAndIncrement); s.onDispose(dispose2::getAndIncrement); assertThat(dispose2.get()).isEqualTo(1); s.onCancel(cancel2::getAndIncrement); assertThat(cancel2.get()).isEqualTo(1); s.onDispose(cancellation::getAndIncrement); assertThat(cancellation.get()).isEqualTo(1); assertThat(dispose1.get()).isEqualTo(0); assertThat(cancel1.get()).isEqualTo(0); s.next("test1"); s.complete(); }); StepVerifier.create(created) .expectNext("test1") .verifyComplete(); assertThat(dispose1.get()).isEqualTo(1); assertThat(cancel1.get()).isEqualTo(0); }
Emitter emitter = new Emitter(s); s.onDispose(() -> onDispose.incrementAndGet()); s.onCancel(() -> onCancel.incrementAndGet()); s.onRequest(emitter::emit); }); s.onRequest(emitter::emit); s.onDispose(() -> onDispose.incrementAndGet()); s.onCancel(() -> onCancel.incrementAndGet()); }); StepVerifier.create(flux2, count)
@Test public void fluxCreateBuffered() { AtomicInteger onDispose = new AtomicInteger(); AtomicInteger onCancel = new AtomicInteger(); Flux<String> created = Flux.create(s -> { s.onDispose(onDispose::getAndIncrement) .onCancel(onCancel::getAndIncrement); s.next("test1"); s.next("test2"); s.next("test3"); s.complete(); }); assertThat(created.getPrefetch()).isEqualTo(-1); StepVerifier.create(created) .expectNext("test1", "test2", "test3") .verifyComplete(); assertThat(onDispose.get()).isEqualTo(1); assertThat(onCancel.get()).isEqualTo(0); }
@Test public void fluxCreateBuffered2() { AtomicInteger cancellation = new AtomicInteger(); AtomicInteger onCancel = new AtomicInteger(); StepVerifier.create(Flux.create(s -> { s.onDispose(cancellation::getAndIncrement); s.onCancel(onCancel::getAndIncrement); s.next("test1"); s.next("test2"); s.next("test3"); s.complete(); }).publishOn(Schedulers.parallel())) .expectNext("test1", "test2", "test3") .verifyComplete(); assertThat(cancellation.get()).isEqualTo(1); assertThat(onCancel.get()).isEqualTo(0); }
@Test public void fluxCreateIgnoreCancelled() { AtomicInteger onDispose = new AtomicInteger(); AtomicInteger onCancel = new AtomicInteger(); Flux<String> created = Flux.create(s -> { s.onDispose(() -> { onDispose.getAndIncrement(); assertThat(s.isCancelled()).isTrue(); }); s.onCancel(() -> { onCancel.getAndIncrement(); assertThat(s.isCancelled()).isTrue(); }); s.next("test1"); s.next("test2"); s.next("test3"); s.complete(); }, FluxSink.OverflowStrategy.IGNORE); StepVerifier.create(created) .expectNext("test1", "test2", "test3") .thenCancel() .verify(); assertThat(onDispose.get()).isEqualTo(1); assertThat(onCancel.get()).isEqualTo(1); }
@Test public void fluxCreateDropCancelled() { AtomicInteger onDispose = new AtomicInteger(); AtomicInteger onCancel = new AtomicInteger(); Flux<String> created = Flux.create(s -> { s.onDispose(() -> { onDispose.getAndIncrement(); assertThat(s.isCancelled()).isTrue(); }); s.onCancel(() -> { onCancel.getAndIncrement(); assertThat(s.isCancelled()).isTrue(); }); s.next("test1"); s.next("test2"); s.next("test3"); s.complete(); }, FluxSink.OverflowStrategy.DROP); StepVerifier.create(created) .expectNext("test1", "test2", "test3") .thenCancel() .verify(); assertThat(onDispose.get()).isEqualTo(1); assertThat(onCancel.get()).isEqualTo(1); }
@Test public void fluxCreateErrorCancelled() { AtomicInteger onDispose = new AtomicInteger(); AtomicInteger onCancel = new AtomicInteger(); Flux<String> created = Flux.create(s -> { s.onDispose(() -> { onDispose.getAndIncrement(); assertThat(s.isCancelled()).isTrue(); }); s.onCancel(() -> { onCancel.getAndIncrement(); assertThat(s.isCancelled()).isTrue(); }); s.next("test1"); s.next("test2"); s.next("test3"); s.complete(); }, FluxSink.OverflowStrategy.ERROR); StepVerifier.create(created) .expectNext("test1", "test2", "test3") .thenCancel() .verify(); assertThat(onDispose.get()).isEqualTo(1); assertThat(onCancel.get()).isEqualTo(1); }
@Test public void fluxCreateLatestCancelled() { AtomicInteger onDispose = new AtomicInteger(); AtomicInteger onCancel = new AtomicInteger(); Flux<String> created = Flux.create(s -> { s.onDispose(() -> { onDispose.getAndIncrement(); assertThat(s.isCancelled()).isTrue(); }); s.onCancel(() -> { onCancel.getAndIncrement(); assertThat(s.isCancelled()).isTrue(); }); s.next("test1"); s.next("test2"); s.next("test3"); s.complete(); }, FluxSink.OverflowStrategy.LATEST); StepVerifier.create(created) .expectNext("test1", "test2", "test3") .thenCancel() .verify(); assertThat(onDispose.get()).isEqualTo(1); assertThat(onCancel.get()).isEqualTo(1); }
@Test public void fluxCreateSerializedCancelled() { AtomicInteger onDispose = new AtomicInteger(); AtomicInteger onCancel = new AtomicInteger(); Flux<String> created = Flux.create(s -> { s.onDispose(onDispose::getAndIncrement) .onCancel(onCancel::getAndIncrement); s.next("test1"); s.next("test2"); s.next("test3"); assertThat(s.isCancelled()).isTrue(); s.complete(); }); StepVerifier.create(created) .expectNext("test1", "test2", "test3") .thenCancel() .verify(); assertThat(onDispose.get()).isEqualTo(1); assertThat(onCancel.get()).isEqualTo(1); }
@Test public void fluxCreateBufferedCancelled() { AtomicInteger onDispose = new AtomicInteger(); AtomicInteger onCancel = new AtomicInteger(); Flux<String> created = Flux.create(s -> { s.onDispose(() -> { onDispose.getAndIncrement(); assertThat(s.isCancelled()).isTrue(); }); s.onCancel(() -> { onCancel.getAndIncrement(); assertThat(s.isCancelled()).isTrue(); }); s.next("test1"); s.next("test2"); s.next("test3"); s.complete(); }); StepVerifier.create(created) .expectNext("test1", "test2", "test3") .thenCancel() .verify(); assertThat(onDispose.get()).isEqualTo(1); assertThat(onCancel.get()).isEqualTo(1); }
@Test public void gh870() throws Exception { CountDownLatch cancelled = new CountDownLatch(1); StepVerifier.create(Flux.<Integer>create(sink -> { int i = 0; sink.onCancel(cancelled::countDown); try { while (true) { sink.next(i++); Thread.sleep(1); if (sink.isCancelled()) { break; } } } catch (InterruptedException e) { sink.error(e); } }) // .doOnCancel(() -> System.out.println("cancel 2")) .publish(Function.identity()) // .doOnCancel(() -> System.out.println("cancel 1")) .take(5)) .expectNextCount(5) .verifyComplete(); if (!cancelled.await(5, TimeUnit.SECONDS)) { fail("Flux.create() did not receive cancellation signal"); } } }
@Override @SuppressWarnings("unchecked") public void subscribe(Subscriber<? super Message<T>> subscriber) { Flux. <Message<?>>create(emitter -> { MessageHandler messageHandler = emitter::next; this.channel.subscribe(messageHandler); emitter.onCancel(() -> this.channel.unsubscribe(messageHandler)); }, FluxSink.OverflowStrategy.IGNORE) .subscribe((Subscriber<? super Message<?>>) subscriber); }
@Override public FluxSink<T> onCancel(Disposable d) { sink.onCancel(d); return sink; }
/** * Register cancel and onDemand callbacks. */ public void register() { this.sink.onRequest(this::onDemand); this.sink.onCancel(this::canceled); }
@Bean Flux<ServerSentEvent<Map>> processor(final List<FluxSink<ServerSentEvent<Map>>> subscribers) { return Flux.create( fluxSink -> subscribers.add( fluxSink.onCancel(() -> subscribers.remove(fluxSink)) .onDispose(() -> log.debug("disposing...")) .onRequest(i -> log.debug("{} subscribers on request", subscribers.size())))); }
@Override @SuppressWarnings("unchecked") public void subscribe(Subscriber<? super Message<T>> subscriber) { Flux. <Message<?>>create(emitter -> { MessageHandler messageHandler = emitter::next; this.channel.subscribe(messageHandler); emitter.onCancel(() -> this.channel.unsubscribe(messageHandler)); }, FluxSink.OverflowStrategy.IGNORE) .subscribe((Subscriber<? super Message<?>>) subscriber); }
@Override @SuppressWarnings("unchecked") public void subscribe(Subscriber<? super Message<T>> subscriber) { Flux.<Message<?>>create(emitter -> { MessageHandler messageHandler = emitter::next; this.channel.subscribe(messageHandler); emitter.onCancel(() -> this.channel.unsubscribe(messageHandler)); }, FluxSink.OverflowStrategy.IGNORE) .subscribe((Subscriber<? super Message<?>>) subscriber); }