io.github.resilience4j.bulkhead.BulkheadFullException Java Examples

@Test
public void testDecorateRunnableWithBulkheadFullExceptionFallback() throws ExecutionException, InterruptedException {
    ThreadPoolBulkhead bulkhead = ThreadPoolBulkhead.ofDefaults("helloBackend");
    ThreadPoolBulkhead bulkheadMock = spy(bulkhead);
    given(bulkheadMock.submit(any(Callable.class))).willThrow(BulkheadFullException.createBulkheadFullException(bulkhead));

    CompletionStage<Void> completionStage = Decorators
        .ofRunnable(() -> helloWorldService.sayHelloWorld())
        .withThreadPoolBulkhead(bulkheadMock)
        .withFallback(BulkheadFullException.class, (e) -> {
            helloWorldService.sayHelloWorld();
            return null;
        })
        .get();

    completionStage.toCompletableFuture().get();

    then(helloWorldService).should(times(1)).sayHelloWorld();
}
 

@Test
public void testDecorateCallableWithBulkheadFullExceptionFallback() throws ExecutionException, InterruptedException {
    ThreadPoolBulkhead bulkhead = ThreadPoolBulkhead.ofDefaults("helloBackend");
    ThreadPoolBulkhead bulkheadMock = spy(bulkhead);
    given(bulkheadMock.submit(any(Callable.class))).willThrow(BulkheadFullException.createBulkheadFullException(bulkhead));

    CompletionStage<String> completionStage = Decorators
        .ofCallable(() -> helloWorldService.returnHelloWorldWithException())
        .withThreadPoolBulkhead(bulkheadMock)
        .withFallback(BulkheadFullException.class, (e) -> "Fallback")
        .get();

    String result = completionStage.toCompletableFuture().get();

    assertThat(result).isEqualTo("Fallback");
}
 

@Test
public void testDecorateSupplierWithBulkheadFullExceptionFallback() throws ExecutionException, InterruptedException {
    ThreadPoolBulkhead bulkhead = ThreadPoolBulkhead.ofDefaults("helloBackend");
    ThreadPoolBulkhead bulkheadMock = spy(bulkhead);
    given(bulkheadMock.submit(any(Callable.class))).willThrow(BulkheadFullException.createBulkheadFullException(bulkhead));

    CompletionStage<String> completionStage = Decorators
        .ofSupplier(() -> helloWorldService.returnHelloWorld())
        .withThreadPoolBulkhead(bulkheadMock)
        .withFallback(BulkheadFullException.class, (e) -> "Fallback")
        .get();

    String result = completionStage.toCompletableFuture().get();

    assertThat(result).isEqualTo("Fallback");
}
 

/**
 * {@inheritDoc}
 */
@Override
public CompletableFuture<Void> submit(Runnable runnable) {
    final CompletableFuture<Void> promise = new CompletableFuture<>();
    try {
        CompletableFuture.runAsync(ContextPropagator.decorateRunnable(config.getContextPropagator(),() -> {
            try {
                publishBulkheadEvent(() -> new BulkheadOnCallPermittedEvent(name));
                runnable.run();
            } catch (Exception e) {
                throw new CompletionException(e);
            }
        }), executorService).whenComplete((result, throwable) -> {
            publishBulkheadEvent(() -> new BulkheadOnCallFinishedEvent(name));
            if (throwable != null) {
                promise.completeExceptionally(throwable);
            } else {
                promise.complete(result);
            }
        });
    } catch (RejectedExecutionException rejected) {
        publishBulkheadEvent(() -> new BulkheadOnCallRejectedEvent(name));
        throw BulkheadFullException.createBulkheadFullException(this);
    }
    return promise;
}
 

@Test
public void shouldEmitErrorWithBulkheadFullException() {
    given(bulkhead.tryAcquirePermission()).willReturn(false);

    Flowable.fromArray("Event 1", "Event 2")
        .compose(BulkheadOperator.of(bulkhead))
        .test()
        .assertSubscribed()
        .assertError(BulkheadFullException.class)
        .assertNotComplete();

    then(bulkhead).should(never()).onComplete();
}
 

@Override
public Upstream<T> apply(Upstream<? extends T> upstream) throws Exception {
    return down -> {
        if (bulkhead.tryAcquirePermission()) {
            // do not allow permits to leak
            upstream.connect(new Downstream<T>() {

                @Override
                public void success(T value) {
                    bulkhead.onComplete();
                    down.success(value);
                }

                @Override
                public void error(Throwable throwable) {
                    bulkhead.onComplete();
                    handleRecovery(down, throwable);
                }

                @Override
                public void complete() {
                    bulkhead.releasePermission();
                    down.complete();
                }
            });
        } else {
            Throwable t = BulkheadFullException.createBulkheadFullException(bulkhead);
            handleRecovery(down, t);
        }
    };
}
 

