@Override public boolean isCancelled() { return sink.isCancelled(); }
@Test public void ignoreDoubleOnSubscribe() { EmitterProcessor<Integer> ep = EmitterProcessor.create(); ep.sink(); assertThat(ep.sink().isCancelled()).isTrue(); }
cancelled.set(e.isCancelled()); e.next(2); e.next(3);
@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 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 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 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 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 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"); } } }
@Test public void normalBuffered() { AssertSubscriber<Integer> ts = AssertSubscriber.create(); Flux<Integer> source = Flux.<Signal<Integer>>create(e -> { e.next(Signal.next(1)); e.next(Signal.next(2)); e.next(Signal.next(3)); e.next(Signal.complete()); System.out.println(e.isCancelled()); System.out.println(e.requestedFromDownstream()); }).dematerialize(); source.subscribe(ts); ts.assertValues(1, 2, 3) .assertNoError() .assertComplete(); }
@Override @SuppressWarnings("unchecked") public void subscribe(Subscriber<? super Message<T>> subscriber) { Flux .<Message<T>>create(sink -> sink.onRequest(n -> { Message<?> m; while (!sink.isCancelled() && n-- > 0 && (m = this.channel.receive()) != null) { sink.next((Message<T>) m); } }), FluxSink.OverflowStrategy.IGNORE) .subscribeOn(Schedulers.elastic()) .subscribe(subscriber); }
@Override public boolean isCancelled() { return sink.isCancelled(); }
private void dispose() { boolean isEventsThread = eventScheduler.isCurrentThreadFromScheduler(); boolean isEventsEmitterAvailable = !(eventSubmission.isCancelled() || eventEmitter.isTerminated() || eventEmitter.isCancelled()); this.dispose(!isEventsThread && isEventsEmitterAvailable); }
private void dispose() { boolean isEventsThread = eventScheduler.isCurrentThreadFromScheduler(); boolean isEventsEmitterAvailable = !(eventSubmission.isCancelled() || eventEmitter.isTerminated() || eventEmitter.isCancelled()); this.dispose(!isEventsThread && isEventsEmitterAvailable); }
@Override public void completed(Integer read, ByteBuffer dataBuffer) { if (read != -1) { long pos = this.position.addAndGet(read); dataBuffer.flip(); ByteBuf buf = allocator.buffer().writeBytes(dataBuffer); this.sink.next(buf); if (!this.sink.isCancelled()) { ByteBuffer newByteBuffer = ByteBuffer.allocate(chunk); this.channel.read(newByteBuffer, pos, newByteBuffer, this); } } else { try { channel.close(); } catch (IOException ignored) { } this.sink.complete(); } }
@Override @SuppressWarnings("unchecked") public void subscribe(Subscriber<? super Message<T>> subscriber) { Flux.<Message<T>>create(sink -> sink.onRequest(n -> { Message<?> m; while (!sink.isCancelled() && n-- > 0 && (m = this.channel.receive()) != null) { sink.next((Message<T>) m); } }), FluxSink.OverflowStrategy.IGNORE).subscribeOn(Schedulers.elastic()) .subscribe(subscriber); }
@Override @SuppressWarnings("unchecked") public void subscribe(Subscriber<? super Message<T>> subscriber) { Flux .<Message<T>>create(sink -> sink.onRequest(n -> { Message<?> m; while (!sink.isCancelled() && n-- > 0 && (m = this.channel.receive()) != null) { sink.next((Message<T>) m); } }), FluxSink.OverflowStrategy.IGNORE) .subscribeOn(Schedulers.elastic()) .subscribe(subscriber); }
@Test(timeout = 1000) public void name() throws Exception { Flux<Integer> f1 = Flux.<Integer>create(sink -> { int i =0 ; while(!sink.isCancelled()) { sink.next(i++); } }) .subscribeOn(SCHEDULER1); Flux<Integer> f2 = Flux.<Integer>create(sink -> { int i =0 ; while(!sink.isCancelled()) { sink.next(i--); } }) .subscribeOn(SCHEDULER2); Flux.merge(f1,f2) .take(1000) .blockLast(); } }