/* * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with * the License. A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions * and limitations under the License. */ package com.amazonaws.services.dax; import javax.annotation.Generated; import com.amazonaws.services.dax.model.*; import com.amazonaws.client.AwsAsyncClientParams; import com.amazonaws.annotation.ThreadSafe; import java.util.concurrent.ExecutorService; /** * Client for accessing Amazon DAX asynchronously. Each asynchronous method will return a Java Future object * representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to receive * notification when an asynchronous operation completes. * <p> * <p> * DAX is a managed caching service engineered for Amazon DynamoDB. DAX dramatically speeds up database reads by caching * frequently-accessed data from DynamoDB, so applications can access that data with sub-millisecond latency. You can * create a DAX cluster easily, using the AWS Management Console. With a few simple modifications to your code, your * application can begin taking advantage of the DAX cluster and realize significant improvements in read performance. * </p> */ @ThreadSafe @Generated("com.amazonaws:aws-java-sdk-code-generator") public class AmazonDaxAsyncClient extends AmazonDaxClient implements AmazonDaxAsync { private static final int DEFAULT_THREAD_POOL_SIZE = 50; private final java.util.concurrent.ExecutorService executorService; public static AmazonDaxAsyncClientBuilder asyncBuilder() { return AmazonDaxAsyncClientBuilder.standard(); } /** * Constructs a new asynchronous client to invoke service methods on Amazon DAX using the specified parameters. * * @param asyncClientParams * Object providing client parameters. */ AmazonDaxAsyncClient(AwsAsyncClientParams asyncClientParams) { this(asyncClientParams, false); } /** * Constructs a new asynchronous client to invoke service methods on Amazon DAX using the specified parameters. * * @param asyncClientParams * Object providing client parameters. * @param endpointDiscoveryEnabled * true will enable endpoint discovery if the service supports it. */ AmazonDaxAsyncClient(AwsAsyncClientParams asyncClientParams, boolean endpointDiscoveryEnabled) { super(asyncClientParams, endpointDiscoveryEnabled); this.executorService = asyncClientParams.getExecutor(); } /** * Returns the executor service used by this client to execute async requests. * * @return The executor service used by this client to execute async requests. */ public ExecutorService getExecutorService() { return executorService; } @Override public java.util.concurrent.Future<CreateClusterResult> createClusterAsync(CreateClusterRequest request) { return createClusterAsync(request, null); } @Override public java.util.concurrent.Future<CreateClusterResult> createClusterAsync(final CreateClusterRequest request, final com.amazonaws.handlers.AsyncHandler<CreateClusterRequest, CreateClusterResult> asyncHandler) { final CreateClusterRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<CreateClusterResult>() { @Override public CreateClusterResult call() throws Exception { CreateClusterResult result = null; try { result = executeCreateCluster(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<CreateParameterGroupResult> createParameterGroupAsync(CreateParameterGroupRequest request) { return createParameterGroupAsync(request, null); } @Override public java.util.concurrent.Future<CreateParameterGroupResult> createParameterGroupAsync(final CreateParameterGroupRequest request, final com.amazonaws.handlers.AsyncHandler<CreateParameterGroupRequest, CreateParameterGroupResult> asyncHandler) { final CreateParameterGroupRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<CreateParameterGroupResult>() { @Override public CreateParameterGroupResult call() throws Exception { CreateParameterGroupResult result = null; try { result = executeCreateParameterGroup(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<CreateSubnetGroupResult> createSubnetGroupAsync(CreateSubnetGroupRequest request) { return createSubnetGroupAsync(request, null); } @Override public java.util.concurrent.Future<CreateSubnetGroupResult> createSubnetGroupAsync(final CreateSubnetGroupRequest request, final com.amazonaws.handlers.AsyncHandler<CreateSubnetGroupRequest, CreateSubnetGroupResult> asyncHandler) { final CreateSubnetGroupRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<CreateSubnetGroupResult>() { @Override public CreateSubnetGroupResult call() throws Exception { CreateSubnetGroupResult result = null; try { result = executeCreateSubnetGroup(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<DecreaseReplicationFactorResult> decreaseReplicationFactorAsync(DecreaseReplicationFactorRequest request) { return decreaseReplicationFactorAsync(request, null); } @Override public java.util.concurrent.Future<DecreaseReplicationFactorResult> decreaseReplicationFactorAsync(final DecreaseReplicationFactorRequest request, final com.amazonaws.handlers.AsyncHandler<DecreaseReplicationFactorRequest, DecreaseReplicationFactorResult> asyncHandler) { final DecreaseReplicationFactorRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DecreaseReplicationFactorResult>() { @Override public DecreaseReplicationFactorResult call() throws Exception { DecreaseReplicationFactorResult result = null; try { result = executeDecreaseReplicationFactor(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<DeleteClusterResult> deleteClusterAsync(DeleteClusterRequest request) { return deleteClusterAsync(request, null); } @Override public java.util.concurrent.Future<DeleteClusterResult> deleteClusterAsync(final DeleteClusterRequest request, final com.amazonaws.handlers.AsyncHandler<DeleteClusterRequest, DeleteClusterResult> asyncHandler) { final DeleteClusterRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DeleteClusterResult>() { @Override public DeleteClusterResult call() throws Exception { DeleteClusterResult result = null; try { result = executeDeleteCluster(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<DeleteParameterGroupResult> deleteParameterGroupAsync(DeleteParameterGroupRequest request) { return deleteParameterGroupAsync(request, null); } @Override public java.util.concurrent.Future<DeleteParameterGroupResult> deleteParameterGroupAsync(final DeleteParameterGroupRequest request, final com.amazonaws.handlers.AsyncHandler<DeleteParameterGroupRequest, DeleteParameterGroupResult> asyncHandler) { final DeleteParameterGroupRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DeleteParameterGroupResult>() { @Override public DeleteParameterGroupResult call() throws Exception { DeleteParameterGroupResult result = null; try { result = executeDeleteParameterGroup(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<DeleteSubnetGroupResult> deleteSubnetGroupAsync(DeleteSubnetGroupRequest request) { return deleteSubnetGroupAsync(request, null); } @Override public java.util.concurrent.Future<DeleteSubnetGroupResult> deleteSubnetGroupAsync(final DeleteSubnetGroupRequest request, final com.amazonaws.handlers.AsyncHandler<DeleteSubnetGroupRequest, DeleteSubnetGroupResult> asyncHandler) { final DeleteSubnetGroupRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DeleteSubnetGroupResult>() { @Override public DeleteSubnetGroupResult call() throws Exception { DeleteSubnetGroupResult result = null; try { result = executeDeleteSubnetGroup(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<DescribeClustersResult> describeClustersAsync(DescribeClustersRequest request) { return describeClustersAsync(request, null); } @Override public java.util.concurrent.Future<DescribeClustersResult> describeClustersAsync(final DescribeClustersRequest request, final com.amazonaws.handlers.AsyncHandler<DescribeClustersRequest, DescribeClustersResult> asyncHandler) { final DescribeClustersRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DescribeClustersResult>() { @Override public DescribeClustersResult call() throws Exception { DescribeClustersResult result = null; try { result = executeDescribeClusters(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<DescribeDefaultParametersResult> describeDefaultParametersAsync(DescribeDefaultParametersRequest request) { return describeDefaultParametersAsync(request, null); } @Override public java.util.concurrent.Future<DescribeDefaultParametersResult> describeDefaultParametersAsync(final DescribeDefaultParametersRequest request, final com.amazonaws.handlers.AsyncHandler<DescribeDefaultParametersRequest, DescribeDefaultParametersResult> asyncHandler) { final DescribeDefaultParametersRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DescribeDefaultParametersResult>() { @Override public DescribeDefaultParametersResult call() throws Exception { DescribeDefaultParametersResult result = null; try { result = executeDescribeDefaultParameters(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<DescribeEventsResult> describeEventsAsync(DescribeEventsRequest request) { return describeEventsAsync(request, null); } @Override public java.util.concurrent.Future<DescribeEventsResult> describeEventsAsync(final DescribeEventsRequest request, final com.amazonaws.handlers.AsyncHandler<DescribeEventsRequest, DescribeEventsResult> asyncHandler) { final DescribeEventsRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DescribeEventsResult>() { @Override public DescribeEventsResult call() throws Exception { DescribeEventsResult result = null; try { result = executeDescribeEvents(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<DescribeParameterGroupsResult> describeParameterGroupsAsync(DescribeParameterGroupsRequest request) { return describeParameterGroupsAsync(request, null); } @Override public java.util.concurrent.Future<DescribeParameterGroupsResult> describeParameterGroupsAsync(final DescribeParameterGroupsRequest request, final com.amazonaws.handlers.AsyncHandler<DescribeParameterGroupsRequest, DescribeParameterGroupsResult> asyncHandler) { final DescribeParameterGroupsRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DescribeParameterGroupsResult>() { @Override public DescribeParameterGroupsResult call() throws Exception { DescribeParameterGroupsResult result = null; try { result = executeDescribeParameterGroups(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<DescribeParametersResult> describeParametersAsync(DescribeParametersRequest request) { return describeParametersAsync(request, null); } @Override public java.util.concurrent.Future<DescribeParametersResult> describeParametersAsync(final DescribeParametersRequest request, final com.amazonaws.handlers.AsyncHandler<DescribeParametersRequest, DescribeParametersResult> asyncHandler) { final DescribeParametersRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DescribeParametersResult>() { @Override public DescribeParametersResult call() throws Exception { DescribeParametersResult result = null; try { result = executeDescribeParameters(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<DescribeSubnetGroupsResult> describeSubnetGroupsAsync(DescribeSubnetGroupsRequest request) { return describeSubnetGroupsAsync(request, null); } @Override public java.util.concurrent.Future<DescribeSubnetGroupsResult> describeSubnetGroupsAsync(final DescribeSubnetGroupsRequest request, final com.amazonaws.handlers.AsyncHandler<DescribeSubnetGroupsRequest, DescribeSubnetGroupsResult> asyncHandler) { final DescribeSubnetGroupsRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DescribeSubnetGroupsResult>() { @Override public DescribeSubnetGroupsResult call() throws Exception { DescribeSubnetGroupsResult result = null; try { result = executeDescribeSubnetGroups(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<IncreaseReplicationFactorResult> increaseReplicationFactorAsync(IncreaseReplicationFactorRequest request) { return increaseReplicationFactorAsync(request, null); } @Override public java.util.concurrent.Future<IncreaseReplicationFactorResult> increaseReplicationFactorAsync(final IncreaseReplicationFactorRequest request, final com.amazonaws.handlers.AsyncHandler<IncreaseReplicationFactorRequest, IncreaseReplicationFactorResult> asyncHandler) { final IncreaseReplicationFactorRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<IncreaseReplicationFactorResult>() { @Override public IncreaseReplicationFactorResult call() throws Exception { IncreaseReplicationFactorResult result = null; try { result = executeIncreaseReplicationFactor(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<ListTagsResult> listTagsAsync(ListTagsRequest request) { return listTagsAsync(request, null); } @Override public java.util.concurrent.Future<ListTagsResult> listTagsAsync(final ListTagsRequest request, final com.amazonaws.handlers.AsyncHandler<ListTagsRequest, ListTagsResult> asyncHandler) { final ListTagsRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<ListTagsResult>() { @Override public ListTagsResult call() throws Exception { ListTagsResult result = null; try { result = executeListTags(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<RebootNodeResult> rebootNodeAsync(RebootNodeRequest request) { return rebootNodeAsync(request, null); } @Override public java.util.concurrent.Future<RebootNodeResult> rebootNodeAsync(final RebootNodeRequest request, final com.amazonaws.handlers.AsyncHandler<RebootNodeRequest, RebootNodeResult> asyncHandler) { final RebootNodeRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<RebootNodeResult>() { @Override public RebootNodeResult call() throws Exception { RebootNodeResult result = null; try { result = executeRebootNode(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<TagResourceResult> tagResourceAsync(TagResourceRequest request) { return tagResourceAsync(request, null); } @Override public java.util.concurrent.Future<TagResourceResult> tagResourceAsync(final TagResourceRequest request, final com.amazonaws.handlers.AsyncHandler<TagResourceRequest, TagResourceResult> asyncHandler) { final TagResourceRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<TagResourceResult>() { @Override public TagResourceResult call() throws Exception { TagResourceResult result = null; try { result = executeTagResource(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<UntagResourceResult> untagResourceAsync(UntagResourceRequest request) { return untagResourceAsync(request, null); } @Override public java.util.concurrent.Future<UntagResourceResult> untagResourceAsync(final UntagResourceRequest request, final com.amazonaws.handlers.AsyncHandler<UntagResourceRequest, UntagResourceResult> asyncHandler) { final UntagResourceRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<UntagResourceResult>() { @Override public UntagResourceResult call() throws Exception { UntagResourceResult result = null; try { result = executeUntagResource(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<UpdateClusterResult> updateClusterAsync(UpdateClusterRequest request) { return updateClusterAsync(request, null); } @Override public java.util.concurrent.Future<UpdateClusterResult> updateClusterAsync(final UpdateClusterRequest request, final com.amazonaws.handlers.AsyncHandler<UpdateClusterRequest, UpdateClusterResult> asyncHandler) { final UpdateClusterRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<UpdateClusterResult>() { @Override public UpdateClusterResult call() throws Exception { UpdateClusterResult result = null; try { result = executeUpdateCluster(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<UpdateParameterGroupResult> updateParameterGroupAsync(UpdateParameterGroupRequest request) { return updateParameterGroupAsync(request, null); } @Override public java.util.concurrent.Future<UpdateParameterGroupResult> updateParameterGroupAsync(final UpdateParameterGroupRequest request, final com.amazonaws.handlers.AsyncHandler<UpdateParameterGroupRequest, UpdateParameterGroupResult> asyncHandler) { final UpdateParameterGroupRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<UpdateParameterGroupResult>() { @Override public UpdateParameterGroupResult call() throws Exception { UpdateParameterGroupResult result = null; try { result = executeUpdateParameterGroup(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } @Override public java.util.concurrent.Future<UpdateSubnetGroupResult> updateSubnetGroupAsync(UpdateSubnetGroupRequest request) { return updateSubnetGroupAsync(request, null); } @Override public java.util.concurrent.Future<UpdateSubnetGroupResult> updateSubnetGroupAsync(final UpdateSubnetGroupRequest request, final com.amazonaws.handlers.AsyncHandler<UpdateSubnetGroupRequest, UpdateSubnetGroupResult> asyncHandler) { final UpdateSubnetGroupRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<UpdateSubnetGroupResult>() { @Override public UpdateSubnetGroupResult call() throws Exception { UpdateSubnetGroupResult result = null; try { result = executeUpdateSubnetGroup(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } /** * Shuts down the client, releasing all managed resources. This includes forcibly terminating all pending * asynchronous service calls. Clients who wish to give pending asynchronous service calls time to complete should * call {@code getExecutorService().shutdown()} followed by {@code getExecutorService().awaitTermination()} prior to * calling this method. */ @Override public void shutdown() { super.shutdown(); executorService.shutdownNow(); } }