@Override
protected void subscribeActual(Subscriber<? super T> downstream) {
    if (bulkhead.tryAcquirePermission()) {
        upstream.subscribe(new BulkheadSubscriber(downstream));
    } else {
        downstream.onSubscribe(EmptySubscription.INSTANCE);
        downstream.onError(BulkheadFullException.createBulkheadFullException(bulkhead));
    }
}
 

@Override
protected void subscribeActual(SingleObserver<? super T> downstream) {
    if (bulkhead.tryAcquirePermission()) {
        upstream.subscribe(new BulkheadSingleObserver(downstream));
    } else {
        downstream.onSubscribe(EmptyDisposable.INSTANCE);
        downstream.onError(BulkheadFullException.createBulkheadFullException(bulkhead));
    }
}
 

@Override
protected void subscribeActual(CompletableObserver downstream) {
    if (bulkhead.tryAcquirePermission()) {
        upstream.subscribe(new BulkheadCompletableObserver(downstream));
    } else {
        downstream.onSubscribe(EmptyDisposable.INSTANCE);
        downstream.onError(BulkheadFullException.createBulkheadFullException(bulkhead));
    }
}
 

@Override
protected void subscribeActual(MaybeObserver<? super T> downstream) {
    if (bulkhead.tryAcquirePermission()) {
        upstream.subscribe(new BulkheadMaybeObserver(downstream));
    } else {
        downstream.onSubscribe(EmptyDisposable.INSTANCE);
        downstream.onError(BulkheadFullException.createBulkheadFullException(bulkhead));
    }
}
 

@Override
protected void subscribeActual(Observer<? super T> downstream) {
    if (bulkhead.tryAcquirePermission()) {
        upstream.subscribe(new BulkheadObserver(downstream));
    } else {
        downstream.onSubscribe(EmptyDisposable.INSTANCE);
        downstream.onError(BulkheadFullException.createBulkheadFullException(bulkhead));
    }
}
 

@Test
public void shouldEmitErrorWithBulkheadFullException() {
    given(bulkhead.tryAcquirePermission()).willReturn(false);

    Completable.complete()
        .compose(BulkheadOperator.of(bulkhead))
        .test()
        .assertSubscribed()
        .assertError(BulkheadFullException.class)
        .assertNotComplete();

    then(bulkhead).should(never()).onComplete();
}
 

@Test
public void shouldEmitBulkheadFullExceptionEvenWhenErrorNotOnSubscribe() {
    given(bulkhead.tryAcquirePermission()).willReturn(false);

    StepVerifier.create(
        Flux.error(new IOException("BAM!"), true)
            .transformDeferred(BulkheadOperator.of(bulkhead)))
        .expectSubscription()
        .expectError(BulkheadFullException.class)
        .verify(Duration.ofSeconds(1));

    verify(bulkhead, never()).onComplete();
}
 

@Test
public void shouldEmitErrorWithBulkheadFullException() {
    given(bulkhead.tryAcquirePermission()).willReturn(false);

    Single.just(1)
        .compose(BulkheadOperator.of(bulkhead))
        .test()
        .assertSubscribed()
        .assertError(BulkheadFullException.class)
        .assertNotComplete();

    then(bulkhead).should(never()).onComplete();
}
 

@Test
public void shouldEmitErrorWithBulkheadFullException() {
    given(bulkhead.tryAcquirePermission()).willReturn(false);

    Maybe.just(1)
        .compose(BulkheadOperator.of(bulkhead))
        .test()
        .assertSubscribed()
        .assertError(BulkheadFullException.class)
        .assertNotComplete();

    verify(bulkhead, never()).onComplete();
}
 

@Test
public void shouldEmitErrorWithBulkheadFullException() {
    given(bulkhead.tryAcquirePermission()).willReturn(false);

    Observable.fromArray("Event 1", "Event 2")
        .compose(BulkheadOperator.of(bulkhead))
        .test()
        .assertSubscribed()
        .assertError(BulkheadFullException.class)
        .assertNotComplete();

    then(bulkhead).should(never()).onComplete();
}
 

@Override
public void subscribe(CoreSubscriber<? super T> actual) {
    if (bulkhead.tryAcquirePermission()) {
        source.subscribe(new BulkheadSubscriber<>(bulkhead, actual, false));
    } else {
        Operators.error(actual, BulkheadFullException.createBulkheadFullException(bulkhead));
    }
}
 

@Override
public void subscribe(CoreSubscriber<? super T> actual) {
    if (bulkhead.tryAcquirePermission()) {
        source.subscribe(new BulkheadSubscriber<>(bulkhead, actual, true));
    } else {
        Operators.error(actual, BulkheadFullException.createBulkheadFullException(bulkhead));
    }
}
 

