tessl/maven-io-quarkus--quarkus-smallrye-fault-tolerance

Build fault-tolerant network services

—

Pending

Overview

Eval results

Files

Bulkhead Strategies

Name: tessl/maven-io-quarkus--quarkus-smallrye-fault-tolerance
Author: tessl

Isolation patterns that control concurrent access to methods by limiting simultaneous executions and managing queuing for asynchronous operations.

Capabilities

Basic Bulkhead

Standard bulkhead functionality with configurable concurrency limits and queue management.

@Bulkhead(
    value = 10,
    waitingTaskQueue = 20
)
public ReturnType limitedConcurrencyMethod();

Parameters

value - Maximum concurrent executions (default: 10)
waitingTaskQueue - Queue size for asynchronous operations (default: 10)

Behavior

Synchronous methods: Rejected immediately when limit exceeded
Asynchronous methods: Queued when concurrent limit reached, rejected when queue full

Usage Example

@ApplicationScoped
public class DatabaseService {
    
    // Limit database connections
    @Bulkhead(value = 5, waitingTaskQueue = 15)
    public List<User> findUsers(UserQuery query) throws SQLException {
        return userRepository.query(query);
    }
    
    // Protect critical resource with tight limit
    @Bulkhead(value = 2)
    public void performMaintenanceTask() throws MaintenanceException {
        criticalSystemMaintenance.execute();
    }
    
    // Async operations with queue management
    @Asynchronous
    @Bulkhead(value = 8, waitingTaskQueue = 25)
    public CompletionStage<ProcessingResult> processAsync(ProcessingTask task) {
        return CompletableFuture.supplyAsync(() -> processor.process(task));
    }
}

Bulkhead with Other Strategies

Combining bulkhead isolation with other fault tolerance patterns.

@Bulkhead(value = 5, waitingTaskQueue = 10)
@CircuitBreaker(requestVolumeThreshold = 20, failureRatio = 0.4)
@Timeout(8000)
public ReturnType isolatedResilientMethod();

Usage Example

@ApplicationScoped
public class ExternalApiService {
    
    // API calls with bulkhead, circuit breaker, and retry
    @Bulkhead(value = 6, waitingTaskQueue = 12)
    @CircuitBreaker(requestVolumeThreshold = 15, failureRatio = 0.5)
    @Retry(maxRetries = 2, delay = 1000)
    @Timeout(10000)
    public ApiResponse callExternalApi(ApiRequest request) throws ApiException {
        return externalApiClient.call(request);
    }
    
    // Payment processing with isolation and fallback
    @Bulkhead(value = 3)
    @Fallback(fallbackMethod = "queuePayment")
    @Timeout(15000)
    public PaymentResult processPayment(PaymentRequest request) throws PaymentException {
        return paymentGateway.process(request);
    }
    
    public PaymentResult queuePayment(PaymentRequest request) {
        paymentQueue.enqueue(request);
        return PaymentResult.queued(request.getId());
    }
}

Resource-specific Bulkheads

Different bulkhead configurations for different resource types or operations.

Usage Example

@ApplicationScoped
public class ResourceManager {
    
    // File system operations - limited by I/O capacity
    @Bulkhead(value = 4, waitingTaskQueue = 8)
    public FileProcessingResult processFile(File file) throws IOException {
        return fileProcessor.process(file);
    }
    
    // Network operations - higher concurrency allowed
    @Bulkhead(value = 15, waitingTaskQueue = 30)
    public NetworkResponse sendNetworkRequest(NetworkRequest request) {
        return networkClient.send(request);
    }
    
    // CPU-intensive operations - match CPU cores
    @Bulkhead(value = Runtime.getRuntime().availableProcessors())
    public ComputationResult performComputation(ComputationTask task) {
        return computationEngine.compute(task);
    }
    
    // Memory-sensitive operations - very limited
    @Bulkhead(value = 2, waitingTaskQueue = 3)
    public ProcessingResult processLargeDataSet(LargeDataSet dataSet) {
        return memoryIntensiveProcessor.process(dataSet);
    }
}

Async Bulkhead Patterns

Specialized patterns for asynchronous and reactive programming.

@Asynchronous
@Bulkhead(value = 10, waitingTaskQueue = 20)
public CompletionStage<ReturnType> asyncBulkheadMethod();

@AsynchronousNonBlocking
@Bulkhead(value = 8, waitingTaskQueue = 15)
public Uni<ReturnType> nonBlockingBulkheadMethod();

Usage Example

@ApplicationScoped
public class AsyncProcessingService {
    
    // Async image processing with bulkhead
    @Asynchronous
    @Bulkhead(value = 6, waitingTaskQueue = 20)
    @Timeout(30000)
    public CompletionStage<ProcessedImage> processImageAsync(ImageData image) {
        return CompletableFuture.supplyAsync(() -> {
            return imageProcessor.process(image);
        });
    }
    
    // Non-blocking email sending with bulkhead
    @AsynchronousNonBlocking
    @Bulkhead(value = 12, waitingTaskQueue = 25)
    @Retry(maxRetries = 3)
    public Uni<EmailResult> sendEmailAsync(EmailMessage message) {
        return emailService.sendAsync(message);
    }
    
    // Batch processing with controlled concurrency
    @Asynchronous
    @Bulkhead(value = 4, waitingTaskQueue = 10)
    public CompletionStage<BatchResult> processBatchAsync(List<BatchItem> items) {
        return CompletableFuture.supplyAsync(() -> {
            return batchProcessor.process(items);
        });
    }
}

Types

Bulkhead Core Types

// Bulkhead rejection exception
class BulkheadException extends RuntimeException {
    public BulkheadException(String message);
    public BulkheadException(String message, Throwable cause);
}

// Async execution types
interface CompletionStage<T> {
    // Java standard CompletionStage methods
}

// Mutiny reactive type
interface Uni<T> {
    // Mutiny Uni methods for non-blocking operations
}

Install with Tessl CLI

npx tessl i tessl/maven-io-quarkus--quarkus-smallrye-fault-tolerance

docs

asynchronous-strategies.md

bulkhead-strategies.md

circuit-breaker-strategies.md

configuration.md

fallback-strategies.md

index.md

programmatic-api.md

rate-limiting-strategies.md

retry-strategies.md

timeout-strategies.md

tile.json

tessl/maven-io-quarkus--quarkus-smallrye-fault-tolerance