/*
* 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.identitymanagement;
import static java.util.concurrent.Executors.newFixedThreadPool;
import javax.annotation.Generated;
import com.amazonaws.services.identitymanagement.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.ClientConfiguration;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import java.util.concurrent.ExecutorService;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
/**
* Client for accessing IAM 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.
*
* Identity and Access Management
*
* Identity and Access Management (IAM) is a web service for securely controlling access to Amazon Web Services
* services. With IAM, you can centrally manage users, security credentials such as access keys, and permissions that
* control which Amazon Web Services resources users and applications can access. For more information about IAM, see Identity and Access Management (IAM) and the Identity and Access Management User Guide.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonIdentityManagementAsyncClient extends AmazonIdentityManagementClient implements AmazonIdentityManagementAsync {
private static final int DEFAULT_THREAD_POOL_SIZE = 50;
private final java.util.concurrent.ExecutorService executorService;
/**
* Constructs a new asynchronous client to invoke service methods on IAM. A credentials provider chain will be used
* that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
* Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
* maximum number of concurrent connections to the service).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AmazonIdentityManagementAsyncClientBuilder#defaultClient()}
*/
@Deprecated
public AmazonIdentityManagementAsyncClient() {
this(DefaultAWSCredentialsProviderChain.getInstance());
}
/**
* Constructs a new asynchronous client to invoke service methods on IAM. A credentials provider chain will be used
* that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
* Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the
* maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}.
*
* @param clientConfiguration
* The client configuration options controlling how this client connects to IAM (ex: proxy settings, retry
* counts, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AmazonIdentityManagementAsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonIdentityManagementAsyncClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on IAM using the specified AWS account
* credentials.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
* maximum number of concurrent connections to the service).
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AmazonIdentityManagementAsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AmazonIdentityManagementAsyncClient(AWSCredentials awsCredentials) {
this(awsCredentials, newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on IAM using the specified AWS account credentials
* and executor service. Default client settings will be used.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AmazonIdentityManagementAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonIdentityManagementAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonIdentityManagementAsyncClient(AWSCredentials awsCredentials, ExecutorService executorService) {
this(awsCredentials, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on IAM using the specified AWS account
* credentials, executor service, and client configuration options.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings, etc).
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AmazonIdentityManagementAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonIdentityManagementAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AmazonIdentityManagementAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonIdentityManagementAsyncClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentials, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on IAM using the specified AWS account credentials
* provider. Default client settings will be used.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
* maximum number of concurrent connections to the service).
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AmazonIdentityManagementAsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AmazonIdentityManagementAsyncClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on IAM using the provided AWS account credentials
* provider and client configuration options.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the
* maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AmazonIdentityManagementAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonIdentityManagementAsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonIdentityManagementAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on IAM using the specified AWS account credentials
* provider and executor service. Default client settings will be used.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AmazonIdentityManagementAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonIdentityManagementAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonIdentityManagementAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ExecutorService executorService) {
this(awsCredentialsProvider, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on IAM using the specified AWS account credentials
* provider, executor service, and client configuration options.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings, etc).
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AmazonIdentityManagementAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonIdentityManagementAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AmazonIdentityManagementAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AmazonIdentityManagementAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration,
ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
public static AmazonIdentityManagementAsyncClientBuilder asyncBuilder() {
return AmazonIdentityManagementAsyncClientBuilder.standard();
}
/**
* Constructs a new asynchronous client to invoke service methods on IAM using the specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AmazonIdentityManagementAsyncClient(AwsAsyncClientParams asyncClientParams) {
this(asyncClientParams, false);
}
/**
* Constructs a new asynchronous client to invoke service methods on IAM using the specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
* @param endpointDiscoveryEnabled
* true will enable endpoint discovery if the service supports it.
*/
AmazonIdentityManagementAsyncClient(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 addClientIDToOpenIDConnectProviderAsync(
AddClientIDToOpenIDConnectProviderRequest request) {
return addClientIDToOpenIDConnectProviderAsync(request, null);
}
@Override
public java.util.concurrent.Future addClientIDToOpenIDConnectProviderAsync(
final AddClientIDToOpenIDConnectProviderRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AddClientIDToOpenIDConnectProviderRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AddClientIDToOpenIDConnectProviderResult call() throws Exception {
AddClientIDToOpenIDConnectProviderResult result = null;
try {
result = executeAddClientIDToOpenIDConnectProvider(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 addRoleToInstanceProfileAsync(AddRoleToInstanceProfileRequest request) {
return addRoleToInstanceProfileAsync(request, null);
}
@Override
public java.util.concurrent.Future addRoleToInstanceProfileAsync(final AddRoleToInstanceProfileRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AddRoleToInstanceProfileRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AddRoleToInstanceProfileResult call() throws Exception {
AddRoleToInstanceProfileResult result = null;
try {
result = executeAddRoleToInstanceProfile(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 addUserToGroupAsync(AddUserToGroupRequest request) {
return addUserToGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future addUserToGroupAsync(final AddUserToGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AddUserToGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AddUserToGroupResult call() throws Exception {
AddUserToGroupResult result = null;
try {
result = executeAddUserToGroup(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 attachGroupPolicyAsync(AttachGroupPolicyRequest request) {
return attachGroupPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future attachGroupPolicyAsync(final AttachGroupPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AttachGroupPolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachGroupPolicyResult call() throws Exception {
AttachGroupPolicyResult result = null;
try {
result = executeAttachGroupPolicy(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 attachRolePolicyAsync(AttachRolePolicyRequest request) {
return attachRolePolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future attachRolePolicyAsync(final AttachRolePolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AttachRolePolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachRolePolicyResult call() throws Exception {
AttachRolePolicyResult result = null;
try {
result = executeAttachRolePolicy(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 attachUserPolicyAsync(AttachUserPolicyRequest request) {
return attachUserPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future attachUserPolicyAsync(final AttachUserPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AttachUserPolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachUserPolicyResult call() throws Exception {
AttachUserPolicyResult result = null;
try {
result = executeAttachUserPolicy(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 changePasswordAsync(ChangePasswordRequest request) {
return changePasswordAsync(request, null);
}
@Override
public java.util.concurrent.Future changePasswordAsync(final ChangePasswordRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ChangePasswordRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ChangePasswordResult call() throws Exception {
ChangePasswordResult result = null;
try {
result = executeChangePassword(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 createAccessKeyAsync(CreateAccessKeyRequest request) {
return createAccessKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future createAccessKeyAsync(final CreateAccessKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateAccessKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateAccessKeyResult call() throws Exception {
CreateAccessKeyResult result = null;
try {
result = executeCreateAccessKey(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the CreateAccessKey operation.
*
* @see #createAccessKeyAsync(CreateAccessKeyRequest)
*/
@Override
public java.util.concurrent.Future createAccessKeyAsync() {
return createAccessKeyAsync(new CreateAccessKeyRequest());
}
/**
* Simplified method form for invoking the CreateAccessKey operation with an AsyncHandler.
*
* @see #createAccessKeyAsync(CreateAccessKeyRequest, com.amazonaws.handlers.AsyncHandler)
*/
@Override
public java.util.concurrent.Future createAccessKeyAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return createAccessKeyAsync(new CreateAccessKeyRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future createAccountAliasAsync(CreateAccountAliasRequest request) {
return createAccountAliasAsync(request, null);
}
@Override
public java.util.concurrent.Future createAccountAliasAsync(final CreateAccountAliasRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateAccountAliasRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateAccountAliasResult call() throws Exception {
CreateAccountAliasResult result = null;
try {
result = executeCreateAccountAlias(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 createGroupAsync(CreateGroupRequest request) {
return createGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future createGroupAsync(final CreateGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateGroupResult call() throws Exception {
CreateGroupResult result = null;
try {
result = executeCreateGroup(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 createInstanceProfileAsync(CreateInstanceProfileRequest request) {
return createInstanceProfileAsync(request, null);
}
@Override
public java.util.concurrent.Future createInstanceProfileAsync(final CreateInstanceProfileRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateInstanceProfileRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateInstanceProfileResult call() throws Exception {
CreateInstanceProfileResult result = null;
try {
result = executeCreateInstanceProfile(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 createLoginProfileAsync(CreateLoginProfileRequest request) {
return createLoginProfileAsync(request, null);
}
@Override
public java.util.concurrent.Future createLoginProfileAsync(final CreateLoginProfileRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateLoginProfileRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateLoginProfileResult call() throws Exception {
CreateLoginProfileResult result = null;
try {
result = executeCreateLoginProfile(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 createOpenIDConnectProviderAsync(CreateOpenIDConnectProviderRequest request) {
return createOpenIDConnectProviderAsync(request, null);
}
@Override
public java.util.concurrent.Future createOpenIDConnectProviderAsync(final CreateOpenIDConnectProviderRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateOpenIDConnectProviderRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateOpenIDConnectProviderResult call() throws Exception {
CreateOpenIDConnectProviderResult result = null;
try {
result = executeCreateOpenIDConnectProvider(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 createPolicyAsync(CreatePolicyRequest request) {
return createPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future createPolicyAsync(final CreatePolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreatePolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreatePolicyResult call() throws Exception {
CreatePolicyResult result = null;
try {
result = executeCreatePolicy(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 createPolicyVersionAsync(CreatePolicyVersionRequest request) {
return createPolicyVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future createPolicyVersionAsync(final CreatePolicyVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreatePolicyVersionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreatePolicyVersionResult call() throws Exception {
CreatePolicyVersionResult result = null;
try {
result = executeCreatePolicyVersion(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 createRoleAsync(CreateRoleRequest request) {
return createRoleAsync(request, null);
}
@Override
public java.util.concurrent.Future createRoleAsync(final CreateRoleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateRoleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateRoleResult call() throws Exception {
CreateRoleResult result = null;
try {
result = executeCreateRole(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 createSAMLProviderAsync(CreateSAMLProviderRequest request) {
return createSAMLProviderAsync(request, null);
}
@Override
public java.util.concurrent.Future createSAMLProviderAsync(final CreateSAMLProviderRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateSAMLProviderRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateSAMLProviderResult call() throws Exception {
CreateSAMLProviderResult result = null;
try {
result = executeCreateSAMLProvider(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 createServiceLinkedRoleAsync(CreateServiceLinkedRoleRequest request) {
return createServiceLinkedRoleAsync(request, null);
}
@Override
public java.util.concurrent.Future createServiceLinkedRoleAsync(final CreateServiceLinkedRoleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateServiceLinkedRoleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateServiceLinkedRoleResult call() throws Exception {
CreateServiceLinkedRoleResult result = null;
try {
result = executeCreateServiceLinkedRole(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 createServiceSpecificCredentialAsync(
CreateServiceSpecificCredentialRequest request) {
return createServiceSpecificCredentialAsync(request, null);
}
@Override
public java.util.concurrent.Future createServiceSpecificCredentialAsync(
final CreateServiceSpecificCredentialRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateServiceSpecificCredentialRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateServiceSpecificCredentialResult call() throws Exception {
CreateServiceSpecificCredentialResult result = null;
try {
result = executeCreateServiceSpecificCredential(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 createUserAsync(CreateUserRequest request) {
return createUserAsync(request, null);
}
@Override
public java.util.concurrent.Future createUserAsync(final CreateUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateUserRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateUserResult call() throws Exception {
CreateUserResult result = null;
try {
result = executeCreateUser(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 createVirtualMFADeviceAsync(CreateVirtualMFADeviceRequest request) {
return createVirtualMFADeviceAsync(request, null);
}
@Override
public java.util.concurrent.Future createVirtualMFADeviceAsync(final CreateVirtualMFADeviceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateVirtualMFADeviceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateVirtualMFADeviceResult call() throws Exception {
CreateVirtualMFADeviceResult result = null;
try {
result = executeCreateVirtualMFADevice(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 deactivateMFADeviceAsync(DeactivateMFADeviceRequest request) {
return deactivateMFADeviceAsync(request, null);
}
@Override
public java.util.concurrent.Future deactivateMFADeviceAsync(final DeactivateMFADeviceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeactivateMFADeviceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeactivateMFADeviceResult call() throws Exception {
DeactivateMFADeviceResult result = null;
try {
result = executeDeactivateMFADevice(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 deleteAccessKeyAsync(DeleteAccessKeyRequest request) {
return deleteAccessKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteAccessKeyAsync(final DeleteAccessKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteAccessKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAccessKeyResult call() throws Exception {
DeleteAccessKeyResult result = null;
try {
result = executeDeleteAccessKey(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 deleteAccountAliasAsync(DeleteAccountAliasRequest request) {
return deleteAccountAliasAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteAccountAliasAsync(final DeleteAccountAliasRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteAccountAliasRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAccountAliasResult call() throws Exception {
DeleteAccountAliasResult result = null;
try {
result = executeDeleteAccountAlias(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 deleteAccountPasswordPolicyAsync(DeleteAccountPasswordPolicyRequest request) {
return deleteAccountPasswordPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteAccountPasswordPolicyAsync(final DeleteAccountPasswordPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteAccountPasswordPolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAccountPasswordPolicyResult call() throws Exception {
DeleteAccountPasswordPolicyResult result = null;
try {
result = executeDeleteAccountPasswordPolicy(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DeleteAccountPasswordPolicy operation.
*
* @see #deleteAccountPasswordPolicyAsync(DeleteAccountPasswordPolicyRequest)
*/
@Override
public java.util.concurrent.Future deleteAccountPasswordPolicyAsync() {
return deleteAccountPasswordPolicyAsync(new DeleteAccountPasswordPolicyRequest());
}
/**
* Simplified method form for invoking the DeleteAccountPasswordPolicy operation with an AsyncHandler.
*
* @see #deleteAccountPasswordPolicyAsync(DeleteAccountPasswordPolicyRequest, com.amazonaws.handlers.AsyncHandler)
*/
@Override
public java.util.concurrent.Future deleteAccountPasswordPolicyAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return deleteAccountPasswordPolicyAsync(new DeleteAccountPasswordPolicyRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future deleteGroupAsync(DeleteGroupRequest request) {
return deleteGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteGroupAsync(final DeleteGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteGroupResult call() throws Exception {
DeleteGroupResult result = null;
try {
result = executeDeleteGroup(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 deleteGroupPolicyAsync(DeleteGroupPolicyRequest request) {
return deleteGroupPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteGroupPolicyAsync(final DeleteGroupPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteGroupPolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteGroupPolicyResult call() throws Exception {
DeleteGroupPolicyResult result = null;
try {
result = executeDeleteGroupPolicy(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 deleteInstanceProfileAsync(DeleteInstanceProfileRequest request) {
return deleteInstanceProfileAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteInstanceProfileAsync(final DeleteInstanceProfileRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteInstanceProfileRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteInstanceProfileResult call() throws Exception {
DeleteInstanceProfileResult result = null;
try {
result = executeDeleteInstanceProfile(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 deleteLoginProfileAsync(DeleteLoginProfileRequest request) {
return deleteLoginProfileAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteLoginProfileAsync(final DeleteLoginProfileRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteLoginProfileRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteLoginProfileResult call() throws Exception {
DeleteLoginProfileResult result = null;
try {
result = executeDeleteLoginProfile(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 deleteOpenIDConnectProviderAsync(DeleteOpenIDConnectProviderRequest request) {
return deleteOpenIDConnectProviderAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteOpenIDConnectProviderAsync(final DeleteOpenIDConnectProviderRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteOpenIDConnectProviderRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteOpenIDConnectProviderResult call() throws Exception {
DeleteOpenIDConnectProviderResult result = null;
try {
result = executeDeleteOpenIDConnectProvider(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 deletePolicyAsync(DeletePolicyRequest request) {
return deletePolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future deletePolicyAsync(final DeletePolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeletePolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeletePolicyResult call() throws Exception {
DeletePolicyResult result = null;
try {
result = executeDeletePolicy(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 deletePolicyVersionAsync(DeletePolicyVersionRequest request) {
return deletePolicyVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future deletePolicyVersionAsync(final DeletePolicyVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeletePolicyVersionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeletePolicyVersionResult call() throws Exception {
DeletePolicyVersionResult result = null;
try {
result = executeDeletePolicyVersion(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 deleteRoleAsync(DeleteRoleRequest request) {
return deleteRoleAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteRoleAsync(final DeleteRoleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteRoleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteRoleResult call() throws Exception {
DeleteRoleResult result = null;
try {
result = executeDeleteRole(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 deleteRolePermissionsBoundaryAsync(DeleteRolePermissionsBoundaryRequest request) {
return deleteRolePermissionsBoundaryAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteRolePermissionsBoundaryAsync(
final DeleteRolePermissionsBoundaryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteRolePermissionsBoundaryRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteRolePermissionsBoundaryResult call() throws Exception {
DeleteRolePermissionsBoundaryResult result = null;
try {
result = executeDeleteRolePermissionsBoundary(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 deleteRolePolicyAsync(DeleteRolePolicyRequest request) {
return deleteRolePolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteRolePolicyAsync(final DeleteRolePolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteRolePolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteRolePolicyResult call() throws Exception {
DeleteRolePolicyResult result = null;
try {
result = executeDeleteRolePolicy(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 deleteSAMLProviderAsync(DeleteSAMLProviderRequest request) {
return deleteSAMLProviderAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteSAMLProviderAsync(final DeleteSAMLProviderRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteSAMLProviderRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteSAMLProviderResult call() throws Exception {
DeleteSAMLProviderResult result = null;
try {
result = executeDeleteSAMLProvider(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 deleteSSHPublicKeyAsync(DeleteSSHPublicKeyRequest request) {
return deleteSSHPublicKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteSSHPublicKeyAsync(final DeleteSSHPublicKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteSSHPublicKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteSSHPublicKeyResult call() throws Exception {
DeleteSSHPublicKeyResult result = null;
try {
result = executeDeleteSSHPublicKey(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 deleteServerCertificateAsync(DeleteServerCertificateRequest request) {
return deleteServerCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteServerCertificateAsync(final DeleteServerCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteServerCertificateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteServerCertificateResult call() throws Exception {
DeleteServerCertificateResult result = null;
try {
result = executeDeleteServerCertificate(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 deleteServiceLinkedRoleAsync(DeleteServiceLinkedRoleRequest request) {
return deleteServiceLinkedRoleAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteServiceLinkedRoleAsync(final DeleteServiceLinkedRoleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteServiceLinkedRoleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteServiceLinkedRoleResult call() throws Exception {
DeleteServiceLinkedRoleResult result = null;
try {
result = executeDeleteServiceLinkedRole(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 deleteServiceSpecificCredentialAsync(
DeleteServiceSpecificCredentialRequest request) {
return deleteServiceSpecificCredentialAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteServiceSpecificCredentialAsync(
final DeleteServiceSpecificCredentialRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteServiceSpecificCredentialRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteServiceSpecificCredentialResult call() throws Exception {
DeleteServiceSpecificCredentialResult result = null;
try {
result = executeDeleteServiceSpecificCredential(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 deleteSigningCertificateAsync(DeleteSigningCertificateRequest request) {
return deleteSigningCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteSigningCertificateAsync(final DeleteSigningCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteSigningCertificateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteSigningCertificateResult call() throws Exception {
DeleteSigningCertificateResult result = null;
try {
result = executeDeleteSigningCertificate(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 deleteUserAsync(DeleteUserRequest request) {
return deleteUserAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserAsync(final DeleteUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteUserRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserResult call() throws Exception {
DeleteUserResult result = null;
try {
result = executeDeleteUser(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 deleteUserPermissionsBoundaryAsync(DeleteUserPermissionsBoundaryRequest request) {
return deleteUserPermissionsBoundaryAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserPermissionsBoundaryAsync(
final DeleteUserPermissionsBoundaryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteUserPermissionsBoundaryRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserPermissionsBoundaryResult call() throws Exception {
DeleteUserPermissionsBoundaryResult result = null;
try {
result = executeDeleteUserPermissionsBoundary(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 deleteUserPolicyAsync(DeleteUserPolicyRequest request) {
return deleteUserPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserPolicyAsync(final DeleteUserPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteUserPolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserPolicyResult call() throws Exception {
DeleteUserPolicyResult result = null;
try {
result = executeDeleteUserPolicy(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 deleteVirtualMFADeviceAsync(DeleteVirtualMFADeviceRequest request) {
return deleteVirtualMFADeviceAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteVirtualMFADeviceAsync(final DeleteVirtualMFADeviceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteVirtualMFADeviceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteVirtualMFADeviceResult call() throws Exception {
DeleteVirtualMFADeviceResult result = null;
try {
result = executeDeleteVirtualMFADevice(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 detachGroupPolicyAsync(DetachGroupPolicyRequest request) {
return detachGroupPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future detachGroupPolicyAsync(final DetachGroupPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DetachGroupPolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DetachGroupPolicyResult call() throws Exception {
DetachGroupPolicyResult result = null;
try {
result = executeDetachGroupPolicy(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 detachRolePolicyAsync(DetachRolePolicyRequest request) {
return detachRolePolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future detachRolePolicyAsync(final DetachRolePolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DetachRolePolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DetachRolePolicyResult call() throws Exception {
DetachRolePolicyResult result = null;
try {
result = executeDetachRolePolicy(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 detachUserPolicyAsync(DetachUserPolicyRequest request) {
return detachUserPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future detachUserPolicyAsync(final DetachUserPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DetachUserPolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DetachUserPolicyResult call() throws Exception {
DetachUserPolicyResult result = null;
try {
result = executeDetachUserPolicy(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 enableMFADeviceAsync(EnableMFADeviceRequest request) {
return enableMFADeviceAsync(request, null);
}
@Override
public java.util.concurrent.Future enableMFADeviceAsync(final EnableMFADeviceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final EnableMFADeviceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public EnableMFADeviceResult call() throws Exception {
EnableMFADeviceResult result = null;
try {
result = executeEnableMFADevice(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 generateCredentialReportAsync(GenerateCredentialReportRequest request) {
return generateCredentialReportAsync(request, null);
}
@Override
public java.util.concurrent.Future generateCredentialReportAsync(final GenerateCredentialReportRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GenerateCredentialReportRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GenerateCredentialReportResult call() throws Exception {
GenerateCredentialReportResult result = null;
try {
result = executeGenerateCredentialReport(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the GenerateCredentialReport operation.
*
* @see #generateCredentialReportAsync(GenerateCredentialReportRequest)
*/
@Override
public java.util.concurrent.Future generateCredentialReportAsync() {
return generateCredentialReportAsync(new GenerateCredentialReportRequest());
}
/**
* Simplified method form for invoking the GenerateCredentialReport operation with an AsyncHandler.
*
* @see #generateCredentialReportAsync(GenerateCredentialReportRequest, com.amazonaws.handlers.AsyncHandler)
*/
@Override
public java.util.concurrent.Future generateCredentialReportAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return generateCredentialReportAsync(new GenerateCredentialReportRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future generateOrganizationsAccessReportAsync(
GenerateOrganizationsAccessReportRequest request) {
return generateOrganizationsAccessReportAsync(request, null);
}
@Override
public java.util.concurrent.Future generateOrganizationsAccessReportAsync(
final GenerateOrganizationsAccessReportRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GenerateOrganizationsAccessReportRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GenerateOrganizationsAccessReportResult call() throws Exception {
GenerateOrganizationsAccessReportResult result = null;
try {
result = executeGenerateOrganizationsAccessReport(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 generateServiceLastAccessedDetailsAsync(
GenerateServiceLastAccessedDetailsRequest request) {
return generateServiceLastAccessedDetailsAsync(request, null);
}
@Override
public java.util.concurrent.Future generateServiceLastAccessedDetailsAsync(
final GenerateServiceLastAccessedDetailsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GenerateServiceLastAccessedDetailsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GenerateServiceLastAccessedDetailsResult call() throws Exception {
GenerateServiceLastAccessedDetailsResult result = null;
try {
result = executeGenerateServiceLastAccessedDetails(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 getAccessKeyLastUsedAsync(GetAccessKeyLastUsedRequest request) {
return getAccessKeyLastUsedAsync(request, null);
}
@Override
public java.util.concurrent.Future getAccessKeyLastUsedAsync(final GetAccessKeyLastUsedRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetAccessKeyLastUsedRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetAccessKeyLastUsedResult call() throws Exception {
GetAccessKeyLastUsedResult result = null;
try {
result = executeGetAccessKeyLastUsed(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 getAccountAuthorizationDetailsAsync(GetAccountAuthorizationDetailsRequest request) {
return getAccountAuthorizationDetailsAsync(request, null);
}
@Override
public java.util.concurrent.Future getAccountAuthorizationDetailsAsync(
final GetAccountAuthorizationDetailsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetAccountAuthorizationDetailsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetAccountAuthorizationDetailsResult call() throws Exception {
GetAccountAuthorizationDetailsResult result = null;
try {
result = executeGetAccountAuthorizationDetails(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the GetAccountAuthorizationDetails operation.
*
* @see #getAccountAuthorizationDetailsAsync(GetAccountAuthorizationDetailsRequest)
*/
@Override
public java.util.concurrent.Future getAccountAuthorizationDetailsAsync() {
return getAccountAuthorizationDetailsAsync(new GetAccountAuthorizationDetailsRequest());
}
/**
* Simplified method form for invoking the GetAccountAuthorizationDetails operation with an AsyncHandler.
*
* @see #getAccountAuthorizationDetailsAsync(GetAccountAuthorizationDetailsRequest,
* com.amazonaws.handlers.AsyncHandler)
*/
@Override
public java.util.concurrent.Future getAccountAuthorizationDetailsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return getAccountAuthorizationDetailsAsync(new GetAccountAuthorizationDetailsRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future getAccountPasswordPolicyAsync(GetAccountPasswordPolicyRequest request) {
return getAccountPasswordPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future getAccountPasswordPolicyAsync(final GetAccountPasswordPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetAccountPasswordPolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetAccountPasswordPolicyResult call() throws Exception {
GetAccountPasswordPolicyResult result = null;
try {
result = executeGetAccountPasswordPolicy(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the GetAccountPasswordPolicy operation.
*
* @see #getAccountPasswordPolicyAsync(GetAccountPasswordPolicyRequest)
*/
@Override
public java.util.concurrent.Future getAccountPasswordPolicyAsync() {
return getAccountPasswordPolicyAsync(new GetAccountPasswordPolicyRequest());
}
/**
* Simplified method form for invoking the GetAccountPasswordPolicy operation with an AsyncHandler.
*
* @see #getAccountPasswordPolicyAsync(GetAccountPasswordPolicyRequest, com.amazonaws.handlers.AsyncHandler)
*/
@Override
public java.util.concurrent.Future getAccountPasswordPolicyAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return getAccountPasswordPolicyAsync(new GetAccountPasswordPolicyRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future getAccountSummaryAsync(GetAccountSummaryRequest request) {
return getAccountSummaryAsync(request, null);
}
@Override
public java.util.concurrent.Future getAccountSummaryAsync(final GetAccountSummaryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetAccountSummaryRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetAccountSummaryResult call() throws Exception {
GetAccountSummaryResult result = null;
try {
result = executeGetAccountSummary(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the GetAccountSummary operation.
*
* @see #getAccountSummaryAsync(GetAccountSummaryRequest)
*/
@Override
public java.util.concurrent.Future getAccountSummaryAsync() {
return getAccountSummaryAsync(new GetAccountSummaryRequest());
}
/**
* Simplified method form for invoking the GetAccountSummary operation with an AsyncHandler.
*
* @see #getAccountSummaryAsync(GetAccountSummaryRequest, com.amazonaws.handlers.AsyncHandler)
*/
@Override
public java.util.concurrent.Future getAccountSummaryAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return getAccountSummaryAsync(new GetAccountSummaryRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future getContextKeysForCustomPolicyAsync(GetContextKeysForCustomPolicyRequest request) {
return getContextKeysForCustomPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future getContextKeysForCustomPolicyAsync(
final GetContextKeysForCustomPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetContextKeysForCustomPolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetContextKeysForCustomPolicyResult call() throws Exception {
GetContextKeysForCustomPolicyResult result = null;
try {
result = executeGetContextKeysForCustomPolicy(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 getContextKeysForPrincipalPolicyAsync(
GetContextKeysForPrincipalPolicyRequest request) {
return getContextKeysForPrincipalPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future getContextKeysForPrincipalPolicyAsync(
final GetContextKeysForPrincipalPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetContextKeysForPrincipalPolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetContextKeysForPrincipalPolicyResult call() throws Exception {
GetContextKeysForPrincipalPolicyResult result = null;
try {
result = executeGetContextKeysForPrincipalPolicy(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 getCredentialReportAsync(GetCredentialReportRequest request) {
return getCredentialReportAsync(request, null);
}
@Override
public java.util.concurrent.Future