com.amazonaws.services.redshiftserverless.AWSRedshiftServerlessAsyncClient Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aws-java-sdk-redshiftserverless Show documentation
Show all versions of aws-java-sdk-redshiftserverless Show documentation
The AWS Java SDK for Redshift Serverless module holds the client classes that are used for communicating with Redshift Serverless Service
/*
* Copyright 2019-2024 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.redshiftserverless;
import javax.annotation.Generated;
import com.amazonaws.services.redshiftserverless.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
import java.util.concurrent.ExecutorService;
/**
* Client for accessing Redshift Serverless 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.
*
*
* This is an interface reference for Amazon Redshift Serverless. It contains documentation for one of the programming
* or command line interfaces you can use to manage Amazon Redshift Serverless.
*
*
* Amazon Redshift Serverless automatically provisions data warehouse capacity and intelligently scales the underlying
* resources based on workload demands. Amazon Redshift Serverless adjusts capacity in seconds to deliver consistently
* high performance and simplified operations for even the most demanding and volatile workloads. Amazon Redshift
* Serverless lets you focus on using your data to acquire new insights for your business and customers.
*
*
* To learn more about Amazon Redshift Serverless, see What is Amazon Redshift
* Serverless.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSRedshiftServerlessAsyncClient extends AWSRedshiftServerlessClient implements AWSRedshiftServerlessAsync {
private static final int DEFAULT_THREAD_POOL_SIZE = 50;
private final java.util.concurrent.ExecutorService executorService;
public static AWSRedshiftServerlessAsyncClientBuilder asyncBuilder() {
return AWSRedshiftServerlessAsyncClientBuilder.standard();
}
/**
* Constructs a new asynchronous client to invoke service methods on Redshift Serverless using the specified
* parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AWSRedshiftServerlessAsyncClient(AwsAsyncClientParams asyncClientParams) {
this(asyncClientParams, false);
}
/**
* Constructs a new asynchronous client to invoke service methods on Redshift Serverless using the specified
* parameters.
*
* @param asyncClientParams
* Object providing client parameters.
* @param endpointDiscoveryEnabled
* true will enable endpoint discovery if the service supports it.
*/
AWSRedshiftServerlessAsyncClient(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 convertRecoveryPointToSnapshotAsync(ConvertRecoveryPointToSnapshotRequest request) {
return convertRecoveryPointToSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future convertRecoveryPointToSnapshotAsync(
final ConvertRecoveryPointToSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ConvertRecoveryPointToSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ConvertRecoveryPointToSnapshotResult call() throws Exception {
ConvertRecoveryPointToSnapshotResult result = null;
try {
result = executeConvertRecoveryPointToSnapshot(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 createCustomDomainAssociationAsync(CreateCustomDomainAssociationRequest request) {
return createCustomDomainAssociationAsync(request, null);
}
@Override
public java.util.concurrent.Future createCustomDomainAssociationAsync(
final CreateCustomDomainAssociationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateCustomDomainAssociationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateCustomDomainAssociationResult call() throws Exception {
CreateCustomDomainAssociationResult result = null;
try {
result = executeCreateCustomDomainAssociation(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 createEndpointAccessAsync(CreateEndpointAccessRequest request) {
return createEndpointAccessAsync(request, null);
}
@Override
public java.util.concurrent.Future createEndpointAccessAsync(final CreateEndpointAccessRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateEndpointAccessRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateEndpointAccessResult call() throws Exception {
CreateEndpointAccessResult result = null;
try {
result = executeCreateEndpointAccess(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 createNamespaceAsync(CreateNamespaceRequest request) {
return createNamespaceAsync(request, null);
}
@Override
public java.util.concurrent.Future createNamespaceAsync(final CreateNamespaceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateNamespaceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateNamespaceResult call() throws Exception {
CreateNamespaceResult result = null;
try {
result = executeCreateNamespace(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 createScheduledActionAsync(CreateScheduledActionRequest request) {
return createScheduledActionAsync(request, null);
}
@Override
public java.util.concurrent.Future createScheduledActionAsync(final CreateScheduledActionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateScheduledActionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateScheduledActionResult call() throws Exception {
CreateScheduledActionResult result = null;
try {
result = executeCreateScheduledAction(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 createSnapshotAsync(CreateSnapshotRequest request) {
return createSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future createSnapshotAsync(final CreateSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateSnapshotResult call() throws Exception {
CreateSnapshotResult result = null;
try {
result = executeCreateSnapshot(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 createSnapshotCopyConfigurationAsync(
CreateSnapshotCopyConfigurationRequest request) {
return createSnapshotCopyConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future createSnapshotCopyConfigurationAsync(
final CreateSnapshotCopyConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateSnapshotCopyConfigurationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateSnapshotCopyConfigurationResult call() throws Exception {
CreateSnapshotCopyConfigurationResult result = null;
try {
result = executeCreateSnapshotCopyConfiguration(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 createUsageLimitAsync(CreateUsageLimitRequest request) {
return createUsageLimitAsync(request, null);
}
@Override
public java.util.concurrent.Future createUsageLimitAsync(final CreateUsageLimitRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateUsageLimitRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateUsageLimitResult call() throws Exception {
CreateUsageLimitResult result = null;
try {
result = executeCreateUsageLimit(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 createWorkgroupAsync(CreateWorkgroupRequest request) {
return createWorkgroupAsync(request, null);
}
@Override
public java.util.concurrent.Future createWorkgroupAsync(final CreateWorkgroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateWorkgroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateWorkgroupResult call() throws Exception {
CreateWorkgroupResult result = null;
try {
result = executeCreateWorkgroup(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 deleteCustomDomainAssociationAsync(DeleteCustomDomainAssociationRequest request) {
return deleteCustomDomainAssociationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteCustomDomainAssociationAsync(
final DeleteCustomDomainAssociationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteCustomDomainAssociationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteCustomDomainAssociationResult call() throws Exception {
DeleteCustomDomainAssociationResult result = null;
try {
result = executeDeleteCustomDomainAssociation(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 deleteEndpointAccessAsync(DeleteEndpointAccessRequest request) {
return deleteEndpointAccessAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteEndpointAccessAsync(final DeleteEndpointAccessRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteEndpointAccessRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteEndpointAccessResult call() throws Exception {
DeleteEndpointAccessResult result = null;
try {
result = executeDeleteEndpointAccess(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 deleteNamespaceAsync(DeleteNamespaceRequest request) {
return deleteNamespaceAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteNamespaceAsync(final DeleteNamespaceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteNamespaceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteNamespaceResult call() throws Exception {
DeleteNamespaceResult result = null;
try {
result = executeDeleteNamespace(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 deleteResourcePolicyAsync(DeleteResourcePolicyRequest request) {
return deleteResourcePolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteResourcePolicyAsync(final DeleteResourcePolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteResourcePolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteResourcePolicyResult call() throws Exception {
DeleteResourcePolicyResult result = null;
try {
result = executeDeleteResourcePolicy(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 deleteScheduledActionAsync(DeleteScheduledActionRequest request) {
return deleteScheduledActionAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteScheduledActionAsync(final DeleteScheduledActionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteScheduledActionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteScheduledActionResult call() throws Exception {
DeleteScheduledActionResult result = null;
try {
result = executeDeleteScheduledAction(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 deleteSnapshotAsync(DeleteSnapshotRequest request) {
return deleteSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteSnapshotAsync(final DeleteSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteSnapshotResult call() throws Exception {
DeleteSnapshotResult result = null;
try {
result = executeDeleteSnapshot(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 deleteSnapshotCopyConfigurationAsync(
DeleteSnapshotCopyConfigurationRequest request) {
return deleteSnapshotCopyConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteSnapshotCopyConfigurationAsync(
final DeleteSnapshotCopyConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteSnapshotCopyConfigurationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteSnapshotCopyConfigurationResult call() throws Exception {
DeleteSnapshotCopyConfigurationResult result = null;
try {
result = executeDeleteSnapshotCopyConfiguration(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 deleteUsageLimitAsync(DeleteUsageLimitRequest request) {
return deleteUsageLimitAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUsageLimitAsync(final DeleteUsageLimitRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteUsageLimitRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUsageLimitResult call() throws Exception {
DeleteUsageLimitResult result = null;
try {
result = executeDeleteUsageLimit(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 deleteWorkgroupAsync(DeleteWorkgroupRequest request) {
return deleteWorkgroupAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteWorkgroupAsync(final DeleteWorkgroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteWorkgroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteWorkgroupResult call() throws Exception {
DeleteWorkgroupResult result = null;
try {
result = executeDeleteWorkgroup(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 getCredentialsAsync(GetCredentialsRequest request) {
return getCredentialsAsync(request, null);
}
@Override
public java.util.concurrent.Future getCredentialsAsync(final GetCredentialsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetCredentialsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetCredentialsResult call() throws Exception {
GetCredentialsResult result = null;
try {
result = executeGetCredentials(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 getCustomDomainAssociationAsync(GetCustomDomainAssociationRequest request) {
return getCustomDomainAssociationAsync(request, null);
}
@Override
public java.util.concurrent.Future getCustomDomainAssociationAsync(final GetCustomDomainAssociationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetCustomDomainAssociationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetCustomDomainAssociationResult call() throws Exception {
GetCustomDomainAssociationResult result = null;
try {
result = executeGetCustomDomainAssociation(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 getEndpointAccessAsync(GetEndpointAccessRequest request) {
return getEndpointAccessAsync(request, null);
}
@Override
public java.util.concurrent.Future getEndpointAccessAsync(final GetEndpointAccessRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetEndpointAccessRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetEndpointAccessResult call() throws Exception {
GetEndpointAccessResult result = null;
try {
result = executeGetEndpointAccess(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 getNamespaceAsync(GetNamespaceRequest request) {
return getNamespaceAsync(request, null);
}
@Override
public java.util.concurrent.Future getNamespaceAsync(final GetNamespaceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetNamespaceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetNamespaceResult call() throws Exception {
GetNamespaceResult result = null;
try {
result = executeGetNamespace(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 getRecoveryPointAsync(GetRecoveryPointRequest request) {
return getRecoveryPointAsync(request, null);
}
@Override
public java.util.concurrent.Future getRecoveryPointAsync(final GetRecoveryPointRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetRecoveryPointRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetRecoveryPointResult call() throws Exception {
GetRecoveryPointResult result = null;
try {
result = executeGetRecoveryPoint(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 getResourcePolicyAsync(GetResourcePolicyRequest request) {
return getResourcePolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future getResourcePolicyAsync(final GetResourcePolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetResourcePolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetResourcePolicyResult call() throws Exception {
GetResourcePolicyResult result = null;
try {
result = executeGetResourcePolicy(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 getScheduledActionAsync(GetScheduledActionRequest request) {
return getScheduledActionAsync(request, null);
}
@Override
public java.util.concurrent.Future getScheduledActionAsync(final GetScheduledActionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetScheduledActionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetScheduledActionResult call() throws Exception {
GetScheduledActionResult result = null;
try {
result = executeGetScheduledAction(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 getSnapshotAsync(GetSnapshotRequest request) {
return getSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future getSnapshotAsync(final GetSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetSnapshotResult call() throws Exception {
GetSnapshotResult result = null;
try {
result = executeGetSnapshot(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 getTableRestoreStatusAsync(GetTableRestoreStatusRequest request) {
return getTableRestoreStatusAsync(request, null);
}
@Override
public java.util.concurrent.Future getTableRestoreStatusAsync(final GetTableRestoreStatusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetTableRestoreStatusRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetTableRestoreStatusResult call() throws Exception {
GetTableRestoreStatusResult result = null;
try {
result = executeGetTableRestoreStatus(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 getUsageLimitAsync(GetUsageLimitRequest request) {
return getUsageLimitAsync(request, null);
}
@Override
public java.util.concurrent.Future getUsageLimitAsync(final GetUsageLimitRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetUsageLimitRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetUsageLimitResult call() throws Exception {
GetUsageLimitResult result = null;
try {
result = executeGetUsageLimit(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 getWorkgroupAsync(GetWorkgroupRequest request) {
return getWorkgroupAsync(request, null);
}
@Override
public java.util.concurrent.Future getWorkgroupAsync(final GetWorkgroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetWorkgroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetWorkgroupResult call() throws Exception {
GetWorkgroupResult result = null;
try {
result = executeGetWorkgroup(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 listCustomDomainAssociationsAsync(ListCustomDomainAssociationsRequest request) {
return listCustomDomainAssociationsAsync(request, null);
}
@Override
public java.util.concurrent.Future listCustomDomainAssociationsAsync(final ListCustomDomainAssociationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListCustomDomainAssociationsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListCustomDomainAssociationsResult call() throws Exception {
ListCustomDomainAssociationsResult result = null;
try {
result = executeListCustomDomainAssociations(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 listEndpointAccessAsync(ListEndpointAccessRequest request) {
return listEndpointAccessAsync(request, null);
}
@Override
public java.util.concurrent.Future listEndpointAccessAsync(final ListEndpointAccessRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListEndpointAccessRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListEndpointAccessResult call() throws Exception {
ListEndpointAccessResult result = null;
try {
result = executeListEndpointAccess(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 listNamespacesAsync(ListNamespacesRequest request) {
return listNamespacesAsync(request, null);
}
@Override
public java.util.concurrent.Future listNamespacesAsync(final ListNamespacesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListNamespacesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListNamespacesResult call() throws Exception {
ListNamespacesResult result = null;
try {
result = executeListNamespaces(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 listRecoveryPointsAsync(ListRecoveryPointsRequest request) {
return listRecoveryPointsAsync(request, null);
}
@Override
public java.util.concurrent.Future listRecoveryPointsAsync(final ListRecoveryPointsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListRecoveryPointsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListRecoveryPointsResult call() throws Exception {
ListRecoveryPointsResult result = null;
try {
result = executeListRecoveryPoints(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 listScheduledActionsAsync(ListScheduledActionsRequest request) {
return listScheduledActionsAsync(request, null);
}
@Override
public java.util.concurrent.Future listScheduledActionsAsync(final ListScheduledActionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListScheduledActionsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListScheduledActionsResult call() throws Exception {
ListScheduledActionsResult result = null;
try {
result = executeListScheduledActions(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 listSnapshotCopyConfigurationsAsync(ListSnapshotCopyConfigurationsRequest request) {
return listSnapshotCopyConfigurationsAsync(request, null);
}
@Override
public java.util.concurrent.Future listSnapshotCopyConfigurationsAsync(
final ListSnapshotCopyConfigurationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListSnapshotCopyConfigurationsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListSnapshotCopyConfigurationsResult call() throws Exception {
ListSnapshotCopyConfigurationsResult result = null;
try {
result = executeListSnapshotCopyConfigurations(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 listSnapshotsAsync(ListSnapshotsRequest request) {
return listSnapshotsAsync(request, null);
}
@Override
public java.util.concurrent.Future listSnapshotsAsync(final ListSnapshotsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListSnapshotsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListSnapshotsResult call() throws Exception {
ListSnapshotsResult result = null;
try {
result = executeListSnapshots(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 listTableRestoreStatusAsync(ListTableRestoreStatusRequest request) {
return listTableRestoreStatusAsync(request, null);
}
@Override
public java.util.concurrent.Future listTableRestoreStatusAsync(final ListTableRestoreStatusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListTableRestoreStatusRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListTableRestoreStatusResult call() throws Exception {
ListTableRestoreStatusResult result = null;
try {
result = executeListTableRestoreStatus(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 listTagsForResourceAsync(ListTagsForResourceRequest request) {
return listTagsForResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future listTagsForResourceAsync(final ListTagsForResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListTagsForResourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListTagsForResourceResult call() throws Exception {
ListTagsForResourceResult result = null;
try {
result = executeListTagsForResource(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 listUsageLimitsAsync(ListUsageLimitsRequest request) {
return listUsageLimitsAsync(request, null);
}
@Override
public java.util.concurrent.Future listUsageLimitsAsync(final ListUsageLimitsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListUsageLimitsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListUsageLimitsResult call() throws Exception {
ListUsageLimitsResult result = null;
try {
result = executeListUsageLimits(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 listWorkgroupsAsync(ListWorkgroupsRequest request) {
return listWorkgroupsAsync(request, null);
}
@Override
public java.util.concurrent.Future listWorkgroupsAsync(final ListWorkgroupsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListWorkgroupsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListWorkgroupsResult call() throws Exception {
ListWorkgroupsResult result = null;
try {
result = executeListWorkgroups(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 putResourcePolicyAsync(PutResourcePolicyRequest request) {
return putResourcePolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future putResourcePolicyAsync(final PutResourcePolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final PutResourcePolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public PutResourcePolicyResult call() throws Exception {
PutResourcePolicyResult result = null;
try {
result = executePutResourcePolicy(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 restoreFromRecoveryPointAsync(RestoreFromRecoveryPointRequest request) {
return restoreFromRecoveryPointAsync(request, null);
}
@Override
public java.util.concurrent.Future restoreFromRecoveryPointAsync(final RestoreFromRecoveryPointRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final RestoreFromRecoveryPointRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RestoreFromRecoveryPointResult call() throws Exception {
RestoreFromRecoveryPointResult result = null;
try {
result = executeRestoreFromRecoveryPoint(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 restoreFromSnapshotAsync(RestoreFromSnapshotRequest request) {
return restoreFromSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future restoreFromSnapshotAsync(final RestoreFromSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final RestoreFromSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RestoreFromSnapshotResult call() throws Exception {
RestoreFromSnapshotResult result = null;
try {
result = executeRestoreFromSnapshot(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 restoreTableFromRecoveryPointAsync(RestoreTableFromRecoveryPointRequest request) {
return restoreTableFromRecoveryPointAsync(request, null);
}
@Override
public java.util.concurrent.Future restoreTableFromRecoveryPointAsync(
final RestoreTableFromRecoveryPointRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final RestoreTableFromRecoveryPointRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RestoreTableFromRecoveryPointResult call() throws Exception {
RestoreTableFromRecoveryPointResult result = null;
try {
result = executeRestoreTableFromRecoveryPoint(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 restoreTableFromSnapshotAsync(RestoreTableFromSnapshotRequest request) {
return restoreTableFromSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future restoreTableFromSnapshotAsync(final RestoreTableFromSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final RestoreTableFromSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RestoreTableFromSnapshotResult call() throws Exception {
RestoreTableFromSnapshotResult result = null;
try {
result = executeRestoreTableFromSnapshot(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 tagResourceAsync(TagResourceRequest request) {
return tagResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future tagResourceAsync(final TagResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final TagResourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@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 untagResourceAsync(UntagResourceRequest request) {
return untagResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future untagResourceAsync(final UntagResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UntagResourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@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 updateCustomDomainAssociationAsync(UpdateCustomDomainAssociationRequest request) {
return updateCustomDomainAssociationAsync(request, null);
}
@Override
public java.util.concurrent.Future updateCustomDomainAssociationAsync(
final UpdateCustomDomainAssociationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateCustomDomainAssociationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateCustomDomainAssociationResult call() throws Exception {
UpdateCustomDomainAssociationResult result = null;
try {
result = executeUpdateCustomDomainAssociation(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 updateEndpointAccessAsync(UpdateEndpointAccessRequest request) {
return updateEndpointAccessAsync(request, null);
}
@Override
public java.util.concurrent.Future updateEndpointAccessAsync(final UpdateEndpointAccessRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateEndpointAccessRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateEndpointAccessResult call() throws Exception {
UpdateEndpointAccessResult result = null;
try {
result = executeUpdateEndpointAccess(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 updateNamespaceAsync(UpdateNamespaceRequest request) {
return updateNamespaceAsync(request, null);
}
@Override
public java.util.concurrent.Future updateNamespaceAsync(final UpdateNamespaceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateNamespaceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateNamespaceResult call() throws Exception {
UpdateNamespaceResult result = null;
try {
result = executeUpdateNamespace(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 updateScheduledActionAsync(UpdateScheduledActionRequest request) {
return updateScheduledActionAsync(request, null);
}
@Override
public java.util.concurrent.Future updateScheduledActionAsync(final UpdateScheduledActionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateScheduledActionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateScheduledActionResult call() throws Exception {
UpdateScheduledActionResult result = null;
try {
result = executeUpdateScheduledAction(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 updateSnapshotAsync(UpdateSnapshotRequest request) {
return updateSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future updateSnapshotAsync(final UpdateSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateSnapshotRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateSnapshotResult call() throws Exception {
UpdateSnapshotResult result = null;
try {
result = executeUpdateSnapshot(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 updateSnapshotCopyConfigurationAsync(
UpdateSnapshotCopyConfigurationRequest request) {
return updateSnapshotCopyConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future updateSnapshotCopyConfigurationAsync(
final UpdateSnapshotCopyConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateSnapshotCopyConfigurationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateSnapshotCopyConfigurationResult call() throws Exception {
UpdateSnapshotCopyConfigurationResult result = null;
try {
result = executeUpdateSnapshotCopyConfiguration(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 updateUsageLimitAsync(UpdateUsageLimitRequest request) {
return updateUsageLimitAsync(request, null);
}
@Override
public java.util.concurrent.Future updateUsageLimitAsync(final UpdateUsageLimitRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateUsageLimitRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateUsageLimitResult call() throws Exception {
UpdateUsageLimitResult result = null;
try {
result = executeUpdateUsageLimit(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 updateWorkgroupAsync(UpdateWorkgroupRequest request) {
return updateWorkgroupAsync(request, null);
}
@Override
public java.util.concurrent.Future updateWorkgroupAsync(final UpdateWorkgroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateWorkgroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateWorkgroupResult call() throws Exception {
UpdateWorkgroupResult result = null;
try {
result = executeUpdateWorkgroup(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();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy