@Override public Mono<Authentication> authenticate(Authentication token) { return Mono.just(token) .publishOn(Schedulers.elastic()) .flatMap( t -> { try { return Mono.just(authenticationManager.authenticate(t)); } catch(Throwable error) { return Mono.error(error); } }) .filter( a -> a.isAuthenticated()); } }
private Mono<Void> executeInternal(URI url, HttpHeaders requestHeaders, WebSocketHandler handler) { MonoProcessor<Void> completionMono = MonoProcessor.create(); return Mono.fromCallable( () -> { if (logger.isDebugEnabled()) { logger.debug("Connecting to " + url); } List<String> protocols = handler.getSubProtocols(); DefaultConfigurator configurator = new DefaultConfigurator(requestHeaders); Endpoint endpoint = createEndpoint(url, handler, completionMono, configurator); ClientEndpointConfig config = createEndpointConfig(configurator, protocols); return this.webSocketContainer.connectToServer(endpoint, config, url); }) .subscribeOn(Schedulers.elastic()) // connectToServer is blocking .then(completionMono); }
@Test public void setReplace() { for (int i = 0; i < 500; i++) { TestDisposable r = new TestDisposable() { @Override public void run() { OperatorDisposables.replace(DISPOSABLE_UPDATER, this, Disposables.single()); } }; RaceTestUtils.race(r, r, Schedulers.elastic()); } }
@Test public void setRace() { for (int i = 0; i < 500; i++) { TestDisposable r = new TestDisposable() { @Override public void run() { Disposables.set(DISPOSABLE_UPDATER, this, Disposables.single()); } }; RaceTestUtils.race(r, r, Schedulers.elastic()); } }
@Test public void disposeRace() { for (int i = 0; i < 500; i++) { TestDisposable r = new TestDisposable() { @Override public void run() { OperatorDisposables.dispose(DISPOSABLE_UPDATER, this); } }; RaceTestUtils.race(r, r, Schedulers.elastic()); } }
@Test public void setRace() { for (int i = 0; i < 500; i++) { TestDisposable r = new TestDisposable() { @Override public void run() { OperatorDisposables.set(DISPOSABLE_UPDATER, this, Disposables.single()); } }; RaceTestUtils.race(r, r, Schedulers.elastic()); } }
@Test(expected = UnsupportedOperationException.class) public void unsupportedStart() { Schedulers.elastic().start(); }
@Test public void disposeRace() { for (int i = 0; i < 500; i++) { TestDisposable r = new TestDisposable() { @Override public void run() { Disposables.dispose(DISPOSABLE_UPDATER, this); } }; RaceTestUtils.race(r, r, Schedulers.elastic()); } }
@Test public void setReplace() { for (int i = 0; i < 500; i++) { TestDisposable r = new TestDisposable() { @Override public void run() { Disposables.replace(DISPOSABLE_UPDATER, this, Disposables.single()); } }; RaceTestUtils.race(r, r, Schedulers.elastic()); } }
@Test public void scanSubscriberCancelled() { CoreSubscriber<List<String>> actual = new LambdaSubscriber<>(null, e -> {}, null, null); FluxBufferTimeout.BufferTimeoutSubscriber<String, List<String>> test = new FluxBufferTimeout.BufferTimeoutSubscriber<String, List<String>>( actual, 123, 1000, Schedulers.elastic().createWorker(), ArrayList::new); assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse(); assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse(); test.cancel(); assertThat(test.scan(Scannable.Attr.CANCELLED)).isTrue(); assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse(); }
@Test public void shouldShowActualSubscriberDemand() { Subscription[] subscriptionsHolder = new Subscription[1]; CoreSubscriber<List<String>> actual = new LambdaSubscriber<>(null, e -> {}, null, s -> subscriptionsHolder[0] = s); FluxBufferTimeout.BufferTimeoutSubscriber<String, List<String>> test = new FluxBufferTimeout.BufferTimeoutSubscriber<String, List<String>>( actual, 123, 1000, Schedulers.elastic().createWorker(), ArrayList::new); Subscription subscription = Operators.emptySubscription(); test.onSubscribe(subscription); subscriptionsHolder[0].request(10); assertThat(test.scan(Scannable.Attr.REQUESTED_FROM_DOWNSTREAM)).isEqualTo(10L); subscriptionsHolder[0].request(5); assertThat(test.scan(Scannable.Attr.REQUESTED_FROM_DOWNSTREAM)).isEqualTo(15L); }
@Test public void boundaryFusion() { Flux.range(1, 10000) .publishOn(Schedulers.single()) .map(t -> Thread.currentThread().getName().contains("single-") ? "single" : ("BAD-" + t + Thread.currentThread().getName())) .concatMap(Flux::just) .publishOn(Schedulers.elastic()) .distinct() .as(StepVerifier::create) .expectFusion() .expectNext("single") .expectComplete() .verify(Duration.ofSeconds(5)); }
@Test public void boundaryFusionDelayError() { Flux.range(1, 10000) .publishOn(Schedulers.single()) .map(t -> Thread.currentThread().getName().contains("single-") ? "single" : ("BAD-" + t + Thread.currentThread().getName())) .concatMapDelayError(Flux::just) .publishOn(Schedulers.elastic()) .distinct() .as(StepVerifier::create) .expectFusion() .expectNext("single") .expectComplete() .verify(Duration.ofSeconds(5)); }
@Test public void disposeConcurrent() { for (int i = 0; i < 500; i++) { final Disposable d1 = new FakeDisposable(); final Disposable.Composite cd = new ListCompositeDisposable(d1); RaceTestUtils.race(cd::dispose, cd::dispose, Schedulers.elastic()); } }
@Test public void sizeConcurrent() { for (int i = 0; i < 500; i++) { final Disposable d1 = new FakeDisposable(); final Disposable.Composite cd = new ListCompositeDisposable(d1); RaceTestUtils.race(cd::size, cd::dispose, Schedulers.elastic()); } }
@Test public void removeConcurrent() { for (int i = 0; i < 500; i++) { final Disposable d1 = new FakeDisposable(); final Disposable.Composite cd = new ListCompositeDisposable(d1); RaceTestUtils.race(() -> cd.remove(d1), cd::dispose, Schedulers.elastic()); } }
@Test public void largeSequence() { Flux<Integer> source = Flux.range(1, Queues.SMALL_BUFFER_SIZE * 4).subscribeOn(Schedulers.elastic()); StepVerifier.create(Mono.sequenceEqual(source, source)) .expectNext(Boolean.TRUE) .expectComplete() .verify(Duration.ofSeconds(5)); }
@Test public void subscribeWithAsyncFusion() { Processor<Integer, Integer> processor = EmitterProcessor.create(16); StepVerifier.create(processor) .then(() -> Flux.range(1, 5).publishOn(Schedulers.elastic()).subscribe(processor)) .expectNext(1, 2, 3, 4, 5) .expectComplete() .verify(Duration.ofSeconds(1)); }
@Test public void testAsynchronousRun() { Flux.range(1, 2).flatMapSequential(t -> Flux.range(1, 1000) .subscribeOn(Schedulers.single()) ).publishOn(Schedulers.elastic()).subscribe(ts); ts.await(Duration.ofSeconds(5)); ts.assertNoError(); ts.assertValueCount(2000); }