honeymoose/OpenSearch
1
0
Fork 0
mirror of https://github.com/honeymoose/OpenSearch.git synced 2025-02-24 05:44:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

Expose the ability to cancel async requests in REST high-level client (#45688)

Browse Source 
This commits makes all the async methods in the high level client return the `Cancellable` object that the low level client now exposes.

Relates to #45379 
Closes #44802
This commit is contained in:
Jilles van Gurp 2019-08-23 16:38:15 +02:00 committed by Luca Cavanna
parent cfb186afaf
commit 60f40d7638
18 changed files with 1043 additions and 749 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
client/rest-high-level/src/main/java/org/elasticsearch/client/CcrClient.java
View File

@ -85,15 +85,15 @@ public final class CcrClient {
* *
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-follow.html"> * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-follow.html">
* the docs</a> for more. * the docs</a> for more.
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putFollowAsync(PutFollowRequest request, public Cancellable putFollowAsync(PutFollowRequest request,
RequestOptions options, RequestOptions options,
ActionListener<PutFollowResponse> listener) { ActionListener<PutFollowResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( return restHighLevelClient.performRequestAsyncAndParseEntity(
request, request,
CcrRequestConverters::putFollow, CcrRequestConverters::putFollow,
options, options,
@ -129,15 +129,15 @@ public final class CcrClient {
* *
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-pause-follow.html"> * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-pause-follow.html">
* the docs</a> for more. * the docs</a> for more.
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void pauseFollowAsync(PauseFollowRequest request, public Cancellable pauseFollowAsync(PauseFollowRequest request,
RequestOptions options, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( return restHighLevelClient.performRequestAsyncAndParseEntity(
request, request,
CcrRequestConverters::pauseFollow, CcrRequestConverters::pauseFollow,
options, options,
@ -172,15 +172,15 @@ public final class CcrClient {
* *
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-resume-follow.html"> * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-resume-follow.html">
* the docs</a> for more. * the docs</a> for more.
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void resumeFollowAsync(ResumeFollowRequest request, public Cancellable resumeFollowAsync(ResumeFollowRequest request,
RequestOptions options, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( return restHighLevelClient.performRequestAsyncAndParseEntity(
request, request,
CcrRequestConverters::resumeFollow, CcrRequestConverters::resumeFollow,
options, options,
@ -217,15 +217,15 @@ public final class CcrClient {
* *
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-unfollow.html"> * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-unfollow.html">
* the docs</a> for more. * the docs</a> for more.
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void unfollowAsync(UnfollowRequest request, public Cancellable unfollowAsync(UnfollowRequest request,
RequestOptions options, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( return restHighLevelClient.performRequestAsyncAndParseEntity(
request, request,
CcrRequestConverters::unfollow, CcrRequestConverters::unfollow,
options, options,
@ -260,15 +260,15 @@ public final class CcrClient {
* *
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-forget-follower.html">the docs</a> for more details * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-forget-follower.html">the docs</a> for more details
* on the intended usage of this API. * on the intended usage of this API.
*
* @param request the request * @param request the request
* @param options the request options (e.g., headers), use {@link RequestOptions#DEFAULT} if the defaults are acceptable. * @param options the request options (e.g., headers), use {@link RequestOptions#DEFAULT} if the defaults are acceptable.
* @return cancellable that may be used to cancel the request
*/ */
public void forgetFollowerAsync( public Cancellable forgetFollowerAsync(
final ForgetFollowerRequest request, final ForgetFollowerRequest request,
final RequestOptions options, final RequestOptions options,
final ActionListener<BroadcastResponse> listener) { final ActionListener<BroadcastResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( return restHighLevelClient.performRequestAsyncAndParseEntity(
request, request,
CcrRequestConverters::forgetFollower, CcrRequestConverters::forgetFollower,
options, options,
@ -303,15 +303,15 @@ public final class CcrClient {
* *
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-auto-follow-pattern.html"> * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-auto-follow-pattern.html">
* the docs</a> for more. * the docs</a> for more.
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putAutoFollowPatternAsync(PutAutoFollowPatternRequest request, public Cancellable putAutoFollowPatternAsync(PutAutoFollowPatternRequest request,
RequestOptions options, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( return restHighLevelClient.performRequestAsyncAndParseEntity(
request, request,
CcrRequestConverters::putAutoFollowPattern, CcrRequestConverters::putAutoFollowPattern,
options, options,
@ -347,15 +347,15 @@ public final class CcrClient {
* *
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-delete-auto-follow-pattern.html"> * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-delete-auto-follow-pattern.html">
* the docs</a> for more. * the docs</a> for more.
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteAutoFollowPatternAsync(DeleteAutoFollowPatternRequest request, public Cancellable deleteAutoFollowPatternAsync(DeleteAutoFollowPatternRequest request,
RequestOptions options, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( return restHighLevelClient.performRequestAsyncAndParseEntity(
request, request,
CcrRequestConverters::deleteAutoFollowPattern, CcrRequestConverters::deleteAutoFollowPattern,
options, options,
@ -392,15 +392,15 @@ public final class CcrClient {
* *
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-auto-follow-pattern.html"> * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-auto-follow-pattern.html">
* the docs</a> for more. * the docs</a> for more.
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getAutoFollowPatternAsync(GetAutoFollowPatternRequest request, public Cancellable getAutoFollowPatternAsync(GetAutoFollowPatternRequest request,
RequestOptions options, RequestOptions options,
ActionListener<GetAutoFollowPatternResponse> listener) { ActionListener<GetAutoFollowPatternResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( return restHighLevelClient.performRequestAsyncAndParseEntity(
request, request,
CcrRequestConverters::getAutoFollowPattern, CcrRequestConverters::getAutoFollowPattern,
options, options,
@ -437,14 +437,14 @@ public final class CcrClient {
* *
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-stats.html"> * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-stats.html">
* the docs</a> for more. * the docs</a> for more.
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @return cancellable that may be used to cancel the request
*/ */
public void getCcrStatsAsync(CcrStatsRequest request, public Cancellable getCcrStatsAsync(CcrStatsRequest request,
RequestOptions options, RequestOptions options,
ActionListener<CcrStatsResponse> listener) { ActionListener<CcrStatsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( return restHighLevelClient.performRequestAsyncAndParseEntity(
request, request,
CcrRequestConverters::getCcrStats, CcrRequestConverters::getCcrStats,
options, options,
@ -481,14 +481,14 @@ public final class CcrClient {
* *
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-follow-stats.html"> * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-follow-stats.html">
* the docs</a> for more. * the docs</a> for more.
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @return cancellable that may be used to cancel the request
*/ */
public void getFollowStatsAsync(FollowStatsRequest request, public Cancellable getFollowStatsAsync(FollowStatsRequest request,
RequestOptions options, RequestOptions options,
ActionListener<FollowStatsResponse> listener) { ActionListener<FollowStatsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( return restHighLevelClient.performRequestAsyncAndParseEntity(
request, request,
CcrRequestConverters::getFollowStats, CcrRequestConverters::getFollowStats,
options, options,
@ -524,14 +524,14 @@ public final class CcrClient {
* *
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-follow-info.html"> * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-follow-info.html">
* the docs</a> for more. * the docs</a> for more.
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @return cancellable that may be used to cancel the request
*/ */
public void getFollowInfoAsync(FollowInfoRequest request, public Cancellable getFollowInfoAsync(FollowInfoRequest request,
RequestOptions options, RequestOptions options,
ActionListener<FollowInfoResponse> listener) { ActionListener<FollowInfoResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( return restHighLevelClient.performRequestAsyncAndParseEntity(
request, request,
CcrRequestConverters::getFollowInfo, CcrRequestConverters::getFollowInfo,
options, options,

22
client/rest-high-level/src/main/java/org/elasticsearch/client/ClusterClient.java
View File

@ -67,10 +67,12 @@ public final class ClusterClient {
* @param clusterUpdateSettingsRequest the request * @param clusterUpdateSettingsRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putSettingsAsync(ClusterUpdateSettingsRequest clusterUpdateSettingsRequest, RequestOptions options, public Cancellable putSettingsAsync(ClusterUpdateSettingsRequest clusterUpdateSettingsRequest, RequestOptions options,
ActionListener<ClusterUpdateSettingsResponse> listener) { ActionListener<ClusterUpdateSettingsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(clusterUpdateSettingsRequest, ClusterRequestConverters::clusterPutSettings, return restHighLevelClient.performRequestAsyncAndParseEntity(clusterUpdateSettingsRequest,
ClusterRequestConverters::clusterPutSettings,
options, ClusterUpdateSettingsResponse::fromXContent, listener, emptySet()); options, ClusterUpdateSettingsResponse::fromXContent, listener, emptySet());
} }
@ -96,10 +98,12 @@ public final class ClusterClient {
* @param clusterGetSettingsRequest the request * @param clusterGetSettingsRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getSettingsAsync(ClusterGetSettingsRequest clusterGetSettingsRequest, RequestOptions options, public Cancellable getSettingsAsync(ClusterGetSettingsRequest clusterGetSettingsRequest, RequestOptions options,
ActionListener<ClusterGetSettingsResponse> listener) { ActionListener<ClusterGetSettingsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(clusterGetSettingsRequest, ClusterRequestConverters::clusterGetSettings, return restHighLevelClient.performRequestAsyncAndParseEntity(
clusterGetSettingsRequest, ClusterRequestConverters::clusterGetSettings,
options, ClusterGetSettingsResponse::fromXContent, listener, emptySet()); options, ClusterGetSettingsResponse::fromXContent, listener, emptySet());
} }
@ -127,9 +131,11 @@ public final class ClusterClient {
* @param healthRequest the request * @param healthRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void healthAsync(ClusterHealthRequest healthRequest, RequestOptions options, ActionListener<ClusterHealthResponse> listener) { public Cancellable healthAsync(ClusterHealthRequest healthRequest, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(healthRequest, ClusterRequestConverters::clusterHealth, options, ActionListener<ClusterHealthResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(healthRequest, ClusterRequestConverters::clusterHealth, options,
ClusterHealthResponse::fromXContent, listener, singleton(RestStatus.REQUEST_TIMEOUT.getStatus())); ClusterHealthResponse::fromXContent, listener, singleton(RestStatus.REQUEST_TIMEOUT.getStatus()));
} }
} }

66
client/rest-high-level/src/main/java/org/elasticsearch/client/DataFrameClient.java
View File

@ -74,15 +74,15 @@ public final class DataFrameClient {
* For additional info * For additional info
* see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/put-data-frame-transform.html"> * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/put-data-frame-transform.html">
* Create data frame transform documentation</a> * Create data frame transform documentation</a>
*
* @param request The PutDataFrameTransformRequest containing the * @param request The PutDataFrameTransformRequest containing the
* {@link org.elasticsearch.client.transform.transforms.DataFrameTransformConfig}. * {@link org.elasticsearch.client.transform.transforms.DataFrameTransformConfig}.
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putDataFrameTransformAsync(PutDataFrameTransformRequest request, RequestOptions options, public Cancellable putDataFrameTransformAsync(PutDataFrameTransformRequest request, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
DataFrameRequestConverters::putDataFrameTransform, DataFrameRequestConverters::putDataFrameTransform,
options, options,
AcknowledgedResponse::fromXContent, AcknowledgedResponse::fromXContent,
@ -118,16 +118,16 @@ public final class DataFrameClient {
* For additional info * For additional info
* see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/update-data-frame-transform.html"> * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/update-data-frame-transform.html">
* Create data frame transform documentation</a> * Create data frame transform documentation</a>
*
* @param request The UpdateDataFrameTransformRequest containing the * @param request The UpdateDataFrameTransformRequest containing the
* {@link org.elasticsearch.client.transform.transforms.DataFrameTransformConfigUpdate}. * {@link org.elasticsearch.client.transform.transforms.DataFrameTransformConfigUpdate}.
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void updateDataFrameTransformAsync(UpdateDataFrameTransformRequest request, public Cancellable updateDataFrameTransformAsync(UpdateDataFrameTransformRequest request,
RequestOptions options, RequestOptions options,
ActionListener<UpdateDataFrameTransformResponse> listener) { ActionListener<UpdateDataFrameTransformResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
DataFrameRequestConverters::updateDataFrameTransform, DataFrameRequestConverters::updateDataFrameTransform,
options, options,
UpdateDataFrameTransformResponse::fromXContent, UpdateDataFrameTransformResponse::fromXContent,
@ -162,14 +162,14 @@ public final class DataFrameClient {
* For additional info * For additional info
* see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/get-data-frame-transform-stats.html"> * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/get-data-frame-transform-stats.html">
* Get data frame transform stats documentation</a> * Get data frame transform stats documentation</a>
*
* @param request Specifies the which transforms to get the stats for * @param request Specifies the which transforms to get the stats for
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getDataFrameTransformStatsAsync(GetDataFrameTransformStatsRequest request, RequestOptions options, public Cancellable getDataFrameTransformStatsAsync(GetDataFrameTransformStatsRequest request, RequestOptions options,
ActionListener<GetDataFrameTransformStatsResponse> listener) { ActionListener<GetDataFrameTransformStatsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
DataFrameRequestConverters::getDataFrameTransformStats, DataFrameRequestConverters::getDataFrameTransformStats,
options, options,
GetDataFrameTransformStatsResponse::fromXContent, GetDataFrameTransformStatsResponse::fromXContent,
@ -204,14 +204,14 @@ public final class DataFrameClient {
* For additional info * For additional info
* see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/delete-data-frame-transform.html"> * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/delete-data-frame-transform.html">
* Delete data frame transform documentation</a> * Delete data frame transform documentation</a>
*
* @param request The delete data frame transform request * @param request The delete data frame transform request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteDataFrameTransformAsync(DeleteDataFrameTransformRequest request, RequestOptions options, public Cancellable deleteDataFrameTransformAsync(DeleteDataFrameTransformRequest request, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
DataFrameRequestConverters::deleteDataFrameTransform, DataFrameRequestConverters::deleteDataFrameTransform,
options, options,
AcknowledgedResponse::fromXContent, AcknowledgedResponse::fromXContent,
@ -245,14 +245,14 @@ public final class DataFrameClient {
* <p> * <p>
* see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/preview-data-frame-transform.html"> * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/preview-data-frame-transform.html">
* Preview data frame transform documentation</a> * Preview data frame transform documentation</a>
*
* @param request The preview data frame transform request * @param request The preview data frame transform request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void previewDataFrameTransformAsync(PreviewDataFrameTransformRequest request, RequestOptions options, public Cancellable previewDataFrameTransformAsync(PreviewDataFrameTransformRequest request, RequestOptions options,
ActionListener<PreviewDataFrameTransformResponse> listener) { ActionListener<PreviewDataFrameTransformResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
DataFrameRequestConverters::previewDataFrameTransform, DataFrameRequestConverters::previewDataFrameTransform,
options, options,
PreviewDataFrameTransformResponse::fromXContent, PreviewDataFrameTransformResponse::fromXContent,
@ -287,14 +287,14 @@ public final class DataFrameClient {
* For additional info * For additional info
* see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/start-data-frame-transform.html"> * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/start-data-frame-transform.html">
* Start data frame transform documentation</a> * Start data frame transform documentation</a>
*
* @param request The start data frame transform request * @param request The start data frame transform request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void startDataFrameTransformAsync(StartDataFrameTransformRequest request, RequestOptions options, public Cancellable startDataFrameTransformAsync(StartDataFrameTransformRequest request, RequestOptions options,
ActionListener<StartDataFrameTransformResponse> listener) { ActionListener<StartDataFrameTransformResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
DataFrameRequestConverters::startDataFrameTransform, DataFrameRequestConverters::startDataFrameTransform,
options, options,
StartDataFrameTransformResponse::fromXContent, StartDataFrameTransformResponse::fromXContent,
@ -329,14 +329,14 @@ public final class DataFrameClient {
* For additional info * For additional info
* see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/stop-data-frame-transform.html"> * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/stop-data-frame-transform.html">
* Stop data frame transform documentation</a> * Stop data frame transform documentation</a>
*
* @param request The stop data frame transform request * @param request The stop data frame transform request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void stopDataFrameTransformAsync(StopDataFrameTransformRequest request, RequestOptions options, public Cancellable stopDataFrameTransformAsync(StopDataFrameTransformRequest request, RequestOptions options,
ActionListener<StopDataFrameTransformResponse> listener) { ActionListener<StopDataFrameTransformResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
DataFrameRequestConverters::stopDataFrameTransform, DataFrameRequestConverters::stopDataFrameTransform,
options, options,
StopDataFrameTransformResponse::fromXContent, StopDataFrameTransformResponse::fromXContent,
@ -371,14 +371,14 @@ public final class DataFrameClient {
* For additional info * For additional info
* see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/get-data-frame-transform.html"> * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/get-data-frame-transform.html">
* Get data frame transform documentation</a> * Get data frame transform documentation</a>
*
* @param request The get data frame transform request * @param request The get data frame transform request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getDataFrameTransformAsync(GetDataFrameTransformRequest request, RequestOptions options, public Cancellable getDataFrameTransformAsync(GetDataFrameTransformRequest request, RequestOptions options,
ActionListener<GetDataFrameTransformResponse> listener) { ActionListener<GetDataFrameTransformResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
DataFrameRequestConverters::getDataFrameTransform, DataFrameRequestConverters::getDataFrameTransform,
options, options,
GetDataFrameTransformResponse::fromXContent, GetDataFrameTransformResponse::fromXContent,

15
client/rest-high-level/src/main/java/org/elasticsearch/client/GraphClient.java
View File

@ -34,7 +34,7 @@ public class GraphClient {
GraphClient(RestHighLevelClient restHighLevelClient) { GraphClient(RestHighLevelClient restHighLevelClient) {
this.restHighLevelClient = restHighLevelClient; this.restHighLevelClient = restHighLevelClient;
} }
/** /**
* Executes an exploration request using the Graph API. * Executes an exploration request using the Graph API.
* *
@ -52,12 +52,13 @@ public class GraphClient {
* *
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/graph-explore-api.html">Graph API * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/graph-explore-api.html">Graph API
* on elastic.co</a>. * on elastic.co</a>.
* @return cancellable that may be used to cancel the request
*/ */
public final void exploreAsync(GraphExploreRequest graphExploreRequest, public final Cancellable exploreAsync(GraphExploreRequest graphExploreRequest,
RequestOptions options, RequestOptions options,
ActionListener<GraphExploreResponse> listener) { ActionListener<GraphExploreResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(graphExploreRequest, GraphRequestConverters::explore, return restHighLevelClient.performRequestAsyncAndParseEntity(graphExploreRequest, GraphRequestConverters::explore,
options, GraphExploreResponse::fromXContent, listener, emptySet()); options, GraphExploreResponse::fromXContent, listener, emptySet());
} }
} }

94
client/rest-high-level/src/main/java/org/elasticsearch/client/IndexLifecycleClient.java
View File

@ -76,10 +76,11 @@ public class IndexLifecycleClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getLifecyclePolicyAsync(GetLifecyclePolicyRequest request, RequestOptions options, public Cancellable getLifecyclePolicyAsync(GetLifecyclePolicyRequest request, RequestOptions options,
ActionListener<GetLifecyclePolicyResponse> listener) { ActionListener<GetLifecyclePolicyResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::getLifecyclePolicy, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::getLifecyclePolicy, options,
GetLifecyclePolicyResponse::fromXContent, listener, emptySet()); GetLifecyclePolicyResponse::fromXContent, listener, emptySet());
} }
@ -105,10 +106,11 @@ public class IndexLifecycleClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putLifecyclePolicyAsync(PutLifecyclePolicyRequest request, RequestOptions options, public Cancellable putLifecyclePolicyAsync(PutLifecyclePolicyRequest request, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::putLifecyclePolicy, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::putLifecyclePolicy, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -134,10 +136,12 @@ public class IndexLifecycleClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteLifecyclePolicyAsync(DeleteLifecyclePolicyRequest request, RequestOptions options, public Cancellable deleteLifecyclePolicyAsync(DeleteLifecyclePolicyRequest request, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::deleteLifecyclePolicy, options, return restHighLevelClient.performRequestAsyncAndParseEntity(
request, IndexLifecycleRequestConverters::deleteLifecyclePolicy, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -163,10 +167,12 @@ public class IndexLifecycleClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void removeIndexLifecyclePolicyAsync(RemoveIndexLifecyclePolicyRequest request, RequestOptions options, public Cancellable removeIndexLifecyclePolicyAsync(RemoveIndexLifecyclePolicyRequest request, RequestOptions options,
ActionListener<RemoveIndexLifecyclePolicyResponse> listener) { ActionListener<RemoveIndexLifecyclePolicyResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::removeIndexLifecyclePolicy, options, return restHighLevelClient.performRequestAsyncAndParseEntity(
request, IndexLifecycleRequestConverters::removeIndexLifecyclePolicy, options,
RemoveIndexLifecyclePolicyResponse::fromXContent, listener, emptySet()); RemoveIndexLifecyclePolicyResponse::fromXContent, listener, emptySet());
} }
@ -191,9 +197,10 @@ public class IndexLifecycleClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void startILMAsync(StartILMRequest request, RequestOptions options, ActionListener<AcknowledgedResponse> listener) { public Cancellable startILMAsync(StartILMRequest request, RequestOptions options, ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::startILM, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::startILM, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -229,14 +236,15 @@ public class IndexLifecycleClient {
* Asynchronously get the status of index lifecycle management * Asynchronously get the status of index lifecycle management
* See <a href="https://fix-me-when-we-have-docs.com"> * See <a href="https://fix-me-when-we-have-docs.com">
* the docs</a> for more. * the docs</a> for more.
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void lifecycleManagementStatusAsync(LifecycleManagementStatusRequest request, RequestOptions options, public Cancellable lifecycleManagementStatusAsync(LifecycleManagementStatusRequest request, RequestOptions options,
ActionListener<LifecycleManagementStatusResponse> listener) { ActionListener<LifecycleManagementStatusResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::lifecycleManagementStatus, options, return restHighLevelClient.performRequestAsyncAndParseEntity(
request, IndexLifecycleRequestConverters::lifecycleManagementStatus, options,
LifecycleManagementStatusResponse::fromXContent, listener, emptySet()); LifecycleManagementStatusResponse::fromXContent, listener, emptySet());
} }
@ -247,9 +255,10 @@ public class IndexLifecycleClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void stopILMAsync(StopILMRequest request, RequestOptions options, ActionListener<AcknowledgedResponse> listener) { public Cancellable stopILMAsync(StopILMRequest request, RequestOptions options, ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::stopILM, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::stopILM, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -274,10 +283,11 @@ public class IndexLifecycleClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void explainLifecycleAsync(ExplainLifecycleRequest request, RequestOptions options, public Cancellable explainLifecycleAsync(ExplainLifecycleRequest request, RequestOptions options,
ActionListener<ExplainLifecycleResponse> listener) { ActionListener<ExplainLifecycleResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::explainLifecycle, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::explainLifecycle, options,
ExplainLifecycleResponse::fromXContent, listener, emptySet()); ExplainLifecycleResponse::fromXContent, listener, emptySet());
} }
@ -302,10 +312,11 @@ public class IndexLifecycleClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void retryLifecyclePolicyAsync(RetryLifecyclePolicyRequest request, RequestOptions options, public Cancellable retryLifecyclePolicyAsync(RetryLifecyclePolicyRequest request, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::retryLifecycle, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::retryLifecycle, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -337,10 +348,11 @@ public class IndexLifecycleClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getSnapshotLifecyclePolicyAsync(GetSnapshotLifecyclePolicyRequest request, RequestOptions options, public Cancellable getSnapshotLifecyclePolicyAsync(GetSnapshotLifecyclePolicyRequest request, RequestOptions options,
ActionListener<GetSnapshotLifecyclePolicyResponse> listener) { ActionListener<GetSnapshotLifecyclePolicyResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::getSnapshotLifecyclePolicy, return restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::getSnapshotLifecyclePolicy,
options, GetSnapshotLifecyclePolicyResponse::fromXContent, listener, emptySet()); options, GetSnapshotLifecyclePolicyResponse::fromXContent, listener, emptySet());
} }
@ -372,10 +384,11 @@ public class IndexLifecycleClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putSnapshotLifecyclePolicyAsync(PutSnapshotLifecyclePolicyRequest request, RequestOptions options, public Cancellable putSnapshotLifecyclePolicyAsync(PutSnapshotLifecyclePolicyRequest request, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::putSnapshotLifecyclePolicy, return restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::putSnapshotLifecyclePolicy,
options, AcknowledgedResponse::fromXContent, listener, emptySet()); options, AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -407,10 +420,12 @@ public class IndexLifecycleClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteSnapshotLifecyclePolicyAsync(DeleteSnapshotLifecyclePolicyRequest request, RequestOptions options, public Cancellable deleteSnapshotLifecyclePolicyAsync(DeleteSnapshotLifecyclePolicyRequest request,
ActionListener<AcknowledgedResponse> listener) { RequestOptions options,ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::deleteSnapshotLifecyclePolicy, return restHighLevelClient.performRequestAsyncAndParseEntity(
request, IndexLifecycleRequestConverters::deleteSnapshotLifecyclePolicy,
options, AcknowledgedResponse::fromXContent, listener, emptySet()); options, AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -442,10 +457,13 @@ public class IndexLifecycleClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void executeSnapshotLifecyclePolicyAsync(ExecuteSnapshotLifecyclePolicyRequest request, RequestOptions options, public Cancellable executeSnapshotLifecyclePolicyAsync(
ActionListener<ExecuteSnapshotLifecyclePolicyResponse> listener) { ExecuteSnapshotLifecyclePolicyRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::executeSnapshotLifecyclePolicy, ActionListener<ExecuteSnapshotLifecyclePolicyResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(
request, IndexLifecycleRequestConverters::executeSnapshotLifecyclePolicy,
options, ExecuteSnapshotLifecyclePolicyResponse::fromXContent, listener, emptySet()); options, ExecuteSnapshotLifecyclePolicyResponse::fromXContent, listener, emptySet());
} }

333
client/rest-high-level/src/main/java/org/elasticsearch/client/IndicesClient.java
View File

@ -108,9 +108,12 @@ public final class IndicesClient {
* @param deleteIndexRequest the request * @param deleteIndexRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteAsync(DeleteIndexRequest deleteIndexRequest, RequestOptions options, ActionListener<AcknowledgedResponse> listener) { public Cancellable deleteAsync(DeleteIndexRequest deleteIndexRequest, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(deleteIndexRequest, IndicesRequestConverters::deleteIndex, options, ActionListener<AcknowledgedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(deleteIndexRequest,
IndicesRequestConverters::deleteIndex, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -136,11 +139,12 @@ public final class IndicesClient {
* @param createIndexRequest the request * @param createIndexRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void createAsync(CreateIndexRequest createIndexRequest, public Cancellable createAsync(CreateIndexRequest createIndexRequest,
RequestOptions options, RequestOptions options,
ActionListener<CreateIndexResponse> listener) { ActionListener<CreateIndexResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(createIndexRequest, IndicesRequestConverters::createIndex, options, return restHighLevelClient.performRequestAsyncAndParseEntity(createIndexRequest, IndicesRequestConverters::createIndex, options,
CreateIndexResponse::fromXContent, listener, emptySet()); CreateIndexResponse::fromXContent, listener, emptySet());
} }
@ -177,12 +181,13 @@ public final class IndicesClient {
* @deprecated This method uses an old request object which still refers to types, a deprecated feature. The * @deprecated This method uses an old request object which still refers to types, a deprecated feature. The
* method {@link #createAsync(CreateIndexRequest, RequestOptions, ActionListener)} should be used instead, * method {@link #createAsync(CreateIndexRequest, RequestOptions, ActionListener)} should be used instead,
* which accepts a new request object. * which accepts a new request object.
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public void createAsync(org.elasticsearch.action.admin.indices.create.CreateIndexRequest createIndexRequest, public Cancellable createAsync(org.elasticsearch.action.admin.indices.create.CreateIndexRequest createIndexRequest,
RequestOptions options, RequestOptions options,
ActionListener<org.elasticsearch.action.admin.indices.create.CreateIndexResponse> listener) { ActionListener<org.elasticsearch.action.admin.indices.create.CreateIndexResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(createIndexRequest, return restHighLevelClient.performRequestAsyncAndParseEntity(createIndexRequest,
IndicesRequestConverters::createIndex, options, IndicesRequestConverters::createIndex, options,
org.elasticsearch.action.admin.indices.create.CreateIndexResponse::fromXContent, listener, emptySet()); org.elasticsearch.action.admin.indices.create.CreateIndexResponse::fromXContent, listener, emptySet());
} }
@ -208,10 +213,11 @@ public final class IndicesClient {
* @param putMappingRequest the request * @param putMappingRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putMappingAsync(PutMappingRequest putMappingRequest, RequestOptions options, public Cancellable putMappingAsync(PutMappingRequest putMappingRequest, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(putMappingRequest, IndicesRequestConverters::putMapping, options, return restHighLevelClient.performRequestAsyncAndParseEntity(putMappingRequest, IndicesRequestConverters::putMapping, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -245,12 +251,13 @@ public final class IndicesClient {
* @deprecated This method uses an old request object which still refers to types, a deprecated feature. The * @deprecated This method uses an old request object which still refers to types, a deprecated feature. The
* method {@link #putMappingAsync(PutMappingRequest, RequestOptions, ActionListener)} should be used instead, * method {@link #putMappingAsync(PutMappingRequest, RequestOptions, ActionListener)} should be used instead,
* which accepts a new request object. * which accepts a new request object.
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public void putMappingAsync(org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest putMappingRequest, public Cancellable putMappingAsync(org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest putMappingRequest,
RequestOptions options, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(putMappingRequest, IndicesRequestConverters::putMapping, options, return restHighLevelClient.performRequestAsyncAndParseEntity(putMappingRequest, IndicesRequestConverters::putMapping, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -278,10 +285,11 @@ public final class IndicesClient {
* @param getMappingsRequest the request * @param getMappingsRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getMappingAsync(GetMappingsRequest getMappingsRequest, RequestOptions options, public Cancellable getMappingAsync(GetMappingsRequest getMappingsRequest, RequestOptions options,
ActionListener<GetMappingsResponse> listener) { ActionListener<GetMappingsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(getMappingsRequest, return restHighLevelClient.performRequestAsyncAndParseEntity(getMappingsRequest,
IndicesRequestConverters::getMappings, IndicesRequestConverters::getMappings,
options, options,
GetMappingsResponse::fromXContent, GetMappingsResponse::fromXContent,
@ -324,12 +332,13 @@ public final class IndicesClient {
* @deprecated This method uses old request and response objects which still refer to types, a deprecated feature. * @deprecated This method uses old request and response objects which still refer to types, a deprecated feature.
* The method {@link #getMapping(GetMappingsRequest, RequestOptions)} should be used instead, which accepts a new * The method {@link #getMapping(GetMappingsRequest, RequestOptions)} should be used instead, which accepts a new
* request object. * request object.
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public void getMappingAsync(org.elasticsearch.action.admin.indices.mapping.get.GetMappingsRequest getMappingsRequest, public Cancellable getMappingAsync(org.elasticsearch.action.admin.indices.mapping.get.GetMappingsRequest getMappingsRequest,
RequestOptions options, RequestOptions options,
ActionListener<org.elasticsearch.action.admin.indices.mapping.get.GetMappingsResponse> listener) { ActionListener<org.elasticsearch.action.admin.indices.mapping.get.GetMappingsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(getMappingsRequest, return restHighLevelClient.performRequestAsyncAndParseEntity(getMappingsRequest,
IndicesRequestConverters::getMappings, IndicesRequestConverters::getMappings,
options, options,
org.elasticsearch.action.admin.indices.mapping.get.GetMappingsResponse::fromXContent, org.elasticsearch.action.admin.indices.mapping.get.GetMappingsResponse::fromXContent,
@ -369,13 +378,17 @@ public final class IndicesClient {
* @deprecated This method uses old request and response objects which still refer to types, a deprecated feature. * @deprecated This method uses old request and response objects which still refer to types, a deprecated feature.
* The method {@link #getFieldMappingAsync(GetFieldMappingsRequest, RequestOptions, ActionListener)} should be * The method {@link #getFieldMappingAsync(GetFieldMappingsRequest, RequestOptions, ActionListener)} should be
* used instead, which accepts a new request object. * used instead, which accepts a new request object.
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public void getFieldMappingAsync(org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsRequest getFieldMappingsRequest, public Cancellable getFieldMappingAsync(
RequestOptions options, org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsRequest getFieldMappingsRequest,
ActionListener<org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse> listener) { RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(getFieldMappingsRequest, IndicesRequestConverters::getFieldMapping, options, ActionListener<org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse> listener) {
org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse::fromXContent, listener, emptySet()); return restHighLevelClient.performRequestAsyncAndParseEntity(getFieldMappingsRequest,
IndicesRequestConverters::getFieldMapping, options,
org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsResponse::fromXContent,
listener, emptySet());
} }
/** /**
@ -401,10 +414,12 @@ public final class IndicesClient {
* @param getFieldMappingsRequest the request * @param getFieldMappingsRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getFieldMappingAsync(GetFieldMappingsRequest getFieldMappingsRequest, public Cancellable getFieldMappingAsync(GetFieldMappingsRequest getFieldMappingsRequest,
RequestOptions options, ActionListener<GetFieldMappingsResponse> listener) { RequestOptions options, ActionListener<GetFieldMappingsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(getFieldMappingsRequest, IndicesRequestConverters::getFieldMapping, options, return restHighLevelClient.performRequestAsyncAndParseEntity(
getFieldMappingsRequest, IndicesRequestConverters::getFieldMapping, options,
GetFieldMappingsResponse::fromXContent, listener, emptySet()); GetFieldMappingsResponse::fromXContent, listener, emptySet());
} }
@ -429,10 +444,12 @@ public final class IndicesClient {
* @param indicesAliasesRequest the request * @param indicesAliasesRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void updateAliasesAsync(IndicesAliasesRequest indicesAliasesRequest, RequestOptions options, public Cancellable updateAliasesAsync(IndicesAliasesRequest indicesAliasesRequest, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(indicesAliasesRequest, IndicesRequestConverters::updateAliases, options, return restHighLevelClient.performRequestAsyncAndParseEntity(indicesAliasesRequest,
IndicesRequestConverters::updateAliases, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -457,9 +474,10 @@ public final class IndicesClient {
* @param openIndexRequest the request * @param openIndexRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void openAsync(OpenIndexRequest openIndexRequest, RequestOptions options, ActionListener<OpenIndexResponse> listener) { public Cancellable openAsync(OpenIndexRequest openIndexRequest, RequestOptions options, ActionListener<OpenIndexResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(openIndexRequest, IndicesRequestConverters::openIndex, options, return restHighLevelClient.performRequestAsyncAndParseEntity(openIndexRequest, IndicesRequestConverters::openIndex, options,
OpenIndexResponse::fromXContent, listener, emptySet()); OpenIndexResponse::fromXContent, listener, emptySet());
} }
@ -484,9 +502,12 @@ public final class IndicesClient {
* @param closeIndexRequest the request * @param closeIndexRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void closeAsync(CloseIndexRequest closeIndexRequest, RequestOptions options, ActionListener<CloseIndexResponse> listener) { public Cancellable closeAsync(CloseIndexRequest closeIndexRequest, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(closeIndexRequest, IndicesRequestConverters::closeIndex, options, ActionListener<CloseIndexResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(closeIndexRequest,
IndicesRequestConverters::closeIndex, options,
CloseIndexResponse::fromXContent, listener, emptySet()); CloseIndexResponse::fromXContent, listener, emptySet());
} }
@ -512,9 +533,10 @@ public final class IndicesClient {
* @param getAliasesRequest the request * @param getAliasesRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void existsAliasAsync(GetAliasesRequest getAliasesRequest, RequestOptions options, ActionListener<Boolean> listener) { public Cancellable existsAliasAsync(GetAliasesRequest getAliasesRequest, RequestOptions options, ActionListener<Boolean> listener) {
restHighLevelClient.performRequestAsync(getAliasesRequest, IndicesRequestConverters::existsAlias, options, return restHighLevelClient.performRequestAsync(getAliasesRequest, IndicesRequestConverters::existsAlias, options,
RestHighLevelClient::convertExistsResponse, listener, emptySet()); RestHighLevelClient::convertExistsResponse, listener, emptySet());
} }
@ -537,9 +559,10 @@ public final class IndicesClient {
* @param refreshRequest the request * @param refreshRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void refreshAsync(RefreshRequest refreshRequest, RequestOptions options, ActionListener<RefreshResponse> listener) { public Cancellable refreshAsync(RefreshRequest refreshRequest, RequestOptions options, ActionListener<RefreshResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(refreshRequest, IndicesRequestConverters::refresh, options, return restHighLevelClient.performRequestAsyncAndParseEntity(refreshRequest, IndicesRequestConverters::refresh, options,
RefreshResponse::fromXContent, listener, emptySet()); RefreshResponse::fromXContent, listener, emptySet());
} }
@ -562,9 +585,10 @@ public final class IndicesClient {
* @param flushRequest the request * @param flushRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void flushAsync(FlushRequest flushRequest, RequestOptions options, ActionListener<FlushResponse> listener) { public Cancellable flushAsync(FlushRequest flushRequest, RequestOptions options, ActionListener<FlushResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(flushRequest, IndicesRequestConverters::flush, options, return restHighLevelClient.performRequestAsyncAndParseEntity(flushRequest, IndicesRequestConverters::flush, options,
FlushResponse::fromXContent, listener, emptySet()); FlushResponse::fromXContent, listener, emptySet());
} }
@ -589,10 +613,11 @@ public final class IndicesClient {
* @param syncedFlushRequest the request * @param syncedFlushRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void flushSyncedAsync(SyncedFlushRequest syncedFlushRequest, RequestOptions options, public Cancellable flushSyncedAsync(SyncedFlushRequest syncedFlushRequest, RequestOptions options,
ActionListener<SyncedFlushResponse> listener) { ActionListener<SyncedFlushResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(syncedFlushRequest, IndicesRequestConverters::flushSynced, options, return restHighLevelClient.performRequestAsyncAndParseEntity(syncedFlushRequest, IndicesRequestConverters::flushSynced, options,
SyncedFlushResponse::fromXContent, listener, emptySet()); SyncedFlushResponse::fromXContent, listener, emptySet());
} }
@ -617,10 +642,11 @@ public final class IndicesClient {
* @param getSettingsRequest the request * @param getSettingsRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getSettingsAsync(GetSettingsRequest getSettingsRequest, RequestOptions options, public Cancellable getSettingsAsync(GetSettingsRequest getSettingsRequest, RequestOptions options,
ActionListener<GetSettingsResponse> listener) { ActionListener<GetSettingsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(getSettingsRequest, IndicesRequestConverters::getSettings, options, return restHighLevelClient.performRequestAsyncAndParseEntity(getSettingsRequest, IndicesRequestConverters::getSettings, options,
GetSettingsResponse::fromXContent, listener, emptySet()); GetSettingsResponse::fromXContent, listener, emptySet());
} }
@ -645,10 +671,11 @@ public final class IndicesClient {
* @param getIndexRequest the request * @param getIndexRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getAsync(GetIndexRequest getIndexRequest, RequestOptions options, public Cancellable getAsync(GetIndexRequest getIndexRequest, RequestOptions options,
ActionListener<GetIndexResponse> listener) { ActionListener<GetIndexResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(getIndexRequest, IndicesRequestConverters::getIndex, options, return restHighLevelClient.performRequestAsyncAndParseEntity(getIndexRequest, IndicesRequestConverters::getIndex, options,
GetIndexResponse::fromXContent, listener, emptySet()); GetIndexResponse::fromXContent, listener, emptySet());
} }
@ -679,11 +706,12 @@ public final class IndicesClient {
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @deprecated This method uses an old request object which still refers to types, a deprecated feature. The method * @deprecated This method uses an old request object which still refers to types, a deprecated feature. The method
* {@link #getAsync(GetIndexRequest, RequestOptions, ActionListener)} should be used instead, which accepts a new request object. * {@link #getAsync(GetIndexRequest, RequestOptions, ActionListener)} should be used instead, which accepts a new request object.
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public void getAsync(org.elasticsearch.action.admin.indices.get.GetIndexRequest getIndexRequest, RequestOptions options, public Cancellable getAsync(org.elasticsearch.action.admin.indices.get.GetIndexRequest getIndexRequest, RequestOptions options,
ActionListener<org.elasticsearch.action.admin.indices.get.GetIndexResponse> listener) { ActionListener<org.elasticsearch.action.admin.indices.get.GetIndexResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(getIndexRequest, IndicesRequestConverters::getIndex, options, return restHighLevelClient.performRequestAsyncAndParseEntity(getIndexRequest, IndicesRequestConverters::getIndex, options,
org.elasticsearch.action.admin.indices.get.GetIndexResponse::fromXContent, listener, emptySet()); org.elasticsearch.action.admin.indices.get.GetIndexResponse::fromXContent, listener, emptySet());
} }
@ -724,10 +752,12 @@ public final class IndicesClient {
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @deprecated use {@link #forcemergeAsync(ForceMergeRequest, RequestOptions, ActionListener)} instead * @deprecated use {@link #forcemergeAsync(ForceMergeRequest, RequestOptions, ActionListener)} instead
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public void forceMergeAsync(ForceMergeRequest forceMergeRequest, RequestOptions options, ActionListener<ForceMergeResponse> listener) { public Cancellable forceMergeAsync(ForceMergeRequest forceMergeRequest, RequestOptions options,
forcemergeAsync(forceMergeRequest, options, listener); ActionListener<ForceMergeResponse> listener) {
return forcemergeAsync(forceMergeRequest, options, listener);
} }
/** /**
@ -737,9 +767,12 @@ public final class IndicesClient {
* @param forceMergeRequest the request * @param forceMergeRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void forcemergeAsync(ForceMergeRequest forceMergeRequest, RequestOptions options, ActionListener<ForceMergeResponse> listener) { public Cancellable forcemergeAsync(ForceMergeRequest forceMergeRequest, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(forceMergeRequest, IndicesRequestConverters::forceMerge, options, ActionListener<ForceMergeResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(forceMergeRequest,
IndicesRequestConverters::forceMerge, options,
ForceMergeResponse::fromXContent, listener, emptySet()); ForceMergeResponse::fromXContent, listener, emptySet());
} }
@ -765,10 +798,12 @@ public final class IndicesClient {
* @param clearIndicesCacheRequest the request * @param clearIndicesCacheRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void clearCacheAsync(ClearIndicesCacheRequest clearIndicesCacheRequest, RequestOptions options, public Cancellable clearCacheAsync(ClearIndicesCacheRequest clearIndicesCacheRequest, RequestOptions options,
ActionListener<ClearIndicesCacheResponse> listener) { ActionListener<ClearIndicesCacheResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(clearIndicesCacheRequest, IndicesRequestConverters::clearCache, options, return restHighLevelClient.performRequestAsyncAndParseEntity(clearIndicesCacheRequest,
IndicesRequestConverters::clearCache, options,
ClearIndicesCacheResponse::fromXContent, listener, emptySet()); ClearIndicesCacheResponse::fromXContent, listener, emptySet());
} }
@ -798,9 +833,10 @@ public final class IndicesClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void existsAsync(GetIndexRequest request, RequestOptions options, ActionListener<Boolean> listener) { public Cancellable existsAsync(GetIndexRequest request, RequestOptions options, ActionListener<Boolean> listener) {
restHighLevelClient.performRequestAsync( return restHighLevelClient.performRequestAsync(
request, request,
IndicesRequestConverters::indicesExist, IndicesRequestConverters::indicesExist,
options, options,
@ -841,11 +877,12 @@ public final class IndicesClient {
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @deprecated This method uses an old request object which still refers to types, a deprecated feature. The method * @deprecated This method uses an old request object which still refers to types, a deprecated feature. The method
* {@link #existsAsync(GetIndexRequest, RequestOptions, ActionListener)} should be used instead, which accepts a new request object. * {@link #existsAsync(GetIndexRequest, RequestOptions, ActionListener)} should be used instead, which accepts a new request object.
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public void existsAsync(org.elasticsearch.action.admin.indices.get.GetIndexRequest request, RequestOptions options, public Cancellable existsAsync(org.elasticsearch.action.admin.indices.get.GetIndexRequest request, RequestOptions options,
ActionListener<Boolean> listener) { ActionListener<Boolean> listener) {
restHighLevelClient.performRequestAsync( return restHighLevelClient.performRequestAsync(
request, request,
IndicesRequestConverters::indicesExist, IndicesRequestConverters::indicesExist,
options, options,
@ -876,9 +913,10 @@ public final class IndicesClient {
* @param resizeRequest the request * @param resizeRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void shrinkAsync(ResizeRequest resizeRequest, RequestOptions options, ActionListener<ResizeResponse> listener) { public Cancellable shrinkAsync(ResizeRequest resizeRequest, RequestOptions options, ActionListener<ResizeResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(resizeRequest, IndicesRequestConverters::shrink, options, return restHighLevelClient.performRequestAsyncAndParseEntity(resizeRequest, IndicesRequestConverters::shrink, options,
ResizeResponse::fromXContent, listener, emptySet()); ResizeResponse::fromXContent, listener, emptySet());
} }
@ -903,9 +941,10 @@ public final class IndicesClient {
* @param resizeRequest the request * @param resizeRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void splitAsync(ResizeRequest resizeRequest, RequestOptions options, ActionListener<ResizeResponse> listener) { public Cancellable splitAsync(ResizeRequest resizeRequest, RequestOptions options, ActionListener<ResizeResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(resizeRequest, IndicesRequestConverters::split, options, return restHighLevelClient.performRequestAsyncAndParseEntity(resizeRequest, IndicesRequestConverters::split, options,
ResizeResponse::fromXContent, listener, emptySet()); ResizeResponse::fromXContent, listener, emptySet());
} }
@ -930,9 +969,10 @@ public final class IndicesClient {
* @param resizeRequest the request * @param resizeRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void cloneAsync(ResizeRequest resizeRequest, RequestOptions options, ActionListener<ResizeResponse> listener) { public Cancellable cloneAsync(ResizeRequest resizeRequest, RequestOptions options, ActionListener<ResizeResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(resizeRequest, IndicesRequestConverters::clone, options, return restHighLevelClient.performRequestAsyncAndParseEntity(resizeRequest, IndicesRequestConverters::clone, options,
ResizeResponse::fromXContent, listener, emptySet()); ResizeResponse::fromXContent, listener, emptySet());
} }
@ -957,9 +997,10 @@ public final class IndicesClient {
* @param rolloverRequest the request * @param rolloverRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void rolloverAsync(RolloverRequest rolloverRequest, RequestOptions options, ActionListener<RolloverResponse> listener) { public Cancellable rolloverAsync(RolloverRequest rolloverRequest, RequestOptions options, ActionListener<RolloverResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(rolloverRequest, IndicesRequestConverters::rollover, options, return restHighLevelClient.performRequestAsyncAndParseEntity(rolloverRequest, IndicesRequestConverters::rollover, options,
RolloverResponse::fromXContent, listener, emptySet()); RolloverResponse::fromXContent, listener, emptySet());
} }
@ -995,11 +1036,13 @@ public final class IndicesClient {
* @deprecated This method uses deprecated request and response objects. * @deprecated This method uses deprecated request and response objects.
* The method {@link #rolloverAsync(RolloverRequest, RequestOptions, ActionListener)} should be used instead, which * The method {@link #rolloverAsync(RolloverRequest, RequestOptions, ActionListener)} should be used instead, which
* accepts a new request object. * accepts a new request object.
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public void rolloverAsync(org.elasticsearch.action.admin.indices.rollover.RolloverRequest rolloverRequest, public Cancellable rolloverAsync(org.elasticsearch.action.admin.indices.rollover.RolloverRequest rolloverRequest,
RequestOptions options, ActionListener<org.elasticsearch.action.admin.indices.rollover.RolloverResponse> listener) { RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(rolloverRequest, IndicesRequestConverters::rollover, options, ActionListener<org.elasticsearch.action.admin.indices.rollover.RolloverResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(rolloverRequest, IndicesRequestConverters::rollover, options,
org.elasticsearch.action.admin.indices.rollover.RolloverResponse::fromXContent, listener, emptySet()); org.elasticsearch.action.admin.indices.rollover.RolloverResponse::fromXContent, listener, emptySet());
} }
@ -1024,10 +1067,13 @@ public final class IndicesClient {
* @param getAliasesRequest the request * @param getAliasesRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getAliasAsync(GetAliasesRequest getAliasesRequest, RequestOptions options, ActionListener<GetAliasesResponse> listener) { public Cancellable getAliasAsync(GetAliasesRequest getAliasesRequest, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(getAliasesRequest, IndicesRequestConverters::getAlias, options, ActionListener<GetAliasesResponse> listener) {
GetAliasesResponse::fromXContent, listener, singleton(RestStatus.NOT_FOUND.getStatus())); return restHighLevelClient.performRequestAsyncAndParseEntity(getAliasesRequest,
IndicesRequestConverters::getAlias, options,
GetAliasesResponse::fromXContent, listener, singleton(RestStatus.NOT_FOUND.getStatus()));
} }
/** /**
@ -1051,10 +1097,12 @@ public final class IndicesClient {
* @param updateSettingsRequest the request * @param updateSettingsRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putSettingsAsync(UpdateSettingsRequest updateSettingsRequest, RequestOptions options, public Cancellable putSettingsAsync(UpdateSettingsRequest updateSettingsRequest, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(updateSettingsRequest, IndicesRequestConverters::indexPutSettings, options, return restHighLevelClient.performRequestAsyncAndParseEntity(updateSettingsRequest,
IndicesRequestConverters::indexPutSettings, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -1088,11 +1136,14 @@ public final class IndicesClient {
* @deprecated This old form of request allows types in mappings. * @deprecated This old form of request allows types in mappings.
* Use {@link #putTemplateAsync(PutIndexTemplateRequest, RequestOptions, ActionListener)} * Use {@link #putTemplateAsync(PutIndexTemplateRequest, RequestOptions, ActionListener)}
* instead which introduces a new request object without types. * instead which introduces a new request object without types.
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public void putTemplateAsync(org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateRequest putIndexTemplateRequest, public Cancellable putTemplateAsync(
RequestOptions options, ActionListener<AcknowledgedResponse> listener) { org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateRequest putIndexTemplateRequest,
restHighLevelClient.performRequestAsyncAndParseEntity(putIndexTemplateRequest, IndicesRequestConverters::putTemplate, options, RequestOptions options, ActionListener<AcknowledgedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(putIndexTemplateRequest,
IndicesRequestConverters::putTemplate, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -1120,10 +1171,12 @@ public final class IndicesClient {
* @param putIndexTemplateRequest the request * @param putIndexTemplateRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putTemplateAsync(PutIndexTemplateRequest putIndexTemplateRequest, public Cancellable putTemplateAsync(PutIndexTemplateRequest putIndexTemplateRequest,
RequestOptions options, ActionListener<AcknowledgedResponse> listener) { RequestOptions options, ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(putIndexTemplateRequest, IndicesRequestConverters::putTemplate, options, return restHighLevelClient.performRequestAsyncAndParseEntity(putIndexTemplateRequest,
IndicesRequestConverters::putTemplate, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -1137,8 +1190,10 @@ public final class IndicesClient {
* @return the response * @return the response
* @throws IOException in case there is a problem sending the request or parsing back the response * @throws IOException in case there is a problem sending the request or parsing back the response
*/ */
public ValidateQueryResponse validateQuery(ValidateQueryRequest validateQueryRequest, RequestOptions options) throws IOException { public ValidateQueryResponse validateQuery(ValidateQueryRequest validateQueryRequest,
return restHighLevelClient.performRequestAndParseEntity(validateQueryRequest, IndicesRequestConverters::validateQuery, options, RequestOptions options) throws IOException {
return restHighLevelClient.performRequestAndParseEntity(validateQueryRequest,
IndicesRequestConverters::validateQuery, options,
ValidateQueryResponse::fromXContent, emptySet()); ValidateQueryResponse::fromXContent, emptySet());
} }
@ -1150,10 +1205,12 @@ public final class IndicesClient {
* @param validateQueryRequest the request * @param validateQueryRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void validateQueryAsync(ValidateQueryRequest validateQueryRequest, RequestOptions options, public Cancellable validateQueryAsync(ValidateQueryRequest validateQueryRequest, RequestOptions options,
ActionListener<ValidateQueryResponse> listener) { ActionListener<ValidateQueryResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(validateQueryRequest, IndicesRequestConverters::validateQuery, options, return restHighLevelClient.performRequestAsyncAndParseEntity(validateQueryRequest,
IndicesRequestConverters::validateQuery, options,
ValidateQueryResponse::fromXContent, listener, emptySet()); ValidateQueryResponse::fromXContent, listener, emptySet());
} }
@ -1174,7 +1231,8 @@ public final class IndicesClient {
GetIndexTemplatesRequest getIndexTemplatesRequest, RequestOptions options) throws IOException { GetIndexTemplatesRequest getIndexTemplatesRequest, RequestOptions options) throws IOException {
return restHighLevelClient.performRequestAndParseEntity(getIndexTemplatesRequest, return restHighLevelClient.performRequestAndParseEntity(getIndexTemplatesRequest,
IndicesRequestConverters::getTemplatesWithDocumentTypes, IndicesRequestConverters::getTemplatesWithDocumentTypes,
options, org.elasticsearch.action.admin.indices.template.get.GetIndexTemplatesResponse::fromXContent, emptySet()); options,
org.elasticsearch.action.admin.indices.template.get.GetIndexTemplatesResponse::fromXContent, emptySet());
} }
/** /**
@ -1186,8 +1244,8 @@ public final class IndicesClient {
* @return the response * @return the response
* @throws IOException in case there is a problem sending the request or parsing back the response * @throws IOException in case there is a problem sending the request or parsing back the response
*/ */
public GetIndexTemplatesResponse getIndexTemplate(GetIndexTemplatesRequest getIndexTemplatesRequest, RequestOptions options) public GetIndexTemplatesResponse getIndexTemplate(GetIndexTemplatesRequest getIndexTemplatesRequest,
throws IOException { RequestOptions options) throws IOException {
return restHighLevelClient.performRequestAndParseEntity(getIndexTemplatesRequest, return restHighLevelClient.performRequestAndParseEntity(getIndexTemplatesRequest,
IndicesRequestConverters::getTemplates, IndicesRequestConverters::getTemplates,
options, GetIndexTemplatesResponse::fromXContent, emptySet()); options, GetIndexTemplatesResponse::fromXContent, emptySet());
@ -1203,13 +1261,16 @@ public final class IndicesClient {
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @deprecated This method uses an old response object which still refers to types, a deprecated feature. Use * @deprecated This method uses an old response object which still refers to types, a deprecated feature. Use
* {@link #getIndexTemplateAsync(GetIndexTemplatesRequest, RequestOptions, ActionListener)} instead which returns a new response object * {@link #getIndexTemplateAsync(GetIndexTemplatesRequest, RequestOptions, ActionListener)} instead which returns a new response object
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public void getTemplateAsync(GetIndexTemplatesRequest getIndexTemplatesRequest, RequestOptions options, public Cancellable getTemplateAsync(GetIndexTemplatesRequest getIndexTemplatesRequest, RequestOptions options,
ActionListener<org.elasticsearch.action.admin.indices.template.get.GetIndexTemplatesResponse> listener) { ActionListener<org.elasticsearch.action.admin.indices.template.get.GetIndexTemplatesResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(getIndexTemplatesRequest, return restHighLevelClient.performRequestAsyncAndParseEntity(getIndexTemplatesRequest,
IndicesRequestConverters::getTemplatesWithDocumentTypes, IndicesRequestConverters::getTemplatesWithDocumentTypes,
options, org.elasticsearch.action.admin.indices.template.get.GetIndexTemplatesResponse::fromXContent, listener, emptySet()); options,
org.elasticsearch.action.admin.indices.template.get.GetIndexTemplatesResponse::fromXContent,
listener, emptySet());
} }
/** /**
@ -1219,10 +1280,11 @@ public final class IndicesClient {
* @param getIndexTemplatesRequest the request * @param getIndexTemplatesRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getIndexTemplateAsync(GetIndexTemplatesRequest getIndexTemplatesRequest, RequestOptions options, public Cancellable getIndexTemplateAsync(GetIndexTemplatesRequest getIndexTemplatesRequest, RequestOptions options,
ActionListener<GetIndexTemplatesResponse> listener) { ActionListener<GetIndexTemplatesResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(getIndexTemplatesRequest, return restHighLevelClient.performRequestAsyncAndParseEntity(getIndexTemplatesRequest,
IndicesRequestConverters::getTemplates, IndicesRequestConverters::getTemplates,
options, GetIndexTemplatesResponse::fromXContent, listener, emptySet()); options, GetIndexTemplatesResponse::fromXContent, listener, emptySet());
} }
@ -1235,24 +1297,26 @@ public final class IndicesClient {
* @return true if any index templates in the request exist, false otherwise * @return true if any index templates in the request exist, false otherwise
* @throws IOException in case there is a problem sending the request or parsing back the response * @throws IOException in case there is a problem sending the request or parsing back the response
*/ */
public boolean existsTemplate(IndexTemplatesExistRequest indexTemplatesRequest, RequestOptions options) throws IOException { public boolean existsTemplate(IndexTemplatesExistRequest indexTemplatesRequest,
return restHighLevelClient.performRequest(indexTemplatesRequest, IndicesRequestConverters::templatesExist, options, RequestOptions options) throws IOException {
return restHighLevelClient.performRequest(indexTemplatesRequest,
IndicesRequestConverters::templatesExist, options,
RestHighLevelClient::convertExistsResponse, emptySet()); RestHighLevelClient::convertExistsResponse, emptySet());
} }
/** /**
* Uses the Index Templates API to determine if index templates exist * Uses the Index Templates API to determine if index templates exist
*
* @param indexTemplatesExistRequest the request * @param indexTemplatesExistRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion. The listener will be called with the value {@code true} * @param listener the listener to be notified upon request completion. The listener will be called with the value {@code true}
* if any index templates in the request exist, false otherwise * @return cancellable that may be used to cancel the request
*/ */
public void existsTemplateAsync(IndexTemplatesExistRequest indexTemplatesExistRequest, public Cancellable existsTemplateAsync(IndexTemplatesExistRequest indexTemplatesExistRequest,
RequestOptions options, RequestOptions options,
ActionListener<Boolean> listener) { ActionListener<Boolean> listener) {
restHighLevelClient.performRequestAsync(indexTemplatesExistRequest, IndicesRequestConverters::templatesExist, options, return restHighLevelClient.performRequestAsync(indexTemplatesExistRequest,
IndicesRequestConverters::templatesExist, options,
RestHighLevelClient::convertExistsResponse, listener, emptySet()); RestHighLevelClient::convertExistsResponse, listener, emptySet());
} }
@ -1273,14 +1337,14 @@ public final class IndicesClient {
* Asynchronously calls the analyze API * Asynchronously calls the analyze API
* *
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-analyze.html">Analyze API on elastic.co</a> * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-analyze.html">Analyze API on elastic.co</a>
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void analyzeAsync(AnalyzeRequest request, RequestOptions options, public Cancellable analyzeAsync(AnalyzeRequest request, RequestOptions options,
ActionListener<AnalyzeResponse> listener) { ActionListener<AnalyzeResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndicesRequestConverters::analyze, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, IndicesRequestConverters::analyze, options,
AnalyzeResponse::fromXContent, listener, emptySet()); AnalyzeResponse::fromXContent, listener, emptySet());
} }
@ -1297,13 +1361,14 @@ public final class IndicesClient {
/** /**
* Asynchronously calls the _freeze API * Asynchronously calls the _freeze API
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void freezeAsync(FreezeIndexRequest request, RequestOptions options, ActionListener<ShardsAcknowledgedResponse> listener) { public Cancellable freezeAsync(FreezeIndexRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndicesRequestConverters::freezeIndex, options, ActionListener<ShardsAcknowledgedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request, IndicesRequestConverters::freezeIndex, options,
ShardsAcknowledgedResponse::fromXContent, listener, emptySet()); ShardsAcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -1320,13 +1385,15 @@ public final class IndicesClient {
/** /**
* Asynchronously calls the _unfreeze API * Asynchronously calls the _unfreeze API
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void unfreezeAsync(UnfreezeIndexRequest request, RequestOptions options, ActionListener<ShardsAcknowledgedResponse> listener) { public Cancellable unfreezeAsync(UnfreezeIndexRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndicesRequestConverters::unfreezeIndex, options, ActionListener<ShardsAcknowledgedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request,
IndicesRequestConverters::unfreezeIndex, options,
ShardsAcknowledgedResponse::fromXContent, listener, emptySet()); ShardsAcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -1348,14 +1415,14 @@ public final class IndicesClient {
* Asynchronously delete an index template using the Index Templates API * Asynchronously delete an index template using the Index Templates API
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-templates.html"> Index Templates API * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-templates.html"> Index Templates API
* on elastic.co</a> * on elastic.co</a>
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteTemplateAsync(DeleteIndexTemplateRequest request, RequestOptions options, public Cancellable deleteTemplateAsync(DeleteIndexTemplateRequest request, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndicesRequestConverters::deleteTemplate, return restHighLevelClient.performRequestAsyncAndParseEntity(request, IndicesRequestConverters::deleteTemplate,
options, AcknowledgedResponse::fromXContent, listener, emptySet()); options, AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -1372,14 +1439,14 @@ public final class IndicesClient {
/** /**
* Asynchronously calls the _reload_search_analyzers API * Asynchronously calls the _reload_search_analyzers API
*
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void reloadAnalyzersAsync(ReloadAnalyzersRequest request, RequestOptions options, public Cancellable reloadAnalyzersAsync(ReloadAnalyzersRequest request, RequestOptions options,
ActionListener<ReloadAnalyzersResponse> listener) { ActionListener<ReloadAnalyzersResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndicesRequestConverters::reloadAnalyzers, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, IndicesRequestConverters::reloadAnalyzers, options,
ReloadAnalyzersResponse::fromXContent, listener, emptySet()); ReloadAnalyzersResponse::fromXContent, listener, emptySet());
} }
} }

26
client/rest-high-level/src/main/java/org/elasticsearch/client/IngestClient.java
View File

@ -67,9 +67,10 @@ public final class IngestClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putPipelineAsync(PutPipelineRequest request, RequestOptions options, ActionListener<AcknowledgedResponse> listener) { public Cancellable putPipelineAsync(PutPipelineRequest request, RequestOptions options, ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( request, IngestRequestConverters::putPipeline, options, return restHighLevelClient.performRequestAsyncAndParseEntity( request, IngestRequestConverters::putPipeline, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -94,9 +95,10 @@ public final class IngestClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getPipelineAsync(GetPipelineRequest request, RequestOptions options, ActionListener<GetPipelineResponse> listener) { public Cancellable getPipelineAsync(GetPipelineRequest request, RequestOptions options, ActionListener<GetPipelineResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( request, IngestRequestConverters::getPipeline, options, return restHighLevelClient.performRequestAsyncAndParseEntity( request, IngestRequestConverters::getPipeline, options,
GetPipelineResponse::fromXContent, listener, Collections.singleton(404)); GetPipelineResponse::fromXContent, listener, Collections.singleton(404));
} }
@ -123,9 +125,12 @@ public final class IngestClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deletePipelineAsync(DeletePipelineRequest request, RequestOptions options, ActionListener<AcknowledgedResponse> listener) { public Cancellable deletePipelineAsync(DeletePipelineRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity( request, IngestRequestConverters::deletePipeline, options, ActionListener<AcknowledgedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity( request,
IngestRequestConverters::deletePipeline, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -154,11 +159,12 @@ public final class IngestClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void simulateAsync(SimulatePipelineRequest request, public Cancellable simulateAsync(SimulatePipelineRequest request,
RequestOptions options, RequestOptions options,
ActionListener<SimulatePipelineResponse> listener) { ActionListener<SimulatePipelineResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( request, IngestRequestConverters::simulatePipeline, options, return restHighLevelClient.performRequestAsyncAndParseEntity( request, IngestRequestConverters::simulatePipeline, options,
SimulatePipelineResponse::fromXContent, listener, emptySet()); SimulatePipelineResponse::fromXContent, listener, emptySet());
} }
} }

33
client/rest-high-level/src/main/java/org/elasticsearch/client/LicenseClient.java
View File

@ -80,9 +80,10 @@ public final class LicenseClient {
* Asynchronously updates license for the cluster. * Asynchronously updates license for the cluster.
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putLicenseAsync(PutLicenseRequest request, RequestOptions options, ActionListener<PutLicenseResponse> listener) { public Cancellable putLicenseAsync(PutLicenseRequest request, RequestOptions options, ActionListener<PutLicenseResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, LicenseRequestConverters::putLicense, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, LicenseRequestConverters::putLicense, options,
PutLicenseResponse::fromXContent, listener, emptySet()); PutLicenseResponse::fromXContent, listener, emptySet());
} }
@ -101,9 +102,10 @@ public final class LicenseClient {
* Asynchronously returns the current license for the cluster cluster. * Asynchronously returns the current license for the cluster cluster.
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getLicenseAsync(GetLicenseRequest request, RequestOptions options, ActionListener<GetLicenseResponse> listener) { public Cancellable getLicenseAsync(GetLicenseRequest request, RequestOptions options, ActionListener<GetLicenseResponse> listener) {
restHighLevelClient.performRequestAsync(request, LicenseRequestConverters::getLicense, options, return restHighLevelClient.performRequestAsync(request, LicenseRequestConverters::getLicense, options,
response -> new GetLicenseResponse(convertResponseToJson(response)), listener, emptySet()); response -> new GetLicenseResponse(convertResponseToJson(response)), listener, emptySet());
} }
@ -122,9 +124,12 @@ public final class LicenseClient {
* Asynchronously deletes license from the cluster. * Asynchronously deletes license from the cluster.
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteLicenseAsync(DeleteLicenseRequest request, RequestOptions options, ActionListener<AcknowledgedResponse> listener) { public Cancellable deleteLicenseAsync(DeleteLicenseRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, LicenseRequestConverters::deleteLicense, options, ActionListener<AcknowledgedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request,
LicenseRequestConverters::deleteLicense, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -143,12 +148,13 @@ public final class LicenseClient {
* Asynchronously starts a trial license on the cluster. * Asynchronously starts a trial license on the cluster.
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void startTrialAsync(StartTrialRequest request, public Cancellable startTrialAsync(StartTrialRequest request,
RequestOptions options, RequestOptions options,
ActionListener<StartTrialResponse> listener) { ActionListener<StartTrialResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, LicenseRequestConverters::startTrial, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, LicenseRequestConverters::startTrial, options,
StartTrialResponse::fromXContent, listener, singleton(403)); StartTrialResponse::fromXContent, listener, singleton(403));
} }
@ -167,10 +173,11 @@ public final class LicenseClient {
* Asynchronously initiates an indefinite basic license. * Asynchronously initiates an indefinite basic license.
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void startBasicAsync(StartBasicRequest request, RequestOptions options, public Cancellable startBasicAsync(StartBasicRequest request, RequestOptions options,
ActionListener<StartBasicResponse> listener) { ActionListener<StartBasicResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, LicenseRequestConverters::startBasic, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, LicenseRequestConverters::startBasic, options,
StartBasicResponse::fromXContent, listener, emptySet()); StartBasicResponse::fromXContent, listener, emptySet());
} }

334
client/rest-high-level/src/main/java/org/elasticsearch/client/MachineLearningClient.java
View File

@ -153,13 +153,13 @@ public final class MachineLearningClient {
* <p> * <p>
* For additional info * For additional info
* see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ml-put-job.html">ML PUT job documentation</a> * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ml-put-job.html">ML PUT job documentation</a>
*
* @param request The request containing the {@link org.elasticsearch.client.ml.job.config.Job} settings * @param request The request containing the {@link org.elasticsearch.client.ml.job.config.Job} settings
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putJobAsync(PutJobRequest request, RequestOptions options, ActionListener<PutJobResponse> listener) { public Cancellable putJobAsync(PutJobRequest request, RequestOptions options, ActionListener<PutJobResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::putJob, MLRequestConverters::putJob,
options, options,
PutJobResponse::fromXContent, PutJobResponse::fromXContent,
@ -192,13 +192,13 @@ public final class MachineLearningClient {
* <p> * <p>
* For additional info * For additional info
* see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ml-get-job.html">ML GET job documentation</a> * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ml-get-job.html">ML GET job documentation</a>
*
* @param request {@link GetJobRequest} Request containing a list of jobId(s) and additional options * @param request {@link GetJobRequest} Request containing a list of jobId(s) and additional options
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified with {@link GetJobResponse} upon request completion * @param listener Listener to be notified with {@link GetJobResponse} upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getJobAsync(GetJobRequest request, RequestOptions options, ActionListener<GetJobResponse> listener) { public Cancellable getJobAsync(GetJobRequest request, RequestOptions options, ActionListener<GetJobResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::getJob, MLRequestConverters::getJob,
options, options,
GetJobResponse::fromXContent, GetJobResponse::fromXContent,
@ -231,13 +231,13 @@ public final class MachineLearningClient {
* <p> * <p>
* For additional info * For additional info
* see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ml-get-job-stats.html">Get job stats docs</a> * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ml-get-job-stats.html">Get job stats docs</a>
*
* @param request {@link GetJobStatsRequest} Request containing a list of jobId(s) and additional options * @param request {@link GetJobStatsRequest} Request containing a list of jobId(s) and additional options
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified with {@link GetJobStatsResponse} upon request completion * @param listener Listener to be notified with {@link GetJobStatsResponse} upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getJobStatsAsync(GetJobStatsRequest request, RequestOptions options, ActionListener<GetJobStatsResponse> listener) { public Cancellable getJobStatsAsync(GetJobStatsRequest request, RequestOptions options, ActionListener<GetJobStatsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::getJobStats, MLRequestConverters::getJobStats,
options, options,
GetJobStatsResponse::fromXContent, GetJobStatsResponse::fromXContent,
@ -272,14 +272,14 @@ public final class MachineLearningClient {
* For additional info * For additional info
* see <a href="http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-delete-expired-data.html">ML Delete Expired Data * see <a href="http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-delete-expired-data.html">ML Delete Expired Data
* documentation</a> * documentation</a>
*
* @param request The request to delete expired ML data * @param request The request to delete expired ML data
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteExpiredDataAsync(DeleteExpiredDataRequest request, RequestOptions options, public Cancellable deleteExpiredDataAsync(DeleteExpiredDataRequest request, RequestOptions options,
ActionListener<DeleteExpiredDataResponse> listener) { ActionListener<DeleteExpiredDataResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::deleteExpiredData, MLRequestConverters::deleteExpiredData,
options, options,
DeleteExpiredDataResponse::fromXContent, DeleteExpiredDataResponse::fromXContent,
@ -313,12 +313,13 @@ public final class MachineLearningClient {
* For additional info * For additional info
* see <a href="http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-delete-job.html">ML Delete Job documentation</a> * see <a href="http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-delete-job.html">ML Delete Job documentation</a>
* *
* @param request The request to delete the job * @param request The request to delete the job
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteJobAsync(DeleteJobRequest request, RequestOptions options, ActionListener<DeleteJobResponse> listener) { public Cancellable deleteJobAsync(DeleteJobRequest request, RequestOptions options, ActionListener<DeleteJobResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::deleteJob, MLRequestConverters::deleteJob,
options, options,
DeleteJobResponse::fromXContent, DeleteJobResponse::fromXContent,
@ -360,9 +361,10 @@ public final class MachineLearningClient {
* @param request Request containing job_id and additional optional options * @param request Request containing job_id and additional optional options
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void openJobAsync(OpenJobRequest request, RequestOptions options, ActionListener<OpenJobResponse> listener) { public Cancellable openJobAsync(OpenJobRequest request, RequestOptions options, ActionListener<OpenJobResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::openJob, MLRequestConverters::openJob,
options, options,
OpenJobResponse::fromXContent, OpenJobResponse::fromXContent,
@ -400,9 +402,10 @@ public final class MachineLearningClient {
* @param request Request containing job_ids and additional options. See {@link CloseJobRequest} * @param request Request containing job_ids and additional options. See {@link CloseJobRequest}
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void closeJobAsync(CloseJobRequest request, RequestOptions options, ActionListener<CloseJobResponse> listener) { public Cancellable closeJobAsync(CloseJobRequest request, RequestOptions options, ActionListener<CloseJobResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::closeJob, MLRequestConverters::closeJob,
options, options,
CloseJobResponse::fromXContent, CloseJobResponse::fromXContent,
@ -449,9 +452,10 @@ public final class MachineLearningClient {
* @param request The {@link FlushJobRequest} object enclosing the `jobId` and additional request options * @param request The {@link FlushJobRequest} object enclosing the `jobId` and additional request options
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void flushJobAsync(FlushJobRequest request, RequestOptions options, ActionListener<FlushJobResponse> listener) { public Cancellable flushJobAsync(FlushJobRequest request, RequestOptions options, ActionListener<FlushJobResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::flushJob, MLRequestConverters::flushJob,
options, options,
FlushJobResponse::fromXContent, FlushJobResponse::fromXContent,
@ -489,9 +493,10 @@ public final class MachineLearningClient {
* @param request ForecastJobRequest with forecasting options * @param request ForecastJobRequest with forecasting options
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void forecastJobAsync(ForecastJobRequest request, RequestOptions options, ActionListener<ForecastJobResponse> listener) { public Cancellable forecastJobAsync(ForecastJobRequest request, RequestOptions options, ActionListener<ForecastJobResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::forecastJob, MLRequestConverters::forecastJob,
options, options,
ForecastJobResponse::fromXContent, ForecastJobResponse::fromXContent,
@ -529,9 +534,11 @@ public final class MachineLearningClient {
* @param request the {@link DeleteForecastRequest} object enclosing the desired jobId, forecastIDs, and other options * @param request the {@link DeleteForecastRequest} object enclosing the desired jobId, forecastIDs, and other options
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteForecastAsync(DeleteForecastRequest request, RequestOptions options, ActionListener<AcknowledgedResponse> listener) { public Cancellable deleteForecastAsync(DeleteForecastRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, ActionListener<AcknowledgedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::deleteForecast, MLRequestConverters::deleteForecast,
options, options,
AcknowledgedResponse::fromXContent, AcknowledgedResponse::fromXContent,
@ -569,10 +576,11 @@ public final class MachineLearningClient {
* @param request The request to delete the model snapshot * @param request The request to delete the model snapshot
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteModelSnapshotAsync(DeleteModelSnapshotRequest request, RequestOptions options, public Cancellable deleteModelSnapshotAsync(DeleteModelSnapshotRequest request, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::deleteModelSnapshot, MLRequestConverters::deleteModelSnapshot,
options, options,
AcknowledgedResponse::fromXContent, AcknowledgedResponse::fromXContent,
@ -610,10 +618,11 @@ public final class MachineLearningClient {
* @param request The request to revert to a previous model snapshot * @param request The request to revert to a previous model snapshot
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void revertModelSnapshotAsync(RevertModelSnapshotRequest request, RequestOptions options, public Cancellable revertModelSnapshotAsync(RevertModelSnapshotRequest request, RequestOptions options,
ActionListener<RevertModelSnapshotResponse> listener) { ActionListener<RevertModelSnapshotResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::revertModelSnapshot, MLRequestConverters::revertModelSnapshot,
options, options,
RevertModelSnapshotResponse::fromXContent, RevertModelSnapshotResponse::fromXContent,
@ -649,9 +658,10 @@ public final class MachineLearningClient {
* @param request The request containing the {@link org.elasticsearch.client.ml.datafeed.DatafeedConfig} settings * @param request The request containing the {@link org.elasticsearch.client.ml.datafeed.DatafeedConfig} settings
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putDatafeedAsync(PutDatafeedRequest request, RequestOptions options, ActionListener<PutDatafeedResponse> listener) { public Cancellable putDatafeedAsync(PutDatafeedRequest request, RequestOptions options, ActionListener<PutDatafeedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::putDatafeed, MLRequestConverters::putDatafeed,
options, options,
PutDatafeedResponse::fromXContent, PutDatafeedResponse::fromXContent,
@ -689,9 +699,11 @@ public final class MachineLearningClient {
* @param request The request containing the {@link org.elasticsearch.client.ml.datafeed.DatafeedUpdate} settings * @param request The request containing the {@link org.elasticsearch.client.ml.datafeed.DatafeedUpdate} settings
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void updateDatafeedAsync(UpdateDatafeedRequest request, RequestOptions options, ActionListener<PutDatafeedResponse> listener) { public Cancellable updateDatafeedAsync(UpdateDatafeedRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, ActionListener<PutDatafeedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::updateDatafeed, MLRequestConverters::updateDatafeed,
options, options,
PutDatafeedResponse::fromXContent, PutDatafeedResponse::fromXContent,
@ -730,9 +742,11 @@ public final class MachineLearningClient {
* @param request {@link GetDatafeedRequest} Request containing a list of datafeedId(s) and additional options * @param request {@link GetDatafeedRequest} Request containing a list of datafeedId(s) and additional options
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified with {@link GetDatafeedResponse} upon request completion * @param listener Listener to be notified with {@link GetDatafeedResponse} upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getDatafeedAsync(GetDatafeedRequest request, RequestOptions options, ActionListener<GetDatafeedResponse> listener) { public Cancellable getDatafeedAsync(GetDatafeedRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, ActionListener<GetDatafeedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::getDatafeed, MLRequestConverters::getDatafeed,
options, options,
GetDatafeedResponse::fromXContent, GetDatafeedResponse::fromXContent,
@ -770,9 +784,11 @@ public final class MachineLearningClient {
* @param request The request to delete the datafeed * @param request The request to delete the datafeed
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteDatafeedAsync(DeleteDatafeedRequest request, RequestOptions options, ActionListener<AcknowledgedResponse> listener) { public Cancellable deleteDatafeedAsync(DeleteDatafeedRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, ActionListener<AcknowledgedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::deleteDatafeed, MLRequestConverters::deleteDatafeed,
options, options,
AcknowledgedResponse::fromXContent, AcknowledgedResponse::fromXContent,
@ -810,9 +826,11 @@ public final class MachineLearningClient {
* @param request The request to start the datafeed * @param request The request to start the datafeed
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void startDatafeedAsync(StartDatafeedRequest request, RequestOptions options, ActionListener<StartDatafeedResponse> listener) { public Cancellable startDatafeedAsync(StartDatafeedRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, ActionListener<StartDatafeedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::startDatafeed, MLRequestConverters::startDatafeed,
options, options,
StartDatafeedResponse::fromXContent, StartDatafeedResponse::fromXContent,
@ -850,9 +868,11 @@ public final class MachineLearningClient {
* @param request The request to stop the datafeed * @param request The request to stop the datafeed
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void stopDatafeedAsync(StopDatafeedRequest request, RequestOptions options, ActionListener<StopDatafeedResponse> listener) { public Cancellable stopDatafeedAsync(StopDatafeedRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, ActionListener<StopDatafeedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::stopDatafeed, MLRequestConverters::stopDatafeed,
options, options,
StopDatafeedResponse::fromXContent, StopDatafeedResponse::fromXContent,
@ -910,11 +930,12 @@ public final class MachineLearningClient {
* @param request {@link GetDatafeedStatsRequest} Request containing a list of datafeedId(s) and additional options * @param request {@link GetDatafeedStatsRequest} Request containing a list of datafeedId(s) and additional options
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified with {@link GetDatafeedStatsResponse} upon request completion * @param listener Listener to be notified with {@link GetDatafeedStatsResponse} upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getDatafeedStatsAsync(GetDatafeedStatsRequest request, public Cancellable getDatafeedStatsAsync(GetDatafeedStatsRequest request,
RequestOptions options, RequestOptions options,
ActionListener<GetDatafeedStatsResponse> listener) { ActionListener<GetDatafeedStatsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::getDatafeedStats, MLRequestConverters::getDatafeedStats,
options, options,
GetDatafeedStatsResponse::fromXContent, GetDatafeedStatsResponse::fromXContent,
@ -932,11 +953,12 @@ public final class MachineLearningClient {
* @param request The request to preview the datafeed * @param request The request to preview the datafeed
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void previewDatafeedAsync(PreviewDatafeedRequest request, public Cancellable previewDatafeedAsync(PreviewDatafeedRequest request,
RequestOptions options, RequestOptions options,
ActionListener<PreviewDatafeedResponse> listener) { ActionListener<PreviewDatafeedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::previewDatafeed, MLRequestConverters::previewDatafeed,
options, options,
PreviewDatafeedResponse::fromXContent, PreviewDatafeedResponse::fromXContent,
@ -972,9 +994,10 @@ public final class MachineLearningClient {
* @param request the {@link UpdateJobRequest} object enclosing the desired updates * @param request the {@link UpdateJobRequest} object enclosing the desired updates
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void updateJobAsync(UpdateJobRequest request, RequestOptions options, ActionListener<PutJobResponse> listener) { public Cancellable updateJobAsync(UpdateJobRequest request, RequestOptions options, ActionListener<PutJobResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::updateJob, MLRequestConverters::updateJob,
options, options,
PutJobResponse::fromXContent, PutJobResponse::fromXContent,
@ -1005,12 +1028,13 @@ public final class MachineLearningClient {
* For additional info * For additional info
* see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ml-get-bucket.html">ML GET buckets documentation</a> * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/ml-get-bucket.html">ML GET buckets documentation</a>
* *
* @param request The request * @param request The request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getBucketsAsync(GetBucketsRequest request, RequestOptions options, ActionListener<GetBucketsResponse> listener) { public Cancellable getBucketsAsync(GetBucketsRequest request, RequestOptions options, ActionListener<GetBucketsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::getBuckets, MLRequestConverters::getBuckets,
options, options,
GetBucketsResponse::fromXContent, GetBucketsResponse::fromXContent,
@ -1047,9 +1071,11 @@ public final class MachineLearningClient {
* @param request The request * @param request The request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getCategoriesAsync(GetCategoriesRequest request, RequestOptions options, ActionListener<GetCategoriesResponse> listener) { public Cancellable getCategoriesAsync(GetCategoriesRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, ActionListener<GetCategoriesResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::getCategories, MLRequestConverters::getCategories,
options, options,
GetCategoriesResponse::fromXContent, GetCategoriesResponse::fromXContent,
@ -1086,10 +1112,11 @@ public final class MachineLearningClient {
* @param request The request * @param request The request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getModelSnapshotsAsync(GetModelSnapshotsRequest request, RequestOptions options, public Cancellable getModelSnapshotsAsync(GetModelSnapshotsRequest request, RequestOptions options,
ActionListener<GetModelSnapshotsResponse> listener) { ActionListener<GetModelSnapshotsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::getModelSnapshots, MLRequestConverters::getModelSnapshots,
options, options,
GetModelSnapshotsResponse::fromXContent, GetModelSnapshotsResponse::fromXContent,
@ -1127,10 +1154,11 @@ public final class MachineLearningClient {
* @param request The request * @param request The request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void updateModelSnapshotAsync(UpdateModelSnapshotRequest request, RequestOptions options, public Cancellable updateModelSnapshotAsync(UpdateModelSnapshotRequest request, RequestOptions options,
ActionListener<UpdateModelSnapshotResponse> listener) { ActionListener<UpdateModelSnapshotResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::updateModelSnapshot, MLRequestConverters::updateModelSnapshot,
options, options,
UpdateModelSnapshotResponse::fromXContent, UpdateModelSnapshotResponse::fromXContent,
@ -1166,10 +1194,11 @@ public final class MachineLearningClient {
* @param request The request * @param request The request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getOverallBucketsAsync(GetOverallBucketsRequest request, RequestOptions options, public Cancellable getOverallBucketsAsync(GetOverallBucketsRequest request, RequestOptions options,
ActionListener<GetOverallBucketsResponse> listener) { ActionListener<GetOverallBucketsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::getOverallBuckets, MLRequestConverters::getOverallBuckets,
options, options,
GetOverallBucketsResponse::fromXContent, GetOverallBucketsResponse::fromXContent,
@ -1203,9 +1232,10 @@ public final class MachineLearningClient {
* @param request the request * @param request the request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getRecordsAsync(GetRecordsRequest request, RequestOptions options, ActionListener<GetRecordsResponse> listener) { public Cancellable getRecordsAsync(GetRecordsRequest request, RequestOptions options, ActionListener<GetRecordsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::getRecords, MLRequestConverters::getRecords,
options, options,
GetRecordsResponse::fromXContent, GetRecordsResponse::fromXContent,
@ -1245,9 +1275,10 @@ public final class MachineLearningClient {
* @param request PostDataRequest containing the data to post and some additional options * @param request PostDataRequest containing the data to post and some additional options
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void postDataAsync(PostDataRequest request, RequestOptions options, ActionListener<PostDataResponse> listener) { public Cancellable postDataAsync(PostDataRequest request, RequestOptions options, ActionListener<PostDataResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::postData, MLRequestConverters::postData,
options, options,
PostDataResponse::fromXContent, PostDataResponse::fromXContent,
@ -1283,9 +1314,11 @@ public final class MachineLearningClient {
* @param request The calendars request * @param request The calendars request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getCalendarsAsync(GetCalendarsRequest request, RequestOptions options, ActionListener<GetCalendarsResponse> listener) { public Cancellable getCalendarsAsync(GetCalendarsRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, ActionListener<GetCalendarsResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::getCalendars, MLRequestConverters::getCalendars,
options, options,
GetCalendarsResponse::fromXContent, GetCalendarsResponse::fromXContent,
@ -1321,10 +1354,11 @@ public final class MachineLearningClient {
* @param request the request * @param request the request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getInfluencersAsync(GetInfluencersRequest request, RequestOptions options, public Cancellable getInfluencersAsync(GetInfluencersRequest request, RequestOptions options,
ActionListener<GetInfluencersResponse> listener) { ActionListener<GetInfluencersResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::getInfluencers, MLRequestConverters::getInfluencers,
options, options,
GetInfluencersResponse::fromXContent, GetInfluencersResponse::fromXContent,
@ -1362,9 +1396,10 @@ public final class MachineLearningClient {
* @param request The request * @param request The request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putCalendarAsync(PutCalendarRequest request, RequestOptions options, ActionListener<PutCalendarResponse> listener) { public Cancellable putCalendarAsync(PutCalendarRequest request, RequestOptions options, ActionListener<PutCalendarResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::putCalendar, MLRequestConverters::putCalendar,
options, options,
PutCalendarResponse::fromXContent, PutCalendarResponse::fromXContent,
@ -1402,9 +1437,11 @@ public final class MachineLearningClient {
* @param request The request * @param request The request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putCalendarJobAsync(PutCalendarJobRequest request, RequestOptions options, ActionListener<PutCalendarResponse> listener) { public Cancellable putCalendarJobAsync(PutCalendarJobRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, ActionListener<PutCalendarResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::putCalendarJob, MLRequestConverters::putCalendarJob,
options, options,
PutCalendarResponse::fromXContent, PutCalendarResponse::fromXContent,
@ -1442,11 +1479,12 @@ public final class MachineLearningClient {
* @param request The request * @param request The request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteCalendarJobAsync(DeleteCalendarJobRequest request, public Cancellable deleteCalendarJobAsync(DeleteCalendarJobRequest request,
RequestOptions options, RequestOptions options,
ActionListener<PutCalendarResponse> listener) { ActionListener<PutCalendarResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::deleteCalendarJob, MLRequestConverters::deleteCalendarJob,
options, options,
PutCalendarResponse::fromXContent, PutCalendarResponse::fromXContent,
@ -1484,9 +1522,11 @@ public final class MachineLearningClient {
* @param request The request to delete the calendar * @param request The request to delete the calendar
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteCalendarAsync(DeleteCalendarRequest request, RequestOptions options, ActionListener<AcknowledgedResponse> listener) { public Cancellable deleteCalendarAsync(DeleteCalendarRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, ActionListener<AcknowledgedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::deleteCalendar, MLRequestConverters::deleteCalendar,
options, options,
AcknowledgedResponse::fromXContent, AcknowledgedResponse::fromXContent,
@ -1524,10 +1564,11 @@ public final class MachineLearningClient {
* @param request The request * @param request The request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getCalendarEventsAsync(GetCalendarEventsRequest request, RequestOptions options, public Cancellable getCalendarEventsAsync(GetCalendarEventsRequest request, RequestOptions options,
ActionListener<GetCalendarEventsResponse> listener) { ActionListener<GetCalendarEventsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::getCalendarEvents, MLRequestConverters::getCalendarEvents,
options, options,
GetCalendarEventsResponse::fromXContent, GetCalendarEventsResponse::fromXContent,
@ -1565,10 +1606,11 @@ public final class MachineLearningClient {
* @param request The request * @param request The request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void postCalendarEventAsync(PostCalendarEventRequest request, RequestOptions options, public Cancellable postCalendarEventAsync(PostCalendarEventRequest request, RequestOptions options,
ActionListener<PostCalendarEventResponse> listener) { ActionListener<PostCalendarEventResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::postCalendarEvents, MLRequestConverters::postCalendarEvents,
options, options,
PostCalendarEventResponse::fromXContent, PostCalendarEventResponse::fromXContent,
@ -1606,11 +1648,12 @@ public final class MachineLearningClient {
* @param request The request * @param request The request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteCalendarEventAsync(DeleteCalendarEventRequest request, public Cancellable deleteCalendarEventAsync(DeleteCalendarEventRequest request,
RequestOptions options, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::deleteCalendarEvent, MLRequestConverters::deleteCalendarEvent,
options, options,
AcknowledgedResponse::fromXContent, AcknowledgedResponse::fromXContent,
@ -1646,9 +1689,10 @@ public final class MachineLearningClient {
* @param request The request containing the {@link org.elasticsearch.client.ml.job.config.MlFilter} settings * @param request The request containing the {@link org.elasticsearch.client.ml.job.config.MlFilter} settings
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putFilterAsync(PutFilterRequest request, RequestOptions options, ActionListener<PutFilterResponse> listener) { public Cancellable putFilterAsync(PutFilterRequest request, RequestOptions options, ActionListener<PutFilterResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::putFilter, MLRequestConverters::putFilter,
options, options,
PutFilterResponse::fromXContent, PutFilterResponse::fromXContent,
@ -1684,9 +1728,10 @@ public final class MachineLearningClient {
* @param request The request * @param request The request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getFilterAsync(GetFiltersRequest request, RequestOptions options, ActionListener<GetFiltersResponse> listener) { public Cancellable getFilterAsync(GetFiltersRequest request, RequestOptions options, ActionListener<GetFiltersResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::getFilter, MLRequestConverters::getFilter,
options, options,
GetFiltersResponse::fromXContent, GetFiltersResponse::fromXContent,
@ -1724,9 +1769,10 @@ public final class MachineLearningClient {
* @param request The request * @param request The request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void updateFilterAsync(UpdateFilterRequest request, RequestOptions options, ActionListener<PutFilterResponse> listener) { public Cancellable updateFilterAsync(UpdateFilterRequest request, RequestOptions options, ActionListener<PutFilterResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::updateFilter, MLRequestConverters::updateFilter,
options, options,
PutFilterResponse::fromXContent, PutFilterResponse::fromXContent,
@ -1764,9 +1810,11 @@ public final class MachineLearningClient {
* @param request The request to delete the filter * @param request The request to delete the filter
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteFilterAsync(DeleteFilterRequest request, RequestOptions options, ActionListener<AcknowledgedResponse> listener) { public Cancellable deleteFilterAsync(DeleteFilterRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, ActionListener<AcknowledgedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::deleteFilter, MLRequestConverters::deleteFilter,
options, options,
AcknowledgedResponse::fromXContent, AcknowledgedResponse::fromXContent,
@ -1802,9 +1850,10 @@ public final class MachineLearningClient {
* @param request The request of Machine Learning info * @param request The request of Machine Learning info
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getMlInfoAsync(MlInfoRequest request, RequestOptions options, ActionListener<MlInfoResponse> listener) { public Cancellable getMlInfoAsync(MlInfoRequest request, RequestOptions options, ActionListener<MlInfoResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::mlInfo, MLRequestConverters::mlInfo,
options, options,
MlInfoResponse::fromXContent, MlInfoResponse::fromXContent,
@ -1842,10 +1891,11 @@ public final class MachineLearningClient {
* @param request The find file structure request * @param request The find file structure request
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void findFileStructureAsync(FindFileStructureRequest request, RequestOptions options, public Cancellable findFileStructureAsync(FindFileStructureRequest request, RequestOptions options,
ActionListener<FindFileStructureResponse> listener) { ActionListener<FindFileStructureResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::findFileStructure, MLRequestConverters::findFileStructure,
options, options,
FindFileStructureResponse::fromXContent, FindFileStructureResponse::fromXContent,
@ -1881,9 +1931,11 @@ public final class MachineLearningClient {
* @param request The request of Machine Learning info * @param request The request of Machine Learning info
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void setUpgradeModeAsync(SetUpgradeModeRequest request, RequestOptions options, ActionListener<AcknowledgedResponse> listener) { public Cancellable setUpgradeModeAsync(SetUpgradeModeRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, ActionListener<AcknowledgedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::setUpgradeMode, MLRequestConverters::setUpgradeMode,
options, options,
AcknowledgedResponse::fromXContent, AcknowledgedResponse::fromXContent,
@ -1925,10 +1977,11 @@ public final class MachineLearningClient {
* {@link org.elasticsearch.client.ml.dataframe.DataFrameAnalyticsConfig} * {@link org.elasticsearch.client.ml.dataframe.DataFrameAnalyticsConfig}
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putDataFrameAnalyticsAsync(PutDataFrameAnalyticsRequest request, RequestOptions options, public Cancellable putDataFrameAnalyticsAsync(PutDataFrameAnalyticsRequest request, RequestOptions options,
ActionListener<PutDataFrameAnalyticsResponse> listener) { ActionListener<PutDataFrameAnalyticsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::putDataFrameAnalytics, MLRequestConverters::putDataFrameAnalytics,
options, options,
PutDataFrameAnalyticsResponse::fromXContent, PutDataFrameAnalyticsResponse::fromXContent,
@ -1967,10 +2020,11 @@ public final class MachineLearningClient {
* @param request The {@link GetDataFrameAnalyticsRequest} * @param request The {@link GetDataFrameAnalyticsRequest}
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getDataFrameAnalyticsAsync(GetDataFrameAnalyticsRequest request, RequestOptions options, public Cancellable getDataFrameAnalyticsAsync(GetDataFrameAnalyticsRequest request, RequestOptions options,
ActionListener<GetDataFrameAnalyticsResponse> listener) { ActionListener<GetDataFrameAnalyticsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::getDataFrameAnalytics, MLRequestConverters::getDataFrameAnalytics,
options, options,
GetDataFrameAnalyticsResponse::fromXContent, GetDataFrameAnalyticsResponse::fromXContent,
@ -2008,10 +2062,11 @@ public final class MachineLearningClient {
* @param request The {@link GetDataFrameAnalyticsStatsRequest} * @param request The {@link GetDataFrameAnalyticsStatsRequest}
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getDataFrameAnalyticsStatsAsync(GetDataFrameAnalyticsStatsRequest request, RequestOptions options, public Cancellable getDataFrameAnalyticsStatsAsync(GetDataFrameAnalyticsStatsRequest request, RequestOptions options,
ActionListener<GetDataFrameAnalyticsStatsResponse> listener) { ActionListener<GetDataFrameAnalyticsStatsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::getDataFrameAnalyticsStats, MLRequestConverters::getDataFrameAnalyticsStats,
options, options,
GetDataFrameAnalyticsStatsResponse::fromXContent, GetDataFrameAnalyticsStatsResponse::fromXContent,
@ -2047,13 +2102,14 @@ public final class MachineLearningClient {
* see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/start-dfanalytics.html"> * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/start-dfanalytics.html">
* Start Data Frame Analytics documentation</a> * Start Data Frame Analytics documentation</a>
* *
* @param request The {@link StartDataFrameAnalyticsRequest} * @param request The {@link StartDataFrameAnalyticsRequest}
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void startDataFrameAnalyticsAsync(StartDataFrameAnalyticsRequest request, RequestOptions options, public Cancellable startDataFrameAnalyticsAsync(StartDataFrameAnalyticsRequest request, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::startDataFrameAnalytics, MLRequestConverters::startDataFrameAnalytics,
options, options,
AcknowledgedResponse::fromXContent, AcknowledgedResponse::fromXContent,
@ -2092,10 +2148,11 @@ public final class MachineLearningClient {
* @param request The {@link StopDataFrameAnalyticsRequest} * @param request The {@link StopDataFrameAnalyticsRequest}
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void stopDataFrameAnalyticsAsync(StopDataFrameAnalyticsRequest request, RequestOptions options, public Cancellable stopDataFrameAnalyticsAsync(StopDataFrameAnalyticsRequest request, RequestOptions options,
ActionListener<StopDataFrameAnalyticsResponse> listener) { ActionListener<StopDataFrameAnalyticsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::stopDataFrameAnalytics, MLRequestConverters::stopDataFrameAnalytics,
options, options,
StopDataFrameAnalyticsResponse::fromXContent, StopDataFrameAnalyticsResponse::fromXContent,
@ -2134,10 +2191,11 @@ public final class MachineLearningClient {
* @param request The {@link DeleteDataFrameAnalyticsRequest} * @param request The {@link DeleteDataFrameAnalyticsRequest}
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteDataFrameAnalyticsAsync(DeleteDataFrameAnalyticsRequest request, RequestOptions options, public Cancellable deleteDataFrameAnalyticsAsync(DeleteDataFrameAnalyticsRequest request, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::deleteDataFrameAnalytics, MLRequestConverters::deleteDataFrameAnalytics,
options, options,
AcknowledgedResponse::fromXContent, AcknowledgedResponse::fromXContent,
@ -2176,10 +2234,11 @@ public final class MachineLearningClient {
* @param request The {@link EvaluateDataFrameRequest} * @param request The {@link EvaluateDataFrameRequest}
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void evaluateDataFrameAsync(EvaluateDataFrameRequest request, RequestOptions options, public Cancellable evaluateDataFrameAsync(EvaluateDataFrameRequest request, RequestOptions options,
ActionListener<EvaluateDataFrameResponse> listener) { ActionListener<EvaluateDataFrameResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
MLRequestConverters::evaluateDataFrame, MLRequestConverters::evaluateDataFrame,
options, options,
EvaluateDataFrameResponse::fromXContent, EvaluateDataFrameResponse::fromXContent,
@ -2219,10 +2278,11 @@ public final class MachineLearningClient {
* @param request The {@link PutDataFrameAnalyticsRequest} * @param request The {@link PutDataFrameAnalyticsRequest}
* @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener Listener to be notified upon request completion * @param listener Listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void estimateMemoryUsageAsync(PutDataFrameAnalyticsRequest request, RequestOptions options, public Cancellable estimateMemoryUsageAsync(PutDataFrameAnalyticsRequest request, RequestOptions options,
ActionListener<EstimateMemoryUsageResponse> listener) { ActionListener<EstimateMemoryUsageResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( return restHighLevelClient.performRequestAsyncAndParseEntity(
request, request,
MLRequestConverters::estimateMemoryUsage, MLRequestConverters::estimateMemoryUsage,
options, options,

7
client/rest-high-level/src/main/java/org/elasticsearch/client/MigrationClient.java
View File

@ -58,10 +58,11 @@ public final class MigrationClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getDeprecationInfoAsync(DeprecationInfoRequest request, RequestOptions options, public Cancellable getDeprecationInfoAsync(DeprecationInfoRequest request, RequestOptions options,
ActionListener<DeprecationInfoResponse> listener) { ActionListener<DeprecationInfoResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, MigrationRequestConverters::getDeprecationInfo, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, MigrationRequestConverters::getDeprecationInfo, options,
DeprecationInfoResponse::fromXContent, listener, Collections.emptySet()); DeprecationInfoResponse::fromXContent, listener, Collections.emptySet());
} }
} }

306
client/rest-high-level/src/main/java/org/elasticsearch/client/RestHighLevelClient.java
View File

@ -498,9 +498,11 @@ public class RestHighLevelClient implements Closeable {
* @param bulkRequest the request * @param bulkRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void bulkAsync(BulkRequest bulkRequest, RequestOptions options, ActionListener<BulkResponse> listener) { public final Cancellable bulkAsync(BulkRequest bulkRequest, RequestOptions options, ActionListener<BulkResponse> listener) {
performRequestAsyncAndParseEntity(bulkRequest, RequestConverters::bulk, options, BulkResponse::fromXContent, listener, emptySet()); return performRequestAsyncAndParseEntity(bulkRequest, RequestConverters::bulk, options,
BulkResponse::fromXContent, listener, emptySet());
} }
/** /**
@ -535,9 +537,11 @@ public class RestHighLevelClient implements Closeable {
* @param reindexRequest the request * @param reindexRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void reindexAsync(ReindexRequest reindexRequest, RequestOptions options, ActionListener<BulkByScrollResponse> listener) { public final Cancellable reindexAsync(ReindexRequest reindexRequest, RequestOptions options,
performRequestAsyncAndParseEntity( ActionListener<BulkByScrollResponse> listener) {
return performRequestAsyncAndParseEntity(
reindexRequest, RequestConverters::reindex, options, BulkByScrollResponse::fromXContent, listener, singleton(409) reindexRequest, RequestConverters::reindex, options, BulkByScrollResponse::fromXContent, listener, singleton(409)
); );
} }
@ -563,10 +567,11 @@ public class RestHighLevelClient implements Closeable {
* @param updateByQueryRequest the request * @param updateByQueryRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void updateByQueryAsync(UpdateByQueryRequest updateByQueryRequest, RequestOptions options, public final Cancellable updateByQueryAsync(UpdateByQueryRequest updateByQueryRequest, RequestOptions options,
ActionListener<BulkByScrollResponse> listener) { ActionListener<BulkByScrollResponse> listener) {
performRequestAsyncAndParseEntity( return performRequestAsyncAndParseEntity(
updateByQueryRequest, RequestConverters::updateByQuery, options, BulkByScrollResponse::fromXContent, listener, singleton(409) updateByQueryRequest, RequestConverters::updateByQuery, options, BulkByScrollResponse::fromXContent, listener, singleton(409)
); );
} }
@ -592,10 +597,11 @@ public class RestHighLevelClient implements Closeable {
* @param deleteByQueryRequest the request * @param deleteByQueryRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void deleteByQueryAsync(DeleteByQueryRequest deleteByQueryRequest, RequestOptions options, public final Cancellable deleteByQueryAsync(DeleteByQueryRequest deleteByQueryRequest, RequestOptions options,
ActionListener<BulkByScrollResponse> listener) { ActionListener<BulkByScrollResponse> listener) {
performRequestAsyncAndParseEntity( return performRequestAsyncAndParseEntity(
deleteByQueryRequest, RequestConverters::deleteByQuery, options, BulkByScrollResponse::fromXContent, listener, singleton(409) deleteByQueryRequest, RequestConverters::deleteByQuery, options, BulkByScrollResponse::fromXContent, listener, singleton(409)
); );
} }
@ -620,10 +626,11 @@ public class RestHighLevelClient implements Closeable {
* @param rethrottleRequest the request * @param rethrottleRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void deleteByQueryRethrottleAsync(RethrottleRequest rethrottleRequest, RequestOptions options, public final Cancellable deleteByQueryRethrottleAsync(RethrottleRequest rethrottleRequest, RequestOptions options,
ActionListener<ListTasksResponse> listener) { ActionListener<ListTasksResponse> listener) {
performRequestAsyncAndParseEntity(rethrottleRequest, RequestConverters::rethrottleDeleteByQuery, options, return performRequestAsyncAndParseEntity(rethrottleRequest, RequestConverters::rethrottleDeleteByQuery, options,
ListTasksResponse::fromXContent, listener, emptySet()); ListTasksResponse::fromXContent, listener, emptySet());
} }
@ -647,10 +654,11 @@ public class RestHighLevelClient implements Closeable {
* @param rethrottleRequest the request * @param rethrottleRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void updateByQueryRethrottleAsync(RethrottleRequest rethrottleRequest, RequestOptions options, public final Cancellable updateByQueryRethrottleAsync(RethrottleRequest rethrottleRequest, RequestOptions options,
ActionListener<ListTasksResponse> listener) { ActionListener<ListTasksResponse> listener) {
performRequestAsyncAndParseEntity(rethrottleRequest, RequestConverters::rethrottleUpdateByQuery, options, return performRequestAsyncAndParseEntity(rethrottleRequest, RequestConverters::rethrottleUpdateByQuery, options,
ListTasksResponse::fromXContent, listener, emptySet()); ListTasksResponse::fromXContent, listener, emptySet());
} }
@ -672,15 +680,15 @@ public class RestHighLevelClient implements Closeable {
* Executes a reindex rethrottling request. * Executes a reindex rethrottling request.
* See the <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-reindex.html#docs-reindex-rethrottle"> * See the <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-reindex.html#docs-reindex-rethrottle">
* Reindex rethrottling API on elastic.co</a> * Reindex rethrottling API on elastic.co</a>
*
* @param rethrottleRequest the request * @param rethrottleRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void reindexRethrottleAsync(RethrottleRequest rethrottleRequest, RequestOptions options, public final Cancellable reindexRethrottleAsync(RethrottleRequest rethrottleRequest, RequestOptions options,
ActionListener<ListTasksResponse> listener) { ActionListener<ListTasksResponse> listener) {
performRequestAsyncAndParseEntity(rethrottleRequest, RequestConverters::rethrottleReindex, options, ListTasksResponse::fromXContent, return performRequestAsyncAndParseEntity(rethrottleRequest,
listener, emptySet()); RequestConverters::rethrottleReindex, options, ListTasksResponse::fromXContent, listener, emptySet());
} }
/** /**
@ -720,9 +728,10 @@ public class RestHighLevelClient implements Closeable {
* @param getRequest the request * @param getRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void getAsync(GetRequest getRequest, RequestOptions options, ActionListener<GetResponse> listener) { public final Cancellable getAsync(GetRequest getRequest, RequestOptions options, ActionListener<GetResponse> listener) {
performRequestAsyncAndParseEntity(getRequest, RequestConverters::get, options, GetResponse::fromXContent, listener, return performRequestAsyncAndParseEntity(getRequest, RequestConverters::get, options, GetResponse::fromXContent, listener,
singleton(404)); singleton(404));
} }
@ -759,10 +768,12 @@ public class RestHighLevelClient implements Closeable {
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @deprecated use {@link #mgetAsync(MultiGetRequest, RequestOptions, ActionListener)} instead * @deprecated use {@link #mgetAsync(MultiGetRequest, RequestOptions, ActionListener)} instead
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public final void multiGetAsync(MultiGetRequest multiGetRequest, RequestOptions options, ActionListener<MultiGetResponse> listener) { public final Cancellable multiGetAsync(MultiGetRequest multiGetRequest, RequestOptions options,
mgetAsync(multiGetRequest, options, listener); ActionListener<MultiGetResponse> listener) {
return mgetAsync(multiGetRequest, options, listener);
} }
/** /**
@ -771,10 +782,12 @@ public class RestHighLevelClient implements Closeable {
* @param multiGetRequest the request * @param multiGetRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void mgetAsync(MultiGetRequest multiGetRequest, RequestOptions options, ActionListener<MultiGetResponse> listener) { public final Cancellable mgetAsync(MultiGetRequest multiGetRequest, RequestOptions options,
performRequestAsyncAndParseEntity(multiGetRequest, RequestConverters::multiGet, options, MultiGetResponse::fromXContent, listener, ActionListener<MultiGetResponse> listener) {
singleton(404)); return performRequestAsyncAndParseEntity(multiGetRequest, RequestConverters::multiGet, options,
MultiGetResponse::fromXContent, listener, singleton(404));
} }
/** /**
@ -794,9 +807,10 @@ public class RestHighLevelClient implements Closeable {
* @param getRequest the request * @param getRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void existsAsync(GetRequest getRequest, RequestOptions options, ActionListener<Boolean> listener) { public final Cancellable existsAsync(GetRequest getRequest, RequestOptions options, ActionListener<Boolean> listener) {
performRequestAsync(getRequest, RequestConverters::exists, options, RestHighLevelClient::convertExistsResponse, listener, return performRequestAsync(getRequest, RequestConverters::exists, options, RestHighLevelClient::convertExistsResponse, listener,
emptySet()); emptySet());
} }
@ -819,10 +833,11 @@ public class RestHighLevelClient implements Closeable {
* @param getRequest the request * @param getRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void existsSourceAsync(GetRequest getRequest, RequestOptions options, ActionListener<Boolean> listener) { public final Cancellable existsSourceAsync(GetRequest getRequest, RequestOptions options, ActionListener<Boolean> listener) {
performRequestAsync(getRequest, RequestConverters::sourceExists, options, RestHighLevelClient::convertExistsResponse, listener, return performRequestAsync(getRequest, RequestConverters::sourceExists, options,
emptySet()); RestHighLevelClient::convertExistsResponse, listener, emptySet());
} }
/** /**
@ -833,7 +848,8 @@ public class RestHighLevelClient implements Closeable {
* @return the response * @return the response
*/ */
public final IndexResponse index(IndexRequest indexRequest, RequestOptions options) throws IOException { public final IndexResponse index(IndexRequest indexRequest, RequestOptions options) throws IOException {
return performRequestAndParseEntity(indexRequest, RequestConverters::index, options, IndexResponse::fromXContent, emptySet()); return performRequestAndParseEntity(indexRequest, RequestConverters::index, options,
IndexResponse::fromXContent, emptySet());
} }
/** /**
@ -842,9 +858,10 @@ public class RestHighLevelClient implements Closeable {
* @param indexRequest the request * @param indexRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void indexAsync(IndexRequest indexRequest, RequestOptions options, ActionListener<IndexResponse> listener) { public final Cancellable indexAsync(IndexRequest indexRequest, RequestOptions options, ActionListener<IndexResponse> listener) {
performRequestAsyncAndParseEntity(indexRequest, RequestConverters::index, options, IndexResponse::fromXContent, listener, return performRequestAsyncAndParseEntity(indexRequest, RequestConverters::index, options, IndexResponse::fromXContent, listener,
emptySet()); emptySet());
} }
@ -866,9 +883,10 @@ public class RestHighLevelClient implements Closeable {
* @param countRequest the request * @param countRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void countAsync(CountRequest countRequest, RequestOptions options, ActionListener<CountResponse> listener) { public final Cancellable countAsync(CountRequest countRequest, RequestOptions options, ActionListener<CountResponse> listener) {
performRequestAsyncAndParseEntity(countRequest, RequestConverters::count, options,CountResponse::fromXContent, return performRequestAsyncAndParseEntity(countRequest, RequestConverters::count, options,CountResponse::fromXContent,
listener, emptySet()); listener, emptySet());
} }
@ -889,9 +907,10 @@ public class RestHighLevelClient implements Closeable {
* @param updateRequest the request * @param updateRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void updateAsync(UpdateRequest updateRequest, RequestOptions options, ActionListener<UpdateResponse> listener) { public final Cancellable updateAsync(UpdateRequest updateRequest, RequestOptions options, ActionListener<UpdateResponse> listener) {
performRequestAsyncAndParseEntity(updateRequest, RequestConverters::update, options, UpdateResponse::fromXContent, listener, return performRequestAsyncAndParseEntity(updateRequest, RequestConverters::update, options, UpdateResponse::fromXContent, listener,
emptySet()); emptySet());
} }
@ -913,9 +932,10 @@ public class RestHighLevelClient implements Closeable {
* @param deleteRequest the request * @param deleteRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void deleteAsync(DeleteRequest deleteRequest, RequestOptions options, ActionListener<DeleteResponse> listener) { public final Cancellable deleteAsync(DeleteRequest deleteRequest, RequestOptions options, ActionListener<DeleteResponse> listener) {
performRequestAsyncAndParseEntity(deleteRequest, RequestConverters::delete, options, DeleteResponse::fromXContent, listener, return performRequestAsyncAndParseEntity(deleteRequest, RequestConverters::delete, options, DeleteResponse::fromXContent, listener,
Collections.singleton(404)); Collections.singleton(404));
} }
@ -941,9 +961,10 @@ public class RestHighLevelClient implements Closeable {
* @param searchRequest the request * @param searchRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void searchAsync(SearchRequest searchRequest, RequestOptions options, ActionListener<SearchResponse> listener) { public final Cancellable searchAsync(SearchRequest searchRequest, RequestOptions options, ActionListener<SearchResponse> listener) {
performRequestAsyncAndParseEntity( return performRequestAsyncAndParseEntity(
searchRequest, searchRequest,
r -> RequestConverters.search(r, "_search"), r -> RequestConverters.search(r, "_search"),
options, options,
@ -987,11 +1008,12 @@ public class RestHighLevelClient implements Closeable {
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @deprecated use {@link #msearchAsync(MultiSearchRequest, RequestOptions, ActionListener)} instead * @deprecated use {@link #msearchAsync(MultiSearchRequest, RequestOptions, ActionListener)} instead
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public final void multiSearchAsync(MultiSearchRequest searchRequest, RequestOptions options, public final Cancellable multiSearchAsync(MultiSearchRequest searchRequest, RequestOptions options,
ActionListener<MultiSearchResponse> listener) { ActionListener<MultiSearchResponse> listener) {
msearchAsync(searchRequest, options, listener); return msearchAsync(searchRequest, options, listener);
} }
/** /**
@ -1001,10 +1023,11 @@ public class RestHighLevelClient implements Closeable {
* @param searchRequest the request * @param searchRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void msearchAsync(MultiSearchRequest searchRequest, RequestOptions options, public final Cancellable msearchAsync(MultiSearchRequest searchRequest, RequestOptions options,
ActionListener<MultiSearchResponse> listener) { ActionListener<MultiSearchResponse> listener) {
performRequestAsyncAndParseEntity(searchRequest, RequestConverters::multiSearch, options, MultiSearchResponse::fromXContext, return performRequestAsyncAndParseEntity(searchRequest, RequestConverters::multiSearch, options, MultiSearchResponse::fromXContext,
listener, emptySet()); listener, emptySet());
} }
@ -1046,11 +1069,12 @@ public class RestHighLevelClient implements Closeable {
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @deprecated use {@link #scrollAsync(SearchScrollRequest, RequestOptions, ActionListener)} instead * @deprecated use {@link #scrollAsync(SearchScrollRequest, RequestOptions, ActionListener)} instead
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public final void searchScrollAsync(SearchScrollRequest searchScrollRequest, RequestOptions options, public final Cancellable searchScrollAsync(SearchScrollRequest searchScrollRequest, RequestOptions options,
ActionListener<SearchResponse> listener) { ActionListener<SearchResponse> listener) {
scrollAsync(searchScrollRequest, options, listener); return scrollAsync(searchScrollRequest, options, listener);
} }
/** /**
@ -1061,11 +1085,12 @@ public class RestHighLevelClient implements Closeable {
* @param searchScrollRequest the request * @param searchScrollRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void scrollAsync(SearchScrollRequest searchScrollRequest, RequestOptions options, public final Cancellable scrollAsync(SearchScrollRequest searchScrollRequest, RequestOptions options,
ActionListener<SearchResponse> listener) { ActionListener<SearchResponse> listener) {
performRequestAsyncAndParseEntity(searchScrollRequest, RequestConverters::searchScroll, options, SearchResponse::fromXContent, return performRequestAsyncAndParseEntity(searchScrollRequest, RequestConverters::searchScroll,
listener, emptySet()); options, SearchResponse::fromXContent, listener, emptySet());
} }
/** /**
@ -1090,11 +1115,12 @@ public class RestHighLevelClient implements Closeable {
* @param clearScrollRequest the request * @param clearScrollRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void clearScrollAsync(ClearScrollRequest clearScrollRequest, RequestOptions options, public final Cancellable clearScrollAsync(ClearScrollRequest clearScrollRequest, RequestOptions options,
ActionListener<ClearScrollResponse> listener) { ActionListener<ClearScrollResponse> listener) {
performRequestAsyncAndParseEntity(clearScrollRequest, RequestConverters::clearScroll, options, ClearScrollResponse::fromXContent, return performRequestAsyncAndParseEntity(clearScrollRequest, RequestConverters::clearScroll,
listener, emptySet()); options, ClearScrollResponse::fromXContent, listener, emptySet());
} }
/** /**
@ -1116,10 +1142,11 @@ public class RestHighLevelClient implements Closeable {
* *
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/search-template.html">Search Template API * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/search-template.html">Search Template API
* on elastic.co</a>. * on elastic.co</a>.
* @return cancellable that may be used to cancel the request
*/ */
public final void searchTemplateAsync(SearchTemplateRequest searchTemplateRequest, RequestOptions options, public final Cancellable searchTemplateAsync(SearchTemplateRequest searchTemplateRequest, RequestOptions options,
ActionListener<SearchTemplateResponse> listener) { ActionListener<SearchTemplateResponse> listener) {
performRequestAsyncAndParseEntity(searchTemplateRequest, RequestConverters::searchTemplate, options, return performRequestAsyncAndParseEntity(searchTemplateRequest, RequestConverters::searchTemplate, options,
SearchTemplateResponse::fromXContent, listener, emptySet()); SearchTemplateResponse::fromXContent, listener, emptySet());
} }
@ -1147,9 +1174,10 @@ public class RestHighLevelClient implements Closeable {
* @param explainRequest the request * @param explainRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void explainAsync(ExplainRequest explainRequest, RequestOptions options, ActionListener<ExplainResponse> listener) { public final Cancellable explainAsync(ExplainRequest explainRequest, RequestOptions options, ActionListener<ExplainResponse> listener) {
performRequestAsync(explainRequest, RequestConverters::explain, options, return performRequestAsync(explainRequest, RequestConverters::explain, options,
response -> { response -> {
CheckedFunction<XContentParser, ExplainResponse, IOException> entityParser = CheckedFunction<XContentParser, ExplainResponse, IOException> entityParser =
parser -> ExplainResponse.fromXContent(parser, convertExistsResponse(response)); parser -> ExplainResponse.fromXContent(parser, convertExistsResponse(response));
@ -1181,9 +1209,12 @@ public class RestHighLevelClient implements Closeable {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void termvectorsAsync(TermVectorsRequest request, RequestOptions options, ActionListener<TermVectorsResponse> listener) { public final Cancellable termvectorsAsync(TermVectorsRequest request, RequestOptions options,
performRequestAsyncAndParseEntity(request, RequestConverters::termVectors, options, TermVectorsResponse::fromXContent, listener, ActionListener<TermVectorsResponse> listener) {
return performRequestAsyncAndParseEntity(request, RequestConverters::termVectors, options,
TermVectorsResponse::fromXContent, listener,
emptySet()); emptySet());
} }
@ -1211,10 +1242,11 @@ public class RestHighLevelClient implements Closeable {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void mtermvectorsAsync(MultiTermVectorsRequest request, RequestOptions options, public final Cancellable mtermvectorsAsync(MultiTermVectorsRequest request, RequestOptions options,
ActionListener<MultiTermVectorsResponse> listener) { ActionListener<MultiTermVectorsResponse> listener) {
performRequestAsyncAndParseEntity( return performRequestAsyncAndParseEntity(
request, RequestConverters::mtermVectors, options, MultiTermVectorsResponse::fromXContent, listener, emptySet()); request, RequestConverters::mtermVectors, options, MultiTermVectorsResponse::fromXContent, listener, emptySet());
} }
@ -1250,11 +1282,12 @@ public class RestHighLevelClient implements Closeable {
* *
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/multi-search-template.html">Multi Search Template API * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/multi-search-template.html">Multi Search Template API
* on elastic.co</a>. * on elastic.co</a>.
* @return cancellable that may be used to cancel the request
*/ */
public final void msearchTemplateAsync(MultiSearchTemplateRequest multiSearchTemplateRequest, public final Cancellable msearchTemplateAsync(MultiSearchTemplateRequest multiSearchTemplateRequest,
RequestOptions options, RequestOptions options,
ActionListener<MultiSearchTemplateResponse> listener) { ActionListener<MultiSearchTemplateResponse> listener) {
performRequestAsyncAndParseEntity(multiSearchTemplateRequest, RequestConverters::multiSearchTemplate, return performRequestAsyncAndParseEntity(multiSearchTemplateRequest, RequestConverters::multiSearchTemplate,
options, MultiSearchTemplateResponse::fromXContext, listener, emptySet()); options, MultiSearchTemplateResponse::fromXContext, listener, emptySet());
} }
@ -1265,9 +1298,12 @@ public class RestHighLevelClient implements Closeable {
* @param rankEvalRequest the request * @param rankEvalRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void rankEvalAsync(RankEvalRequest rankEvalRequest, RequestOptions options, ActionListener<RankEvalResponse> listener) { public final Cancellable rankEvalAsync(RankEvalRequest rankEvalRequest, RequestOptions options,
performRequestAsyncAndParseEntity(rankEvalRequest, RequestConverters::rankEval, options, RankEvalResponse::fromXContent, listener, ActionListener<RankEvalResponse> listener) {
return performRequestAsyncAndParseEntity(rankEvalRequest, RequestConverters::rankEval, options,
RankEvalResponse::fromXContent, listener,
emptySet()); emptySet());
} }
@ -1305,10 +1341,11 @@ public class RestHighLevelClient implements Closeable {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getScriptAsync(GetStoredScriptRequest request, RequestOptions options, public Cancellable getScriptAsync(GetStoredScriptRequest request, RequestOptions options,
ActionListener<GetStoredScriptResponse> listener) { ActionListener<GetStoredScriptResponse> listener) {
performRequestAsyncAndParseEntity(request, RequestConverters::getScript, options, return performRequestAsyncAndParseEntity(request, RequestConverters::getScript, options,
GetStoredScriptResponse::fromXContent, listener, emptySet()); GetStoredScriptResponse::fromXContent, listener, emptySet());
} }
@ -1332,10 +1369,11 @@ public class RestHighLevelClient implements Closeable {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteScriptAsync(DeleteStoredScriptRequest request, RequestOptions options, public Cancellable deleteScriptAsync(DeleteStoredScriptRequest request, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
performRequestAsyncAndParseEntity(request, RequestConverters::deleteScript, options, return performRequestAsyncAndParseEntity(request, RequestConverters::deleteScript, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -1360,10 +1398,11 @@ public class RestHighLevelClient implements Closeable {
* @param putStoredScriptRequest the request * @param putStoredScriptRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putScriptAsync(PutStoredScriptRequest putStoredScriptRequest, RequestOptions options, public Cancellable putScriptAsync(PutStoredScriptRequest putStoredScriptRequest, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
performRequestAsyncAndParseEntity(putStoredScriptRequest, RequestConverters::putScript, options, return performRequestAsyncAndParseEntity(putStoredScriptRequest, RequestConverters::putScript, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -1374,10 +1413,11 @@ public class RestHighLevelClient implements Closeable {
* @param fieldCapabilitiesRequest the request * @param fieldCapabilitiesRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public final void fieldCapsAsync(FieldCapabilitiesRequest fieldCapabilitiesRequest, RequestOptions options, public final Cancellable fieldCapsAsync(FieldCapabilitiesRequest fieldCapabilitiesRequest, RequestOptions options,
ActionListener<FieldCapabilitiesResponse> listener) { ActionListener<FieldCapabilitiesResponse> listener) {
performRequestAsyncAndParseEntity(fieldCapabilitiesRequest, RequestConverters::fieldCaps, options, return performRequestAsyncAndParseEntity(fieldCapabilitiesRequest, RequestConverters::fieldCaps, options,
FieldCapabilitiesResponse::fromXContent, listener, emptySet()); FieldCapabilitiesResponse::fromXContent, listener, emptySet());
} }
@ -1509,26 +1549,28 @@ public class RestHighLevelClient implements Closeable {
/** /**
* @deprecated If creating a new HLRC ReST API call, consider creating new actions instead of reusing server actions. The Validation * @deprecated If creating a new HLRC ReST API call, consider creating new actions instead of reusing server actions. The Validation
* layer has been added to the ReST client, and requests should extend {@link Validatable} instead of {@link ActionRequest}. * layer has been added to the ReST client, and requests should extend {@link Validatable} instead of {@link ActionRequest}.
* @return Cancellable instance that may be used to cancel the request
*/ */
@Deprecated @Deprecated
protected final <Req extends ActionRequest, Resp> void performRequestAsyncAndParseEntity(Req request, protected final <Req extends ActionRequest, Resp> Cancellable performRequestAsyncAndParseEntity(Req request,
CheckedFunction<Req, Request, IOException> requestConverter, CheckedFunction<Req, Request, IOException> requestConverter,
RequestOptions options, RequestOptions options,
CheckedFunction<XContentParser, Resp, IOException> entityParser, CheckedFunction<XContentParser, Resp, IOException> entityParser,
ActionListener<Resp> listener, Set<Integer> ignores) { ActionListener<Resp> listener, Set<Integer> ignores) {
performRequestAsync(request, requestConverter, options, return performRequestAsync(request, requestConverter, options,
response -> parseEntity(response.getEntity(), entityParser), listener, ignores); response -> parseEntity(response.getEntity(), entityParser), listener, ignores);
} }
/** /**
* Defines a helper method for asynchronously performing a request. * Defines a helper method for asynchronously performing a request.
* @return Cancellable instance that may be used to cancel the request
*/ */
protected final <Req extends Validatable, Resp> void performRequestAsyncAndParseEntity(Req request, protected final <Req extends Validatable, Resp> Cancellable performRequestAsyncAndParseEntity(Req request,
CheckedFunction<Req, Request, IOException> requestConverter, CheckedFunction<Req, Request, IOException> requestConverter,
RequestOptions options, RequestOptions options,
CheckedFunction<XContentParser, Resp, IOException> entityParser, CheckedFunction<XContentParser, Resp, IOException> entityParser,
ActionListener<Resp> listener, Set<Integer> ignores) { ActionListener<Resp> listener, Set<Integer> ignores) {
performRequestAsync(request, requestConverter, options, return performRequestAsync(request, requestConverter, options,
response -> parseEntity(response.getEntity(), entityParser), listener, ignores); response -> parseEntity(response.getEntity(), entityParser), listener, ignores);
} }
@ -1536,56 +1578,59 @@ public class RestHighLevelClient implements Closeable {
/** /**
* @deprecated If creating a new HLRC ReST API call, consider creating new actions instead of reusing server actions. The Validation * @deprecated If creating a new HLRC ReST API call, consider creating new actions instead of reusing server actions. The Validation
* layer has been added to the ReST client, and requests should extend {@link Validatable} instead of {@link ActionRequest}. * layer has been added to the ReST client, and requests should extend {@link Validatable} instead of {@link ActionRequest}.
* @return Cancellable instance that may be used to cancel the request
*/ */
@Deprecated @Deprecated
protected final <Req extends ActionRequest, Resp> void performRequestAsync(Req request, protected final <Req extends ActionRequest, Resp> Cancellable performRequestAsync(Req request,
CheckedFunction<Req, Request, IOException> requestConverter, CheckedFunction<Req, Request, IOException> requestConverter,
RequestOptions options, RequestOptions options,
CheckedFunction<Response, Resp, IOException> responseConverter, CheckedFunction<Response, Resp, IOException> responseConverter,
ActionListener<Resp> listener, Set<Integer> ignores) { ActionListener<Resp> listener, Set<Integer> ignores) {
ActionRequestValidationException validationException = request.validate(); ActionRequestValidationException validationException = request.validate();
if (validationException != null && validationException.validationErrors().isEmpty() == false) { if (validationException != null && validationException.validationErrors().isEmpty() == false) {
listener.onFailure(validationException); listener.onFailure(validationException);
return; return Cancellable.NO_OP;
} }
internalPerformRequestAsync(request, requestConverter, options, responseConverter, listener, ignores); return internalPerformRequestAsync(request, requestConverter, options, responseConverter, listener, ignores);
} }
/** /**
* Defines a helper method for asynchronously performing a request. * Defines a helper method for asynchronously performing a request.
* @return Cancellable instance that may be used to cancel the request
*/ */
protected final <Req extends Validatable, Resp> void performRequestAsync(Req request, protected final <Req extends Validatable, Resp> Cancellable performRequestAsync(Req request,
CheckedFunction<Req, Request, IOException> requestConverter, CheckedFunction<Req, Request, IOException> requestConverter,
RequestOptions options, RequestOptions options,
CheckedFunction<Response, Resp, IOException> responseConverter, CheckedFunction<Response, Resp, IOException> responseConverter,
ActionListener<Resp> listener, Set<Integer> ignores) { ActionListener<Resp> listener, Set<Integer> ignores) {
Optional<ValidationException> validationException = request.validate(); Optional<ValidationException> validationException = request.validate();
if (validationException != null && validationException.isPresent()) { if (validationException != null && validationException.isPresent()) {
listener.onFailure(validationException.get()); listener.onFailure(validationException.get());
return; return Cancellable.NO_OP;
} }
internalPerformRequestAsync(request, requestConverter, options, responseConverter, listener, ignores); return internalPerformRequestAsync(request, requestConverter, options, responseConverter, listener, ignores);
} }
/** /**
* Provides common functionality for asynchronously performing a request. * Provides common functionality for asynchronously performing a request.
* @return Cancellable instance that may be used to cancel the request
*/ */
private <Req, Resp> void internalPerformRequestAsync(Req request, private <Req, Resp> Cancellable internalPerformRequestAsync(Req request,
CheckedFunction<Req, Request, IOException> requestConverter, CheckedFunction<Req, Request, IOException> requestConverter,
RequestOptions options, RequestOptions options,
CheckedFunction<Response, Resp, IOException> responseConverter, CheckedFunction<Response, Resp, IOException> responseConverter,
ActionListener<Resp> listener, Set<Integer> ignores) { ActionListener<Resp> listener, Set<Integer> ignores) {
Request req; Request req;
try { try {
req = requestConverter.apply(request); req = requestConverter.apply(request);
} catch (Exception e) { } catch (Exception e) {
listener.onFailure(e); listener.onFailure(e);
return; return Cancellable.NO_OP;
} }
req.setOptions(options); req.setOptions(options);
ResponseListener responseListener = wrapResponseListener(responseConverter, listener, ignores); ResponseListener responseListener = wrapResponseListener(responseConverter, listener, ignores);
client.performRequestAsync(req, responseListener); return client.performRequestAsync(req, responseListener);
} }
@ -1629,28 +1674,29 @@ public class RestHighLevelClient implements Closeable {
/** /**
* Asynchronous request which returns empty {@link Optional}s in the case of 404s or parses entity into an Optional * Asynchronous request which returns empty {@link Optional}s in the case of 404s or parses entity into an Optional
* @return Cancellable instance that may be used to cancel the request
*/ */
protected final <Req extends Validatable, Resp> void performRequestAsyncAndParseOptionalEntity(Req request, protected final <Req extends Validatable, Resp> Cancellable performRequestAsyncAndParseOptionalEntity(Req request,
CheckedFunction<Req, Request, IOException> requestConverter, CheckedFunction<Req, Request, IOException> requestConverter,
RequestOptions options, RequestOptions options,
CheckedFunction<XContentParser, Resp, IOException> entityParser, CheckedFunction<XContentParser, Resp, IOException> entityParser,
ActionListener<Optional<Resp>> listener) { ActionListener<Optional<Resp>> listener) {
Optional<ValidationException> validationException = request.validate(); Optional<ValidationException> validationException = request.validate();
if (validationException != null && validationException.isPresent()) { if (validationException != null && validationException.isPresent()) {
listener.onFailure(validationException.get()); listener.onFailure(validationException.get());
return; return Cancellable.NO_OP;
} }
Request req; Request req;
try { try {
req = requestConverter.apply(request); req = requestConverter.apply(request);
} catch (Exception e) { } catch (Exception e) {
listener.onFailure(e); listener.onFailure(e);
return; return Cancellable.NO_OP;
} }
req.setOptions(options); req.setOptions(options);
ResponseListener responseListener = wrapResponseListener404sOptional(response -> parseEntity(response.getEntity(), ResponseListener responseListener = wrapResponseListener404sOptional(response -> parseEntity(response.getEntity(),
entityParser), listener); entityParser), listener);
client.performRequestAsync(req, responseListener); return client.performRequestAsync(req, responseListener);
} }
final <Resp> ResponseListener wrapResponseListener404sOptional(CheckedFunction<Response, Resp, IOException> responseConverter, final <Resp> ResponseListener wrapResponseListener404sOptional(CheckedFunction<Response, Resp, IOException> responseConverter,

58
client/rest-high-level/src/main/java/org/elasticsearch/client/RollupClient.java
View File

@ -30,8 +30,6 @@ import org.elasticsearch.client.rollup.GetRollupJobRequest;
import org.elasticsearch.client.rollup.GetRollupJobResponse; import org.elasticsearch.client.rollup.GetRollupJobResponse;
import org.elasticsearch.client.rollup.GetRollupCapsRequest; import org.elasticsearch.client.rollup.GetRollupCapsRequest;
import org.elasticsearch.client.rollup.GetRollupCapsResponse; import org.elasticsearch.client.rollup.GetRollupCapsResponse;
import org.elasticsearch.client.rollup.GetRollupJobRequest;
import org.elasticsearch.client.rollup.GetRollupJobResponse;
import org.elasticsearch.client.rollup.PutRollupJobRequest; import org.elasticsearch.client.rollup.PutRollupJobRequest;
import org.elasticsearch.client.rollup.StartRollupJobRequest; import org.elasticsearch.client.rollup.StartRollupJobRequest;
import org.elasticsearch.client.rollup.StartRollupJobResponse; import org.elasticsearch.client.rollup.StartRollupJobResponse;
@ -80,9 +78,11 @@ public class RollupClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putRollupJobAsync(PutRollupJobRequest request, RequestOptions options, ActionListener<AcknowledgedResponse> listener) { public Cancellable putRollupJobAsync(PutRollupJobRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, ActionListener<AcknowledgedResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request,
RollupRequestConverters::putJob, RollupRequestConverters::putJob,
options, options,
AcknowledgedResponse::fromXContent, AcknowledgedResponse::fromXContent,
@ -113,10 +113,11 @@ public class RollupClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void startRollupJobAsync(StartRollupJobRequest request, RequestOptions options, public Cancellable startRollupJobAsync(StartRollupJobRequest request, RequestOptions options,
ActionListener<StartRollupJobResponse> listener) { ActionListener<StartRollupJobResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
RollupRequestConverters::startJob, RollupRequestConverters::startJob,
options, options,
StartRollupJobResponse::fromXContent, StartRollupJobResponse::fromXContent,
@ -147,10 +148,11 @@ public class RollupClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void stopRollupJobAsync(StopRollupJobRequest request, RequestOptions options, public Cancellable stopRollupJobAsync(StopRollupJobRequest request, RequestOptions options,
ActionListener<StopRollupJobResponse> listener) { ActionListener<StopRollupJobResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
RollupRequestConverters::stopJob, RollupRequestConverters::stopJob,
options, options,
StopRollupJobResponse::fromXContent, StopRollupJobResponse::fromXContent,
@ -180,11 +182,12 @@ public class RollupClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteRollupJobAsync(DeleteRollupJobRequest request, public Cancellable deleteRollupJobAsync(DeleteRollupJobRequest request,
RequestOptions options, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
RollupRequestConverters::deleteJob, RollupRequestConverters::deleteJob,
options, options,
AcknowledgedResponse::fromXContent, AcknowledgedResponse::fromXContent,
@ -215,11 +218,11 @@ public class RollupClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public Cancellable getRollupJobAsync(GetRollupJobRequest request, RequestOptions options,
ActionListener<GetRollupJobResponse> listener) {
public void getRollupJobAsync(GetRollupJobRequest request, RequestOptions options, ActionListener<GetRollupJobResponse> listener) { return restHighLevelClient.performRequestAsyncAndParseEntity(request,
restHighLevelClient.performRequestAsyncAndParseEntity(request,
RollupRequestConverters::getJob, RollupRequestConverters::getJob,
options, options,
GetRollupJobResponse::fromXContent, GetRollupJobResponse::fromXContent,
@ -251,9 +254,10 @@ public class RollupClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void searchAsync(SearchRequest request, RequestOptions options, ActionListener<SearchResponse> listener) { public Cancellable searchAsync(SearchRequest request, RequestOptions options, ActionListener<SearchResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( return restHighLevelClient.performRequestAsyncAndParseEntity(
request, request,
RollupRequestConverters::search, RollupRequestConverters::search,
options, options,
@ -286,10 +290,11 @@ public class RollupClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getRollupCapabilitiesAsync(GetRollupCapsRequest request, RequestOptions options, public Cancellable getRollupCapabilitiesAsync(GetRollupCapsRequest request, RequestOptions options,
ActionListener<GetRollupCapsResponse> listener) { ActionListener<GetRollupCapsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
RollupRequestConverters::getRollupCaps, RollupRequestConverters::getRollupCaps,
options, options,
GetRollupCapsResponse::fromXContent, GetRollupCapsResponse::fromXContent,
@ -322,10 +327,11 @@ public class RollupClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getRollupIndexCapabilitiesAsync(GetRollupIndexCapsRequest request, RequestOptions options, public Cancellable getRollupIndexCapabilitiesAsync(GetRollupIndexCapsRequest request, RequestOptions options,
ActionListener<GetRollupIndexCapsResponse> listener) { ActionListener<GetRollupIndexCapsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
RollupRequestConverters::getRollupIndexCaps, RollupRequestConverters::getRollupIndexCaps,
options, options,
GetRollupIndexCapsResponse::fromXContent, GetRollupIndexCapsResponse::fromXContent,

204
client/rest-high-level/src/main/java/org/elasticsearch/client/SecurityClient.java
View File

@ -113,9 +113,10 @@ public final class SecurityClient {
* @param request the request with the user's name * @param request the request with the user's name
* @param options the request options (e.g., headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g., headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getUsersAsync(GetUsersRequest request, RequestOptions options, ActionListener<GetUsersResponse> listener) { public Cancellable getUsersAsync(GetUsersRequest request, RequestOptions options, ActionListener<GetUsersResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::getUsers, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::getUsers, options,
GetUsersResponse::fromXContent, listener, emptySet()); GetUsersResponse::fromXContent, listener, emptySet());
} }
@ -142,9 +143,10 @@ public final class SecurityClient {
* @param request the request with the user's information * @param request the request with the user's information
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putUserAsync(PutUserRequest request, RequestOptions options, ActionListener<PutUserResponse> listener) { public Cancellable putUserAsync(PutUserRequest request, RequestOptions options, ActionListener<PutUserResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::putUser, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::putUser, options,
PutUserResponse::fromXContent, listener, emptySet()); PutUserResponse::fromXContent, listener, emptySet());
} }
@ -169,9 +171,10 @@ public final class SecurityClient {
* @param request the request with the user to delete * @param request the request with the user to delete
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteUserAsync(DeleteUserRequest request, RequestOptions options, ActionListener<DeleteUserResponse> listener) { public Cancellable deleteUserAsync(DeleteUserRequest request, RequestOptions options, ActionListener<DeleteUserResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::deleteUser, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::deleteUser, options,
DeleteUserResponse::fromXContent, listener, singleton(404)); DeleteUserResponse::fromXContent, listener, singleton(404));
} }
@ -196,10 +199,11 @@ public final class SecurityClient {
* @param request the request with the role mapping information * @param request the request with the role mapping information
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putRoleMappingAsync(final PutRoleMappingRequest request, final RequestOptions options, public Cancellable putRoleMappingAsync(final PutRoleMappingRequest request, final RequestOptions options,
final ActionListener<PutRoleMappingResponse> listener) { final ActionListener<PutRoleMappingResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::putRoleMapping, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::putRoleMapping, options,
PutRoleMappingResponse::fromXContent, listener, emptySet()); PutRoleMappingResponse::fromXContent, listener, emptySet());
} }
@ -216,7 +220,8 @@ public final class SecurityClient {
* @throws IOException in case there is a problem sending the request or * @throws IOException in case there is a problem sending the request or
* parsing back the response * parsing back the response
*/ */
public GetRoleMappingsResponse getRoleMappings(final GetRoleMappingsRequest request, final RequestOptions options) throws IOException { public GetRoleMappingsResponse getRoleMappings(final GetRoleMappingsRequest request,
final RequestOptions options) throws IOException {
return restHighLevelClient.performRequestAndParseEntity(request, SecurityRequestConverters::getRoleMappings, return restHighLevelClient.performRequestAndParseEntity(request, SecurityRequestConverters::getRoleMappings,
options, GetRoleMappingsResponse::fromXContent, emptySet()); options, GetRoleMappingsResponse::fromXContent, emptySet());
} }
@ -230,10 +235,11 @@ public final class SecurityClient {
* If no role mapping name is provided then retrieves all role mappings. * If no role mapping name is provided then retrieves all role mappings.
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getRoleMappingsAsync(final GetRoleMappingsRequest request, final RequestOptions options, public Cancellable getRoleMappingsAsync(final GetRoleMappingsRequest request, final RequestOptions options,
final ActionListener<GetRoleMappingsResponse> listener) { final ActionListener<GetRoleMappingsResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::getRoleMappings, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::getRoleMappings,
options, GetRoleMappingsResponse::fromXContent, listener, emptySet()); options, GetRoleMappingsResponse::fromXContent, listener, emptySet());
} }
@ -276,10 +282,11 @@ public final class SecurityClient {
* @param request the request with the user to enable * @param request the request with the user to enable
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void enableUserAsync(EnableUserRequest request, RequestOptions options, public Cancellable enableUserAsync(EnableUserRequest request, RequestOptions options,
ActionListener<Boolean> listener) { ActionListener<Boolean> listener) {
restHighLevelClient.performRequestAsync(request, SecurityRequestConverters::enableUser, options, return restHighLevelClient.performRequestAsync(request, SecurityRequestConverters::enableUser, options,
RestHighLevelClient::convertExistsResponse, listener, emptySet()); RestHighLevelClient::convertExistsResponse, listener, emptySet());
} }
@ -292,11 +299,12 @@ public final class SecurityClient {
* @param request the request with the user to enable * @param request the request with the user to enable
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @deprecated use {@link #enableUserAsync(EnableUserRequest, RequestOptions, ActionListener)} instead * @deprecated use {@link #enableUserAsync(EnableUserRequest, RequestOptions, ActionListener)} instead
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public void enableUserAsync(RequestOptions options, EnableUserRequest request, public Cancellable enableUserAsync(RequestOptions options, EnableUserRequest request,
ActionListener<Boolean> listener) { ActionListener<Boolean> listener) {
enableUserAsync(request, options, listener); return enableUserAsync(request, options, listener);
} }
/** /**
@ -338,10 +346,11 @@ public final class SecurityClient {
* @param request the request with the user to disable * @param request the request with the user to disable
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void disableUserAsync(DisableUserRequest request, RequestOptions options, public Cancellable disableUserAsync(DisableUserRequest request, RequestOptions options,
ActionListener<Boolean> listener) { ActionListener<Boolean> listener) {
restHighLevelClient.performRequestAsync(request, SecurityRequestConverters::disableUser, options, return restHighLevelClient.performRequestAsync(request, SecurityRequestConverters::disableUser, options,
RestHighLevelClient::convertExistsResponse, listener, emptySet()); RestHighLevelClient::convertExistsResponse, listener, emptySet());
} }
@ -354,11 +363,12 @@ public final class SecurityClient {
* @param request the request with the user to disable * @param request the request with the user to disable
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @deprecated use {@link #disableUserAsync(DisableUserRequest, RequestOptions, ActionListener)} instead * @deprecated use {@link #disableUserAsync(DisableUserRequest, RequestOptions, ActionListener)} instead
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public void disableUserAsync(RequestOptions options, DisableUserRequest request, public Cancellable disableUserAsync(RequestOptions options, DisableUserRequest request,
ActionListener<Boolean> listener) { ActionListener<Boolean> listener) {
disableUserAsync(request, options, listener); return disableUserAsync(request, options, listener);
} }
/** /**
@ -381,9 +391,10 @@ public final class SecurityClient {
* *
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void authenticateAsync(RequestOptions options, ActionListener<AuthenticateResponse> listener) { public Cancellable authenticateAsync(RequestOptions options, ActionListener<AuthenticateResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(AuthenticateRequest.INSTANCE, AuthenticateRequest::getRequest, options, return restHighLevelClient.performRequestAsyncAndParseEntity(AuthenticateRequest.INSTANCE, AuthenticateRequest::getRequest, options,
AuthenticateResponse::fromXContent, listener, emptySet()); AuthenticateResponse::fromXContent, listener, emptySet());
} }
@ -405,13 +416,14 @@ public final class SecurityClient {
* Asynchronously determine whether the current user has a specified list of privileges * Asynchronously determine whether the current user has a specified list of privileges
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-has-privileges.html"> * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-has-privileges.html">
* the docs</a> for more. * the docs</a> for more.
*
* @param request the request with the privileges to check * @param request the request with the privileges to check
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void hasPrivilegesAsync(HasPrivilegesRequest request, RequestOptions options, ActionListener<HasPrivilegesResponse> listener) { public Cancellable hasPrivilegesAsync(HasPrivilegesRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::hasPrivileges, options, ActionListener<HasPrivilegesResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::hasPrivileges, options,
HasPrivilegesResponse::fromXContent, listener, emptySet()); HasPrivilegesResponse::fromXContent, listener, emptySet());
} }
@ -428,9 +440,11 @@ public final class SecurityClient {
* Asynchronously retrieve the set of effective privileges held by the current user. * Asynchronously retrieve the set of effective privileges held by the current user.
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getUserPrivilegesAsync(RequestOptions options, ActionListener<GetUserPrivilegesResponse> listener) { public Cancellable getUserPrivilegesAsync(RequestOptions options, ActionListener<GetUserPrivilegesResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(GetUserPrivilegesRequest.INSTANCE, GetUserPrivilegesRequest::getRequest, return restHighLevelClient.performRequestAsyncAndParseEntity(
GetUserPrivilegesRequest.INSTANCE, GetUserPrivilegesRequest::getRequest,
options, GetUserPrivilegesResponse::fromXContent, listener, emptySet()); options, GetUserPrivilegesResponse::fromXContent, listener, emptySet());
} }
@ -457,10 +471,11 @@ public final class SecurityClient {
* @param request the request with the realm names and usernames to clear the cache for * @param request the request with the realm names and usernames to clear the cache for
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void clearRealmCacheAsync(ClearRealmCacheRequest request, RequestOptions options, public Cancellable clearRealmCacheAsync(ClearRealmCacheRequest request, RequestOptions options,
ActionListener<ClearRealmCacheResponse> listener) { ActionListener<ClearRealmCacheResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::clearRealmCache, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::clearRealmCache, options,
ClearRealmCacheResponse::fromXContent, listener, emptySet()); ClearRealmCacheResponse::fromXContent, listener, emptySet());
} }
@ -487,10 +502,11 @@ public final class SecurityClient {
* @param request the request with the roles for which the cache should be cleared. * @param request the request with the roles for which the cache should be cleared.
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void clearRolesCacheAsync(ClearRolesCacheRequest request, RequestOptions options, public Cancellable clearRolesCacheAsync(ClearRolesCacheRequest request, RequestOptions options,
ActionListener<ClearRolesCacheResponse> listener) { ActionListener<ClearRolesCacheResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::clearRolesCache, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::clearRolesCache, options,
ClearRolesCacheResponse::fromXContent, listener, emptySet()); ClearRolesCacheResponse::fromXContent, listener, emptySet());
} }
@ -515,9 +531,11 @@ public final class SecurityClient {
* *
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getSslCertificatesAsync(RequestOptions options, ActionListener<GetSslCertificatesResponse> listener) { public Cancellable getSslCertificatesAsync(RequestOptions options, ActionListener<GetSslCertificatesResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(GetSslCertificatesRequest.INSTANCE, GetSslCertificatesRequest::getRequest, return restHighLevelClient.performRequestAsyncAndParseEntity(
GetSslCertificatesRequest.INSTANCE, GetSslCertificatesRequest::getRequest,
options, GetSslCertificatesResponse::fromXContent, listener, emptySet()); options, GetSslCertificatesResponse::fromXContent, listener, emptySet());
} }
@ -560,10 +578,11 @@ public final class SecurityClient {
* @param request the request with the user's new password * @param request the request with the user's new password
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void changePasswordAsync(ChangePasswordRequest request, RequestOptions options, public Cancellable changePasswordAsync(ChangePasswordRequest request, RequestOptions options,
ActionListener<Boolean> listener) { ActionListener<Boolean> listener) {
restHighLevelClient.performRequestAsync(request, SecurityRequestConverters::changePassword, options, return restHighLevelClient.performRequestAsync(request, SecurityRequestConverters::changePassword, options,
RestHighLevelClient::convertExistsResponse, listener, emptySet()); RestHighLevelClient::convertExistsResponse, listener, emptySet());
} }
@ -576,11 +595,12 @@ public final class SecurityClient {
* @param request the request with the user's new password * @param request the request with the user's new password
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @deprecated use {@link #changePasswordAsync(ChangePasswordRequest, RequestOptions, ActionListener)} instead * @deprecated use {@link #changePasswordAsync(ChangePasswordRequest, RequestOptions, ActionListener)} instead
* @return cancellable that may be used to cancel the request
*/ */
@Deprecated @Deprecated
public void changePasswordAsync(RequestOptions options, ChangePasswordRequest request, public Cancellable changePasswordAsync(RequestOptions options, ChangePasswordRequest request,
ActionListener<Boolean> listener) { ActionListener<Boolean> listener) {
changePasswordAsync(request, options, listener); return changePasswordAsync(request, options, listener);
} }
/** /**
@ -605,9 +625,10 @@ public final class SecurityClient {
* @param request the request with the roles to get * @param request the request with the roles to get
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getRolesAsync(GetRolesRequest request, RequestOptions options, ActionListener<GetRolesResponse> listener) { public Cancellable getRolesAsync(GetRolesRequest request, RequestOptions options, ActionListener<GetRolesResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::getRoles, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::getRoles, options,
GetRolesResponse::fromXContent, listener, emptySet()); GetRolesResponse::fromXContent, listener, emptySet());
} }
@ -634,9 +655,10 @@ public final class SecurityClient {
* @param request the request containing the role to create or update * @param request the request containing the role to create or update
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putRoleAsync(PutRoleRequest request, RequestOptions options, ActionListener<PutRoleResponse> listener) { public Cancellable putRoleAsync(PutRoleRequest request, RequestOptions options, ActionListener<PutRoleResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::putRole, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::putRole, options,
PutRoleResponse::fromXContent, listener, emptySet()); PutRoleResponse::fromXContent, listener, emptySet());
} }
@ -662,10 +684,12 @@ public final class SecurityClient {
* @param request the request with the role mapping name to be deleted. * @param request the request with the role mapping name to be deleted.
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteRoleMappingAsync(DeleteRoleMappingRequest request, RequestOptions options, public Cancellable deleteRoleMappingAsync(DeleteRoleMappingRequest request, RequestOptions options,
ActionListener<DeleteRoleMappingResponse> listener) { ActionListener<DeleteRoleMappingResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::deleteRoleMapping, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request,
SecurityRequestConverters::deleteRoleMapping, options,
DeleteRoleMappingResponse::fromXContent, listener, emptySet()); DeleteRoleMappingResponse::fromXContent, listener, emptySet());
} }
@ -690,9 +714,11 @@ public final class SecurityClient {
* @param request the request with the role to delete * @param request the request with the role to delete
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteRoleAsync(DeleteRoleRequest request, RequestOptions options, ActionListener<DeleteRoleResponse> listener) { public Cancellable deleteRoleAsync(DeleteRoleRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::deleteRole, options, ActionListener<DeleteRoleResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::deleteRole, options,
DeleteRoleResponse::fromXContent, listener, singleton(404)); DeleteRoleResponse::fromXContent, listener, singleton(404));
} }
@ -719,9 +745,11 @@ public final class SecurityClient {
* @param request the request for the token * @param request the request for the token
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void createTokenAsync(CreateTokenRequest request, RequestOptions options, ActionListener<CreateTokenResponse> listener) { public Cancellable createTokenAsync(CreateTokenRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::createToken, options, ActionListener<CreateTokenResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::createToken, options,
CreateTokenResponse::fromXContent, listener, emptySet()); CreateTokenResponse::fromXContent, listener, emptySet());
} }
@ -744,14 +772,14 @@ public final class SecurityClient {
* Asynchronously invalidates an OAuth2 token. * Asynchronously invalidates an OAuth2 token.
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-invalidate-token.html"> * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-invalidate-token.html">
* the docs</a> for more. * the docs</a> for more.
*
* @param request the request to invalidate the token * @param request the request to invalidate the token
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void invalidateTokenAsync(InvalidateTokenRequest request, RequestOptions options, public Cancellable invalidateTokenAsync(InvalidateTokenRequest request, RequestOptions options,
ActionListener<InvalidateTokenResponse> listener) { ActionListener<InvalidateTokenResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::invalidateToken, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::invalidateToken, options,
InvalidateTokenResponse::fromXContent, listener, emptySet()); InvalidateTokenResponse::fromXContent, listener, emptySet());
} }
@ -777,10 +805,13 @@ public final class SecurityClient {
* *
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getBuiltinPrivilegesAsync(final RequestOptions options, final ActionListener<GetBuiltinPrivilegesResponse> listener) { public Cancellable getBuiltinPrivilegesAsync(final RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(GetBuiltinPrivilegesRequest.INSTANCE, final ActionListener<GetBuiltinPrivilegesResponse> listener) {
GetBuiltinPrivilegesRequest::getRequest, options, GetBuiltinPrivilegesResponse::fromXContent, listener, emptySet()); return restHighLevelClient.performRequestAsyncAndParseEntity(GetBuiltinPrivilegesRequest.INSTANCE,
GetBuiltinPrivilegesRequest::getRequest, options, GetBuiltinPrivilegesResponse::fromXContent,
listener, emptySet());
} }
/** /**
@ -806,16 +837,16 @@ public final class SecurityClient {
* Asynchronously get application privilege(s). * Asynchronously get application privilege(s).
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-get-privileges.html"> * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-get-privileges.html">
* the docs</a> for more. * the docs</a> for more.
* * @param request {@link GetPrivilegesRequest} with the application name and the privilege name.
* @param request {@link GetPrivilegesRequest} with the application name and the privilege name.
* If no application name is provided, information about all privileges for all applications is retrieved. * If no application name is provided, information about all privileges for all applications is retrieved.
* If no privilege name is provided, information about all privileges of the specified application is retrieved. * If no privilege name is provided, information about all privileges of the specified application is retrieved.
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getPrivilegesAsync(final GetPrivilegesRequest request, final RequestOptions options, public Cancellable getPrivilegesAsync(final GetPrivilegesRequest request, final RequestOptions options,
final ActionListener<GetPrivilegesResponse> listener) { final ActionListener<GetPrivilegesResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::getPrivileges, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::getPrivileges,
options, GetPrivilegesResponse::fromXContent, listener, emptySet()); options, GetPrivilegesResponse::fromXContent, listener, emptySet());
} }
@ -844,10 +875,11 @@ public final class SecurityClient {
* @param options the request options (e.g. headers), use * @param options the request options (e.g. headers), use
* {@link RequestOptions#DEFAULT} if nothing needs to be customized * {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putPrivilegesAsync(final PutPrivilegesRequest request, final RequestOptions options, public Cancellable putPrivilegesAsync(final PutPrivilegesRequest request, final RequestOptions options,
final ActionListener<PutPrivilegesResponse> listener) { final ActionListener<PutPrivilegesResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::putPrivileges, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::putPrivileges, options,
PutPrivilegesResponse::fromXContent, listener, emptySet()); PutPrivilegesResponse::fromXContent, listener, emptySet());
} }
@ -874,10 +906,11 @@ public final class SecurityClient {
* @param request the request with the application privilege to delete * @param request the request with the application privilege to delete
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deletePrivilegesAsync(DeletePrivilegesRequest request, RequestOptions options, public Cancellable deletePrivilegesAsync(DeletePrivilegesRequest request, RequestOptions options,
ActionListener<DeletePrivilegesResponse> listener) { ActionListener<DeletePrivilegesResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::deletePrivileges, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::deletePrivileges, options,
DeletePrivilegesResponse::fromXContent, listener, singleton(404)); DeletePrivilegesResponse::fromXContent, listener, singleton(404));
} }
@ -904,10 +937,11 @@ public final class SecurityClient {
* @param request the request to create a API key * @param request the request to create a API key
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void createApiKeyAsync(final CreateApiKeyRequest request, final RequestOptions options, public Cancellable createApiKeyAsync(final CreateApiKeyRequest request, final RequestOptions options,
final ActionListener<CreateApiKeyResponse> listener) { final ActionListener<CreateApiKeyResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::createApiKey, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::createApiKey, options,
CreateApiKeyResponse::fromXContent, listener, emptySet()); CreateApiKeyResponse::fromXContent, listener, emptySet());
} }
@ -934,10 +968,11 @@ public final class SecurityClient {
* @param request the request to retrieve API key(s) * @param request the request to retrieve API key(s)
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getApiKeyAsync(final GetApiKeyRequest request, final RequestOptions options, public Cancellable getApiKeyAsync(final GetApiKeyRequest request, final RequestOptions options,
final ActionListener<GetApiKeyResponse> listener) { final ActionListener<GetApiKeyResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::getApiKey, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::getApiKey, options,
GetApiKeyResponse::fromXContent, listener, emptySet()); GetApiKeyResponse::fromXContent, listener, emptySet());
} }
@ -965,10 +1000,11 @@ public final class SecurityClient {
* @param request the request to invalidate API key(s) * @param request the request to invalidate API key(s)
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void invalidateApiKeyAsync(final InvalidateApiKeyRequest request, final RequestOptions options, public Cancellable invalidateApiKeyAsync(final InvalidateApiKeyRequest request, final RequestOptions options,
final ActionListener<InvalidateApiKeyResponse> listener) { final ActionListener<InvalidateApiKeyResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::invalidateApiKey, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, SecurityRequestConverters::invalidateApiKey, options,
InvalidateApiKeyResponse::fromXContent, listener, emptySet()); InvalidateApiKeyResponse::fromXContent, listener, emptySet());
} }

82
client/rest-high-level/src/main/java/org/elasticsearch/client/SnapshotClient.java
View File

@ -79,10 +79,12 @@ public final class SnapshotClient {
* @param getRepositoriesRequest the request * @param getRepositoriesRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getRepositoryAsync(GetRepositoriesRequest getRepositoriesRequest, RequestOptions options, public Cancellable getRepositoryAsync(GetRepositoriesRequest getRepositoriesRequest, RequestOptions options,
ActionListener<GetRepositoriesResponse> listener) { ActionListener<GetRepositoriesResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(getRepositoriesRequest, SnapshotRequestConverters::getRepositories, options, return restHighLevelClient.performRequestAsyncAndParseEntity(getRepositoriesRequest,
SnapshotRequestConverters::getRepositories, options,
GetRepositoriesResponse::fromXContent, listener, emptySet()); GetRepositoriesResponse::fromXContent, listener, emptySet());
} }
@ -107,10 +109,12 @@ public final class SnapshotClient {
* @param putRepositoryRequest the request * @param putRepositoryRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void createRepositoryAsync(PutRepositoryRequest putRepositoryRequest, RequestOptions options, public Cancellable createRepositoryAsync(PutRepositoryRequest putRepositoryRequest, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(putRepositoryRequest, SnapshotRequestConverters::createRepository, options, return restHighLevelClient.performRequestAsyncAndParseEntity(putRepositoryRequest,
SnapshotRequestConverters::createRepository, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -136,10 +140,12 @@ public final class SnapshotClient {
* @param deleteRepositoryRequest the request * @param deleteRepositoryRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteRepositoryAsync(DeleteRepositoryRequest deleteRepositoryRequest, RequestOptions options, public Cancellable deleteRepositoryAsync(DeleteRepositoryRequest deleteRepositoryRequest, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(deleteRepositoryRequest, SnapshotRequestConverters::deleteRepository, options, return restHighLevelClient.performRequestAsyncAndParseEntity(deleteRepositoryRequest,
SnapshotRequestConverters::deleteRepository, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -165,10 +171,12 @@ public final class SnapshotClient {
* @param verifyRepositoryRequest the request * @param verifyRepositoryRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void verifyRepositoryAsync(VerifyRepositoryRequest verifyRepositoryRequest, RequestOptions options, public Cancellable verifyRepositoryAsync(VerifyRepositoryRequest verifyRepositoryRequest, RequestOptions options,
ActionListener<VerifyRepositoryResponse> listener) { ActionListener<VerifyRepositoryResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(verifyRepositoryRequest, SnapshotRequestConverters::verifyRepository, options, return restHighLevelClient.performRequestAsyncAndParseEntity(verifyRepositoryRequest,
SnapshotRequestConverters::verifyRepository, options,
VerifyRepositoryResponse::fromXContent, listener, emptySet()); VerifyRepositoryResponse::fromXContent, listener, emptySet());
} }
@ -194,10 +202,11 @@ public final class SnapshotClient {
* @param cleanupRepositoryRequest the request * @param cleanupRepositoryRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void cleanupRepositoryAsync(CleanupRepositoryRequest cleanupRepositoryRequest, RequestOptions options, public Cancellable cleanupRepositoryAsync(CleanupRepositoryRequest cleanupRepositoryRequest, RequestOptions options,
ActionListener<CleanupRepositoryResponse> listener) { ActionListener<CleanupRepositoryResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(cleanupRepositoryRequest, SnapshotRequestConverters::cleanupRepository, return restHighLevelClient.performRequestAsyncAndParseEntity(cleanupRepositoryRequest, SnapshotRequestConverters::cleanupRepository,
options, CleanupRepositoryResponse::fromXContent, listener, emptySet()); options, CleanupRepositoryResponse::fromXContent, listener, emptySet());
} }
@ -218,10 +227,12 @@ public final class SnapshotClient {
* <p> * <p>
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/modules-snapshots.html"> Snapshot and Restore * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/modules-snapshots.html"> Snapshot and Restore
* API on elastic.co</a> * API on elastic.co</a>
* @return cancellable that may be used to cancel the request
*/ */
public void createAsync(CreateSnapshotRequest createSnapshotRequest, RequestOptions options, public Cancellable createAsync(CreateSnapshotRequest createSnapshotRequest, RequestOptions options,
ActionListener<CreateSnapshotResponse> listener) { ActionListener<CreateSnapshotResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(createSnapshotRequest, SnapshotRequestConverters::createSnapshot, options, return restHighLevelClient.performRequestAsyncAndParseEntity(createSnapshotRequest,
SnapshotRequestConverters::createSnapshot, options,
CreateSnapshotResponse::fromXContent, listener, emptySet()); CreateSnapshotResponse::fromXContent, listener, emptySet());
} }
@ -244,13 +255,15 @@ public final class SnapshotClient {
* Asynchronously get snapshots. * Asynchronously get snapshots.
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/modules-snapshots.html"> Snapshot and Restore * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/modules-snapshots.html"> Snapshot and Restore
* API on elastic.co</a> * API on elastic.co</a>
* * @param getSnapshotsRequest the request
* @param getSnapshotsRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getAsync(GetSnapshotsRequest getSnapshotsRequest, RequestOptions options, ActionListener<GetSnapshotsResponse> listener) { public Cancellable getAsync(GetSnapshotsRequest getSnapshotsRequest, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(getSnapshotsRequest, SnapshotRequestConverters::getSnapshots, options, ActionListener<GetSnapshotsResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(getSnapshotsRequest,
SnapshotRequestConverters::getSnapshots, options,
GetSnapshotsResponse::fromXContent, listener, emptySet()); GetSnapshotsResponse::fromXContent, listener, emptySet());
} }
@ -276,10 +289,12 @@ public final class SnapshotClient {
* @param snapshotsStatusRequest the request * @param snapshotsStatusRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void statusAsync(SnapshotsStatusRequest snapshotsStatusRequest, RequestOptions options, public Cancellable statusAsync(SnapshotsStatusRequest snapshotsStatusRequest, RequestOptions options,
ActionListener<SnapshotsStatusResponse> listener) { ActionListener<SnapshotsStatusResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(snapshotsStatusRequest, SnapshotRequestConverters::snapshotsStatus, options, return restHighLevelClient.performRequestAsyncAndParseEntity(snapshotsStatusRequest,
SnapshotRequestConverters::snapshotsStatus, options,
SnapshotsStatusResponse::fromXContent, listener, emptySet()); SnapshotsStatusResponse::fromXContent, listener, emptySet());
} }
@ -306,10 +321,12 @@ public final class SnapshotClient {
* @param restoreSnapshotRequest the request * @param restoreSnapshotRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void restoreAsync(RestoreSnapshotRequest restoreSnapshotRequest, RequestOptions options, public Cancellable restoreAsync(RestoreSnapshotRequest restoreSnapshotRequest, RequestOptions options,
ActionListener<RestoreSnapshotResponse> listener) { ActionListener<RestoreSnapshotResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(restoreSnapshotRequest, SnapshotRequestConverters::restoreSnapshot, options, return restHighLevelClient.performRequestAsyncAndParseEntity(restoreSnapshotRequest,
SnapshotRequestConverters::restoreSnapshot, options,
RestoreSnapshotResponse::fromXContent, listener, emptySet()); RestoreSnapshotResponse::fromXContent, listener, emptySet());
} }
@ -324,7 +341,8 @@ public final class SnapshotClient {
* @throws IOException in case there is a problem sending the request or parsing back the response * @throws IOException in case there is a problem sending the request or parsing back the response
*/ */
public AcknowledgedResponse delete(DeleteSnapshotRequest deleteSnapshotRequest, RequestOptions options) throws IOException { public AcknowledgedResponse delete(DeleteSnapshotRequest deleteSnapshotRequest, RequestOptions options) throws IOException {
return restHighLevelClient.performRequestAndParseEntity(deleteSnapshotRequest, SnapshotRequestConverters::deleteSnapshot, options, return restHighLevelClient.performRequestAndParseEntity(deleteSnapshotRequest,
SnapshotRequestConverters::deleteSnapshot, options,
AcknowledgedResponse::fromXContent, emptySet()); AcknowledgedResponse::fromXContent, emptySet());
} }
@ -336,10 +354,12 @@ public final class SnapshotClient {
* @param deleteSnapshotRequest the request * @param deleteSnapshotRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteAsync(DeleteSnapshotRequest deleteSnapshotRequest, RequestOptions options, public Cancellable deleteAsync(DeleteSnapshotRequest deleteSnapshotRequest, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(deleteSnapshotRequest, SnapshotRequestConverters::deleteSnapshot, options, return restHighLevelClient.performRequestAsyncAndParseEntity(deleteSnapshotRequest,
SnapshotRequestConverters::deleteSnapshot, options,
AcknowledgedResponse::fromXContent, listener, emptySet()); AcknowledgedResponse::fromXContent, listener, emptySet());
} }
} }

29
client/rest-high-level/src/main/java/org/elasticsearch/client/TasksClient.java
View File

@ -65,12 +65,13 @@ public final class TasksClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void listAsync(ListTasksRequest request, RequestOptions options, ActionListener<ListTasksResponse> listener) { public Cancellable listAsync(ListTasksRequest request, RequestOptions options, ActionListener<ListTasksResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, TasksRequestConverters::listTasks, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, TasksRequestConverters::listTasks, options,
ListTasksResponse::fromXContent, listener, emptySet()); ListTasksResponse::fromXContent, listener, emptySet());
} }
/** /**
* Get a task using the Task Management API. * Get a task using the Task Management API.
* See * See
@ -82,9 +83,9 @@ public final class TasksClient {
*/ */
public Optional<GetTaskResponse> get(GetTaskRequest request, RequestOptions options) throws IOException { public Optional<GetTaskResponse> get(GetTaskRequest request, RequestOptions options) throws IOException {
return restHighLevelClient.performRequestAndParseOptionalEntity(request, TasksRequestConverters::getTask, options, return restHighLevelClient.performRequestAndParseOptionalEntity(request, TasksRequestConverters::getTask, options,
GetTaskResponse::fromXContent); GetTaskResponse::fromXContent);
} }
/** /**
* Get a task using the Task Management API. * Get a task using the Task Management API.
* See * See
@ -92,12 +93,14 @@ public final class TasksClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener an actionlistener that takes an optional response (404s are returned as an empty Optional) * @param listener an actionlistener that takes an optional response (404s are returned as an empty Optional)
* @return cancellable that may be used to cancel the request
*/ */
public void getAsync(GetTaskRequest request, RequestOptions options, ActionListener<Optional<GetTaskResponse>> listener) { public Cancellable getAsync(GetTaskRequest request, RequestOptions options,
ActionListener<Optional<GetTaskResponse>> listener) {
restHighLevelClient.performRequestAsyncAndParseOptionalEntity(request, TasksRequestConverters::getTask, options,
return restHighLevelClient.performRequestAsyncAndParseOptionalEntity(request, TasksRequestConverters::getTask, options,
GetTaskResponse::fromXContent, listener); GetTaskResponse::fromXContent, listener);
} }
/** /**
* Cancel one or more cluster tasks using the Task Management API. * Cancel one or more cluster tasks using the Task Management API.
@ -128,9 +131,11 @@ public final class TasksClient {
* @param cancelTasksRequest the request * @param cancelTasksRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void cancelAsync(CancelTasksRequest cancelTasksRequest, RequestOptions options, ActionListener<CancelTasksResponse> listener) { public Cancellable cancelAsync(CancelTasksRequest cancelTasksRequest, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity( ActionListener<CancelTasksResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(
cancelTasksRequest, cancelTasksRequest,
TasksRequestConverters::cancelTasks, TasksRequestConverters::cancelTasks,
options, options,

63
client/rest-high-level/src/main/java/org/elasticsearch/client/WatcherClient.java
View File

@ -71,10 +71,11 @@ public final class WatcherClient {
* See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/watcher-api-start.html"> * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/watcher-api-start.html">
* the docs</a> for more. * the docs</a> for more.
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @return cancellable that may be used to cancel the request
*/ */
public void startWatchServiceAsync(StartWatchServiceRequest request, RequestOptions options, public Cancellable startWatchServiceAsync(StartWatchServiceRequest request, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( return restHighLevelClient.performRequestAsyncAndParseEntity(
request, WatcherRequestConverters::startWatchService, options, AcknowledgedResponse::fromXContent, listener, emptySet()); request, WatcherRequestConverters::startWatchService, options, AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -98,10 +99,11 @@ public final class WatcherClient {
* the docs</a> for more. * the docs</a> for more.
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @return cancellable that may be used to cancel the request
*/ */
public void stopWatchServiceAsync(StopWatchServiceRequest request, RequestOptions options, public Cancellable stopWatchServiceAsync(StopWatchServiceRequest request, RequestOptions options,
ActionListener<AcknowledgedResponse> listener) { ActionListener<AcknowledgedResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity( return restHighLevelClient.performRequestAsyncAndParseEntity(
request, WatcherRequestConverters::stopWatchService, options, AcknowledgedResponse::fromXContent, listener, emptySet()); request, WatcherRequestConverters::stopWatchService, options, AcknowledgedResponse::fromXContent, listener, emptySet());
} }
@ -126,10 +128,11 @@ public final class WatcherClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void putWatchAsync(PutWatchRequest request, RequestOptions options, public Cancellable putWatchAsync(PutWatchRequest request, RequestOptions options,
ActionListener<PutWatchResponse> listener) { ActionListener<PutWatchResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::putWatch, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::putWatch, options,
PutWatchResponse::fromXContent, listener, emptySet()); PutWatchResponse::fromXContent, listener, emptySet());
} }
@ -154,10 +157,11 @@ public final class WatcherClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void getWatchAsync(GetWatchRequest request, RequestOptions options, public Cancellable getWatchAsync(GetWatchRequest request, RequestOptions options,
ActionListener<GetWatchResponse> listener) { ActionListener<GetWatchResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::getWatch, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::getWatch, options,
GetWatchResponse::fromXContent, listener, emptySet()); GetWatchResponse::fromXContent, listener, emptySet());
} }
@ -183,10 +187,11 @@ public final class WatcherClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deactivateWatchAsync(DeactivateWatchRequest request, RequestOptions options, public Cancellable deactivateWatchAsync(DeactivateWatchRequest request, RequestOptions options,
ActionListener<DeactivateWatchResponse> listener) { ActionListener<DeactivateWatchResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::deactivateWatch, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::deactivateWatch, options,
DeactivateWatchResponse::fromXContent, listener, emptySet()); DeactivateWatchResponse::fromXContent, listener, emptySet());
} }
@ -211,9 +216,10 @@ public final class WatcherClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void deleteWatchAsync(DeleteWatchRequest request, RequestOptions options, ActionListener<DeleteWatchResponse> listener) { public Cancellable deleteWatchAsync(DeleteWatchRequest request, RequestOptions options, ActionListener<DeleteWatchResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::deleteWatch, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::deleteWatch, options,
DeleteWatchResponse::fromXContent, listener, singleton(404)); DeleteWatchResponse::fromXContent, listener, singleton(404));
} }
@ -238,9 +244,10 @@ public final class WatcherClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon completion of the request * @param listener the listener to be notified upon completion of the request
* @return cancellable that may be used to cancel the request
*/ */
public void ackWatchAsync(AckWatchRequest request, RequestOptions options, ActionListener<AckWatchResponse> listener) { public Cancellable ackWatchAsync(AckWatchRequest request, RequestOptions options, ActionListener<AckWatchResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::ackWatch, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::ackWatch, options,
AckWatchResponse::fromXContent, listener, emptySet()); AckWatchResponse::fromXContent, listener, emptySet());
} }
@ -265,9 +272,11 @@ public final class WatcherClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void activateWatchAsync(ActivateWatchRequest request, RequestOptions options, ActionListener<ActivateWatchResponse> listener) { public Cancellable activateWatchAsync(ActivateWatchRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::activateWatch, options, ActionListener<ActivateWatchResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::activateWatch, options,
ActivateWatchResponse::fromXContent, listener, singleton(404)); ActivateWatchResponse::fromXContent, listener, singleton(404));
} }
@ -292,9 +301,11 @@ public final class WatcherClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notifed upon request completion * @param listener the listener to be notifed upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void executeWatchAsync(ExecuteWatchRequest request, RequestOptions options, ActionListener<ExecuteWatchResponse> listener) { public Cancellable executeWatchAsync(ExecuteWatchRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::executeWatch, options, ActionListener<ExecuteWatchResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::executeWatch, options,
ExecuteWatchResponse::fromXContent, listener, emptySet()); ExecuteWatchResponse::fromXContent, listener, emptySet());
} }
@ -319,9 +330,11 @@ public final class WatcherClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void watcherStatsAsync(WatcherStatsRequest request, RequestOptions options, ActionListener<WatcherStatsResponse> listener) { public Cancellable watcherStatsAsync(WatcherStatsRequest request, RequestOptions options,
restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::watcherStats, options, ActionListener<WatcherStatsResponse> listener) {
return restHighLevelClient.performRequestAsyncAndParseEntity(request, WatcherRequestConverters::watcherStats, options,
WatcherStatsResponse::fromXContent, listener, emptySet()); WatcherStatsResponse::fromXContent, listener, emptySet());
} }

12
client/rest-high-level/src/main/java/org/elasticsearch/client/XPackClient.java
View File

@ -67,10 +67,11 @@ public final class XPackClient {
* @param request the request * @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void infoAsync(XPackInfoRequest request, RequestOptions options, public Cancellable infoAsync(XPackInfoRequest request, RequestOptions options,
ActionListener<XPackInfoResponse> listener) { ActionListener<XPackInfoResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, XPackRequestConverters::info, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, XPackRequestConverters::info, options,
XPackInfoResponse::fromXContent, listener, emptySet()); XPackInfoResponse::fromXContent, listener, emptySet());
} }
@ -89,9 +90,10 @@ public final class XPackClient {
* Asynchronously fetch usage information about X-Pack features from the cluster. * Asynchronously fetch usage information about X-Pack features from the cluster.
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion * @param listener the listener to be notified upon request completion
* @return cancellable that may be used to cancel the request
*/ */
public void usageAsync(XPackUsageRequest request, RequestOptions options, ActionListener<XPackUsageResponse> listener) { public Cancellable usageAsync(XPackUsageRequest request, RequestOptions options, ActionListener<XPackUsageResponse> listener) {
restHighLevelClient.performRequestAsyncAndParseEntity(request, XPackRequestConverters::usage, options, return restHighLevelClient.performRequestAsyncAndParseEntity(request, XPackRequestConverters::usage, options,
XPackUsageResponse::fromXContent, listener, emptySet()); XPackUsageResponse::fromXContent, listener, emptySet());
} }
} }

2
client/rest-high-level/src/test/java/org/elasticsearch/client/RestHighLevelClientTests.java
View File

@ -900,7 +900,7 @@ public class RestHighLevelClientTests extends ESTestCase {
private static void assertAsyncMethod(Map<String, Set<Method>> methods, Method method, String apiName) { private static void assertAsyncMethod(Map<String, Set<Method>> methods, Method method, String apiName) {
assertTrue("async method [" + method.getName() + "] doesn't have corresponding sync method", assertTrue("async method [" + method.getName() + "] doesn't have corresponding sync method",
methods.containsKey(apiName.substring(0, apiName.length() - 6))); methods.containsKey(apiName.substring(0, apiName.length() - 6)));
assertThat("async method [" + method + "] should return void", method.getReturnType(), equalTo(Void.TYPE)); assertThat("async method [" + method + "] should return Cancellable", method.getReturnType(), equalTo(Cancellable.class));
assertEquals("async method [" + method + "] should not throw any exceptions", 0, method.getExceptionTypes().length); assertEquals("async method [" + method + "] should not throw any exceptions", 0, method.getExceptionTypes().length);
if (APIS_WITHOUT_REQUEST_OBJECT.contains(apiName.replaceAll("_async$", ""))) { if (APIS_WITHOUT_REQUEST_OBJECT.contains(apiName.replaceAll("_async$", ""))) {
assertEquals(2, method.getParameterTypes().length); assertEquals(2, method.getParameterTypes().length);