io.smallrye.faulttolerance.core.timeout

Class AsyncTimeout<V>

java.lang.Object

io.smallrye.faulttolerance.core.timeout.AsyncTimeout<V>

All Implemented Interfaces:

FaultToleranceStrategy<Future<V>>

public class AsyncTimeout<V>
extends Object
implements FaultToleranceStrategy<Future<V>>

The next strategy in the chain must be Timeout, and it is invoked on an extra thread. Communication then happens using TimeoutEvent.

Note that the TimeoutException thrown from this strategy might come from two places: the Timeout strategy throwing, or AsyncTimeoutTask#timedOut setting an exception as a result of TimeoutEvent. Both might happen, and whichever happens first gets to decide. That's why we take extra care to make sure that there's only one place where the exception is created.

Constructor Summary

Constructors

Constructor and Description
AsyncTimeout(FaultToleranceStrategy<Future<V>> delegate, Executor executor)

Method Summary

Modifier and Type	Method and Description
Future<V>	apply(InvocationContext<Future<V>> ctx) Apply the fault tolerance strategy around the target Callable.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AsyncTimeout

public AsyncTimeout(FaultToleranceStrategy<Future<V>> delegate,
                    Executor executor)

Method Detail

apply

public Future<V> apply(InvocationContext<Future<V>> ctx)
                throws Exception

Description copied from interface: FaultToleranceStrategy

Apply the fault tolerance strategy around the target Callable. The Callable is wrapped in an InvocationContext.

Specified by:

apply in interface FaultToleranceStrategy<Future<V>>

Parameters:

ctx - the InvocationContext wrapping the Callable guarded by this fault tolerance strategy

Returns:

result computed by the target Callable

Throws:

Exception - if result couldn't be computed