public interface ExecControl
import ratpack.exec.ExecControl;
import ratpack.exec.Promise;
import ratpack.test.handling.RequestFixture;
import ratpack.test.handling.HandlingResult;
public class Example {
public static class AsyncUpperCaseService {
private final ExecControl control;
public AsyncUpperCaseService(ExecControl control) {
this.control = control;
}
public Promise<String> toUpper(final String lower) {
return control.promise(f -> f.success(lower.toUpperCase()));
}
}
public static void main(String[] args) throws Exception {
HandlingResult result = RequestFixture.requestFixture().handleChain(chain -> {
ExecControl control = chain.getLaunchConfig().getExecController().getControl();
AsyncUpperCaseService service = new AsyncUpperCaseService(control);
chain.get(ctx -> service.toUpper("foo").then(ctx::render));
});
assert result.rendered(String.class).equals("FOO");
}
}
Note: when using the Guice integration, the exec control is made available for injection.
Modifier and Type | Method and Description |
---|---|
void |
addInterceptor(ExecInterceptor execInterceptor,
NoArgAction continuation)
Adds an interceptor that wraps the rest of the current execution segment and all future segments of this execution.
|
<T> Promise<T> |
blocking(Callable<T> blockingOperation)
Performs a blocking operation on a separate thread, returning a promise for its value.
|
static ExecControl |
current()
Provides the execution control bound to the current thread.
|
ExecStarter |
exec()
Creates a new execution stater that can be used to initiate a new execution.
|
ExecController |
getController() |
Execution |
getExecution() |
<T> Promise<T> |
promise(Action<? super Fulfiller<T>> action)
Creates a promise for an asynchronously created value.
|
<T> TransformablePublisher<T> |
stream(org.reactivestreams.Publisher<T> publisher)
Process streams of data asynchronously with non-blocking back pressure.
|
static ExecControl current()
This method will fail when called outside of a Ratpack compute thread as it relies on ExecController.require()
.
Execution getExecution()
ExecController getController()
void addInterceptor(ExecInterceptor execInterceptor, NoArgAction continuation) throws Exception
The given action is executed immediately (i.e. as opposed to being queued to be executed as the next execution segment). Any code executed after a call to this method in the same execution segment WILL NOT be intercepted. Therefore, it is advisable to not execute any code after calling this method in a given execution segment.
See ExecInterceptor
for example use of an interceptor.
execInterceptor
- the execution interceptor to addcontinuation
- the rest of the code to be executedException
- any thrown by continuation
ExecInterceptor
<T> Promise<T> blocking(Callable<T> blockingOperation)
This method should be used to perform blocking IO, or to perform any operation that synchronously waits for something to happen.
The given blockingOperation
will be performed on a thread from a special thread pool for such operations
(i.e. not a thread from the main compute event loop).
The operation should do as little computation as possible. It should just perform the blocking operation and immediately return the result. Performing computation during the operation will degrade performance.
This method is just a specialization of promise(ratpack.func.Action<? super ratpack.exec.Fulfiller<T>>)
, and shares all of the same semantics with regard to
execution binding and execution-on-promise-subscription.
T
- the type of value created by the operationblockingOperation
- the operation that blocks<T> Promise<T> promise(Action<? super Fulfiller<T>> action)
This method can be used to integrate with APIs that produce values asynchronously.
The asynchronous API should be invoked during the execute method of the action given to this method.
The result of the asynchronous call is then given to the Fulfiller
that the action is given.
T
- the type of promised valueaction
- an action that invokes an asynchronous API, forwarding the result to the given fulfillerFulfiller
,
Fulfillment
ExecStarter exec()
<T> TransformablePublisher<T> stream(org.reactivestreams.Publisher<T> publisher)
This method allows the processing of elements (onNext) or termination signals (onError, onComplete) to happen outside of the execution stack of the Publisher. In other words these "events" are executed asynchronously, on a Ratpack managed thread, without blocking the Publisher.
T
- the type of streamed elementspublisher
- the provider of a potentially unbounded number of sequenced elements, publishing them according to the demand
received from its Subscriber(s)