public interface AsyncInvoker
Modifier and Type | Method and Description |
---|---|
java.util.concurrent.Future<Response> |
delete()
Invoke HTTP DELETE method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
delete(java.lang.Class<T> responseType)
Invoke HTTP DELETE method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
delete(GenericType<T> responseType)
Invoke HTTP DELETE method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
delete(InvocationCallback<T> callback)
Invoke HTTP DELETE method for the current request asynchronously.
|
java.util.concurrent.Future<Response> |
get()
Invoke HTTP GET method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
get(java.lang.Class<T> responseType)
Invoke HTTP GET method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
get(GenericType<T> responseType)
Invoke HTTP GET method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
get(InvocationCallback<T> callback)
Invoke HTTP GET method for the current request asynchronously.
|
java.util.concurrent.Future<Response> |
head()
Invoke HTTP HEAD method for the current request asynchronously.
|
java.util.concurrent.Future<Response> |
head(InvocationCallback<Response> callback)
Invoke HTTP HEAD method for the current request asynchronously.
|
java.util.concurrent.Future<Response> |
method(java.lang.String name)
Invoke an arbitrary method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
method(java.lang.String name,
java.lang.Class<T> responseType)
Invoke an arbitrary method for the current request asynchronously.
|
java.util.concurrent.Future<Response> |
method(java.lang.String name,
Entity<?> entity)
Invoke an arbitrary method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
method(java.lang.String name,
Entity<?> entity,
java.lang.Class<T> responseType)
Invoke an arbitrary method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
method(java.lang.String name,
Entity<?> entity,
GenericType<T> responseType)
Invoke an arbitrary method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
method(java.lang.String name,
Entity<?> entity,
InvocationCallback<T> callback)
Invoke an arbitrary method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
method(java.lang.String name,
GenericType<T> responseType)
Invoke an arbitrary method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
method(java.lang.String name,
InvocationCallback<T> callback)
Invoke an arbitrary method for the current request asynchronously.
|
java.util.concurrent.Future<Response> |
options()
Invoke HTTP OPTIONS method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
options(java.lang.Class<T> responseType)
Invoke HTTP OPTIONS method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
options(GenericType<T> responseType)
Invoke HTTP OPTIONS method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
options(InvocationCallback<T> callback)
Invoke HTTP OPTIONS method for the current request asynchronously.
|
java.util.concurrent.Future<Response> |
post(Entity<?> entity)
Invoke HTTP POST method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
post(Entity<?> entity,
java.lang.Class<T> responseType)
Invoke HTTP POST method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
post(Entity<?> entity,
GenericType<T> responseType)
Invoke HTTP POST method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
post(Entity<?> entity,
InvocationCallback<T> callback)
Invoke HTTP POST method for the current request asynchronously.
|
java.util.concurrent.Future<Response> |
put(Entity<?> entity)
Invoke HTTP PUT method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
put(Entity<?> entity,
java.lang.Class<T> responseType)
Invoke HTTP PUT method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
put(Entity<?> entity,
GenericType<T> responseType)
Invoke HTTP PUT method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
put(Entity<?> entity,
InvocationCallback<T> callback)
Invoke HTTP PUT method for the current request asynchronously.
|
java.util.concurrent.Future<Response> |
trace()
Invoke HTTP TRACE method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
trace(java.lang.Class<T> responseType)
Invoke HTTP TRACE method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
trace(GenericType<T> responseType)
Invoke HTTP TRACE method for the current request asynchronously.
|
<T> java.util.concurrent.Future<T> |
trace(InvocationCallback<T> callback)
Invoke HTTP TRACE method for the current request asynchronously.
|
java.util.concurrent.Future<Response> get()
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps a ProcessingException
thrown
in case of an invocation processing failure. Note that in case a processing of a properly received response fails,
the wrapped processing exception will be of ResponseProcessingException
type and will contain the
Response
instance whose processing has failed.
future
.<T> java.util.concurrent.Future<T> get(java.lang.Class<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.responseType
- Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> get(GenericType<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.responseType
- representation of a generic Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> get(InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the generic type of the supplied response callback is not Response
. In case
a processing of a properly received response fails, the wrapped processing exception will be of
ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.callback
- asynchronous invocation callback.future
.java.util.concurrent.Future<Response> put(Entity<?> entity)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps a ProcessingException
thrown
in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped
processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
entity
- request entity, including it's full Variant
information. Any variant-related
HTTP headers previously set (namely Content-Type
, Content-Language
and Content-Encoding
) will
be overwritten using the entity variant information.future
.<T> java.util.concurrent.Future<T> put(Entity<?> entity, java.lang.Class<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.entity
- request entity, including it's full Variant
information. Any variant-related
HTTP headers previously set (namely Content-Type
, Content-Language
and Content-Encoding
) will
be overwritten using the entity variant information.responseType
- Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> put(Entity<?> entity, GenericType<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.entity
- request entity, including it's full Variant
information. Any variant-related
HTTP headers previously set (namely Content-Type
, Content-Language
and Content-Encoding
) will
be overwritten using the entity variant information.responseType
- representation of a generic Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> put(Entity<?> entity, InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the generic type of the supplied response callback is not Response
. In case
a processing of a properly received response fails, the wrapped processing exception will be of
ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.entity
- request entity, including it's full Variant
information. Any variant-related
HTTP headers previously set (namely Content-Type
, Content-Language
and Content-Encoding
) will
be overwritten using the entity variant information.callback
- asynchronous invocation callback.future
.java.util.concurrent.Future<Response> post(Entity<?> entity)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps a ProcessingException
thrown
in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped
processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
entity
- request entity, including it's full Variant
information. Any variant-related
HTTP headers previously set (namely Content-Type
, Content-Language
and Content-Encoding
) will
be overwritten using the entity variant information.future
.ProcessingException
- in case the invocation processing has failed.<T> java.util.concurrent.Future<T> post(Entity<?> entity, java.lang.Class<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.entity
- request entity, including it's full Variant
information. Any variant-related
HTTP headers previously set (namely Content-Type
, Content-Language
and Content-Encoding
) will
be overwritten using the entity variant information.responseType
- Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> post(Entity<?> entity, GenericType<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.entity
- request entity, including it's full Variant
information. Any variant-related
HTTP headers previously set (namely Content-Type
, Content-Language
and Content-Encoding
) will
be overwritten using the entity variant information.responseType
- representation of a generic Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> post(Entity<?> entity, InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the generic type of the supplied response callback is not Response
. In case
a processing of a properly received response fails, the wrapped processing exception will be of
ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.entity
- request entity, including it's full Variant
information. Any variant-related
HTTP headers previously set (namely Content-Type
, Content-Language
and Content-Encoding
) will
be overwritten using the entity variant information.callback
- asynchronous invocation callback.future
.java.util.concurrent.Future<Response> delete()
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps a ProcessingException
thrown
in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped
processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
future
.<T> java.util.concurrent.Future<T> delete(java.lang.Class<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.responseType
- Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> delete(GenericType<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.responseType
- representation of a generic Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> delete(InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the generic type of the supplied response callback is not Response
. In case
a processing of a properly received response fails, the wrapped processing exception will be of
ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.callback
- asynchronous invocation callback.future
.java.util.concurrent.Future<Response> head()
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps a ProcessingException
thrown
in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped
processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
future
.java.util.concurrent.Future<Response> head(InvocationCallback<Response> callback)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps a ProcessingException
thrown
in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped
processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
callback
- asynchronous invocation callback.future
.java.util.concurrent.Future<Response> options()
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps a ProcessingException
thrown
in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped
processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
future
.<T> java.util.concurrent.Future<T> options(java.lang.Class<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.responseType
- Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> options(GenericType<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.responseType
- representation of a generic Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> options(InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the generic type of the supplied response callback is not Response
. In case
a processing of a properly received response fails, the wrapped processing exception will be of
ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.callback
- asynchronous invocation callback.future
.java.util.concurrent.Future<Response> trace()
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps a ProcessingException
thrown
in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped
processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
future
.<T> java.util.concurrent.Future<T> trace(java.lang.Class<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.responseType
- Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> trace(GenericType<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.responseType
- representation of a generic Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> trace(InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the generic type of the supplied response callback is not Response
. In case
a processing of a properly received response fails, the wrapped processing exception will be of
ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.callback
- asynchronous invocation callback.future
.java.util.concurrent.Future<Response> method(java.lang.String name)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps a ProcessingException
thrown
in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped
processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
name
- method name.future
.<T> java.util.concurrent.Future<T> method(java.lang.String name, java.lang.Class<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.name
- method name.responseType
- Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> method(java.lang.String name, GenericType<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.name
- method name.responseType
- representation of a generic Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> method(java.lang.String name, InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the generic type of the supplied response callback is not Response
. In case
a processing of a properly received response fails, the wrapped processing exception will be of
ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.name
- method name.callback
- asynchronous invocation callback.future
.java.util.concurrent.Future<Response> method(java.lang.String name, Entity<?> entity)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps a ProcessingException
thrown
in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped
processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
name
- method name.entity
- request entity, including it's full Variant
information. Any variant-related
HTTP headers previously set (namely Content-Type
, Content-Language
and Content-Encoding
) will
be overwritten using the entity variant information.future
.<T> java.util.concurrent.Future<T> method(java.lang.String name, Entity<?> entity, java.lang.Class<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.name
- method name.entity
- request entity, including it's full Variant
information. Any variant-related
HTTP headers previously set (namely Content-Type
, Content-Language
and Content-Encoding
) will
be overwritten using the entity variant information.responseType
- Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> method(java.lang.String name, Entity<?> entity, GenericType<T> responseType)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the specified response type is not Response
. In case a processing of a
properly received response fails, the wrapped processing exception will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.name
- method name.entity
- request entity, including it's full Variant
information. Any variant-related
HTTP headers previously set (namely Content-Type
, Content-Language
and Content-Encoding
) will
be overwritten using the entity variant information.responseType
- representation of a generic Java type the response entity will be converted to.future
.<T> java.util.concurrent.Future<T> method(java.lang.String name, Entity<?> entity, InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned Future
instance may
throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing failure or a WebApplicationException
or one of its subclasses
thrown in case the received response status code is not successful
and the generic type of the supplied response callback is not Response
. In case
a processing of a properly received response fails, the wrapped processing exception will be of
ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.name
- method name.entity
- request entity, including it's full Variant
information. Any variant-related
HTTP headers previously set (namely Content-Type
, Content-Language
and Content-Encoding
) will
be overwritten using the entity variant information.callback
- asynchronous invocation callback.future
.