@Test
public void shouldEmitErrorWithBulkheadFullException() {
    given(bulkhead.tryAcquirePermission()).willReturn(false);

    StepVerifier.create(
        Mono.just("Event")
            .transformDeferred(BulkheadOperator.of(bulkhead)))
        .expectSubscription()
        .expectError(BulkheadFullException.class)
        .verify(Duration.ofSeconds(1));

    verify(bulkhead, never()).onComplete();
}
 

@Test
public void shouldEmitBulkheadFullExceptionEvenWhenErrorDuringSubscribe() {
    given(bulkhead.tryAcquirePermission()).willReturn(false);

    StepVerifier.create(
        Mono.error(new IOException("BAM!"))
            .transformDeferred(BulkheadOperator.of(bulkhead)))
        .expectSubscription()
        .expectError(BulkheadFullException.class)
        .verify(Duration.ofSeconds(1));
}
 

@Test
public void shouldEmitErrorWithBulkheadFullException() {
    given(bulkhead.tryAcquirePermission()).willReturn(false);
    bulkhead.tryAcquirePermission();

    StepVerifier.create(
        Flux.just("Event")
            .transformDeferred(BulkheadOperator.of(bulkhead)))
        .expectSubscription()
        .expectError(BulkheadFullException.class)
        .verify(Duration.ofSeconds(1));

    verify(bulkhead, never()).onComplete();
}
 

@Test
public void shouldEmitBulkheadFullExceptionEvenWhenErrorDuringSubscribe() {
    given(bulkhead.tryAcquirePermission()).willReturn(false);

    StepVerifier.create(
        Flux.error(new IOException("BAM!"))
            .transformDeferred(BulkheadOperator.of(bulkhead)))
        .expectSubscription()
        .expectError(BulkheadFullException.class)
        .verify(Duration.ofSeconds(1));

    verify(bulkhead, never()).onComplete();
}
 

private Supplier<CompletionStage<Void>> getCompletionStageSupplier(
    ThreadPoolBulkhead threadPoolBulkhead) {
    return () -> {
        try {
            return threadPoolBulkhead.executeRunnable(runnable);
        } catch (BulkheadFullException ex) {
            CompletableFuture<Void> future = new CompletableFuture<>();
            future.completeExceptionally(ex);
            return future;
        }
    };
}
 

/**
 * {@inheritDoc}
 */
@Override
public void acquirePermission() {
    boolean permitted = tryAcquirePermission();
    if (permitted) {
        return;
    }
    if (Thread.currentThread().isInterrupted()) {
        throw new AcquirePermissionCancelledException();
    }
    throw BulkheadFullException.createBulkheadFullException(this);
}
 

@Override
protected void subscribeActual(Subscriber<? super T> downstream) {
    if (bulkhead.tryAcquirePermission()) {
        upstream.subscribe(new BulkheadSubscriber(downstream));
    } else {
        downstream.onSubscribe(EmptySubscription.INSTANCE);
        downstream.onError(BulkheadFullException.createBulkheadFullException(bulkhead));
    }
}
 

@Override
protected void subscribeActual(SingleObserver<? super T> downstream) {
    if (bulkhead.tryAcquirePermission()) {
        upstream.subscribe(new BulkheadSingleObserver(downstream));
    } else {
        downstream.onSubscribe(EmptyDisposable.INSTANCE);
        downstream.onError(BulkheadFullException.createBulkheadFullException(bulkhead));
    }
}
 

@Override
protected void subscribeActual(CompletableObserver downstream) {
    if (bulkhead.tryAcquirePermission()) {
        upstream.subscribe(new BulkheadCompletableObserver(downstream));
    } else {
        downstream.onSubscribe(EmptyDisposable.INSTANCE);
        downstream.onError(BulkheadFullException.createBulkheadFullException(bulkhead));
    }
}
 

@Override
protected void subscribeActual(MaybeObserver<? super T> downstream) {
    if (bulkhead.tryAcquirePermission()) {
        upstream.subscribe(new BulkheadMaybeObserver(downstream));
    } else {
        downstream.onSubscribe(EmptyDisposable.INSTANCE);
        downstream.onError(BulkheadFullException.createBulkheadFullException(bulkhead));
    }
}
 

@Override
protected void subscribeActual(Observer<? super T> downstream) {
    if (bulkhead.tryAcquirePermission()) {
        upstream.subscribe(new BulkheadObserver(downstream));
    } else {
        downstream.onSubscribe(EmptyDisposable.INSTANCE);
        downstream.onError(BulkheadFullException.createBulkheadFullException(bulkhead));
    }
}
 

@Test
public void shouldEmitErrorWithBulkheadFullException() {
    given(bulkhead.tryAcquirePermission()).willReturn(false);

    Completable.complete()
        .compose(BulkheadOperator.of(bulkhead))
        .test()
        .assertError(BulkheadFullException.class)
        .assertNotComplete();

    then(bulkhead).should(never()).onComplete();
}