com.amazonaws.services.identitymanagement.AmazonIdentityManagementAsyncClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-iam Show documentation
/*
* Copyright 2011-2016 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 com.amazonaws.services.identitymanagement.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
/**
* Interface 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.
*
* AWS Identity and Access Management
*
* AWS Identity and Access Management (IAM) is a web service that you can use to manage users and user permissions under
* your AWS account. This guide provides descriptions of IAM actions that you can call programmatically. For general
* information about IAM, see AWS Identity and Access Management (IAM). For the
* user guide for IAM, see Using IAM.
*
*
*
* AWS provides SDKs that consist of libraries and sample code for various programming languages and platforms (Java,
* Ruby, .NET, iOS, Android, etc.). The SDKs provide a convenient way to create programmatic access to IAM and AWS. For
* example, the SDKs take care of tasks such as cryptographically signing requests (see below), managing errors, and
* retrying requests automatically. For information about the AWS SDKs, including how to download and install them, see
* the Tools for Amazon Web Services page.
*
*
*
* We recommend that you use the AWS SDKs to make programmatic API calls to IAM. However, you can also use the IAM Query
* API to make direct calls to the IAM web service. To learn more about the IAM Query API, see Making Query Requests in the
* Using IAM guide. IAM supports GET and POST requests for all actions. That is, the API does not require you to
* use GET for some actions and POST for others. However, GET requests are subject to the limitation size of a URL.
* Therefore, for operations that require larger sizes, use a POST request.
*
*
* Signing Requests
*
*
* Requests must be signed using an access key ID and a secret access key. We strongly recommend that you do not use
* your AWS account access key ID and secret access key for everyday work with IAM. You can use the access key ID and
* secret access key for an IAM user or you can use the AWS Security Token Service to generate temporary security
* credentials and use those to sign requests.
*
*
* To sign requests, we recommend that you use Signature Version 4. If you have an
* existing application that uses Signature Version 2, you do not have to update it to use Signature Version 4. However,
* some operations now require Signature Version 4. The documentation for operations that require version 4 indicate
* this requirement.
*
*
* Additional Resources
*
*
* For more information, see the following:
*
*
* -
*
* AWS Security Credentials.
* This topic provides general information about the types of credentials used for accessing AWS.
*
*
* -
*
* IAM Best Practices. This topic
* presents a list of suggestions for using the IAM service to help secure your AWS resources.
*
*
* -
*
* Signing AWS API Requests.
* This set of topics walk you through the process of signing a request using an access key ID and secret access key.
*
*
*
*/
@ThreadSafe
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)
*/
public AmazonIdentityManagementAsyncClient() {
this(com.amazonaws.auth.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)
*/
public AmazonIdentityManagementAsyncClient(com.amazonaws.ClientConfiguration clientConfiguration) {
this(com.amazonaws.auth.DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration, java.util.concurrent.Executors
.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)
*/
public AmazonIdentityManagementAsyncClient(com.amazonaws.auth.AWSCredentials awsCredentials) {
this(awsCredentials, java.util.concurrent.Executors.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.
*/
public AmazonIdentityManagementAsyncClient(com.amazonaws.auth.AWSCredentials awsCredentials, java.util.concurrent.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.
*/
public AmazonIdentityManagementAsyncClient(com.amazonaws.auth.AWSCredentials awsCredentials, com.amazonaws.ClientConfiguration clientConfiguration,
java.util.concurrent.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)
*/
public AmazonIdentityManagementAsyncClient(com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, java.util.concurrent.Executors.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)
*/
public AmazonIdentityManagementAsyncClient(com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
com.amazonaws.ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, java.util.concurrent.Executors.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.
*/
public AmazonIdentityManagementAsyncClient(com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
java.util.concurrent.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.
*/
public AmazonIdentityManagementAsyncClient(com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
com.amazonaws.ClientConfiguration clientConfiguration, java.util.concurrent.ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on IAM using the specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AmazonIdentityManagementAsyncClient(AwsAsyncClientParams asyncClientParams) {
super(asyncClientParams);
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 java.util.concurrent.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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AddClientIDToOpenIDConnectProviderResult call() throws Exception {
AddClientIDToOpenIDConnectProviderResult result;
try {
result = addClientIDToOpenIDConnectProvider(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AddRoleToInstanceProfileResult call() throws Exception {
AddRoleToInstanceProfileResult result;
try {
result = addRoleToInstanceProfile(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AddUserToGroupResult call() throws Exception {
AddUserToGroupResult result;
try {
result = addUserToGroup(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachGroupPolicyResult call() throws Exception {
AttachGroupPolicyResult result;
try {
result = attachGroupPolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachRolePolicyResult call() throws Exception {
AttachRolePolicyResult result;
try {
result = attachRolePolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachUserPolicyResult call() throws Exception {
AttachUserPolicyResult result;
try {
result = attachUserPolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ChangePasswordResult call() throws Exception {
ChangePasswordResult result;
try {
result = changePassword(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateAccessKeyResult call() throws Exception {
CreateAccessKeyResult result;
try {
result = createAccessKey(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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)
*/
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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateAccountAliasResult call() throws Exception {
CreateAccountAliasResult result;
try {
result = createAccountAlias(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateGroupResult call() throws Exception {
CreateGroupResult result;
try {
result = createGroup(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateInstanceProfileResult call() throws Exception {
CreateInstanceProfileResult result;
try {
result = createInstanceProfile(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateLoginProfileResult call() throws Exception {
CreateLoginProfileResult result;
try {
result = createLoginProfile(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateOpenIDConnectProviderResult call() throws Exception {
CreateOpenIDConnectProviderResult result;
try {
result = createOpenIDConnectProvider(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreatePolicyResult call() throws Exception {
CreatePolicyResult result;
try {
result = createPolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreatePolicyVersionResult call() throws Exception {
CreatePolicyVersionResult result;
try {
result = createPolicyVersion(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateRoleResult call() throws Exception {
CreateRoleResult result;
try {
result = createRole(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateSAMLProviderResult call() throws Exception {
CreateSAMLProviderResult result;
try {
result = createSAMLProvider(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateUserResult call() throws Exception {
CreateUserResult result;
try {
result = createUser(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateVirtualMFADeviceResult call() throws Exception {
CreateVirtualMFADeviceResult result;
try {
result = createVirtualMFADevice(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeactivateMFADeviceResult call() throws Exception {
DeactivateMFADeviceResult result;
try {
result = deactivateMFADevice(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAccessKeyResult call() throws Exception {
DeleteAccessKeyResult result;
try {
result = deleteAccessKey(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAccountAliasResult call() throws Exception {
DeleteAccountAliasResult result;
try {
result = deleteAccountAlias(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAccountPasswordPolicyResult call() throws Exception {
DeleteAccountPasswordPolicyResult result;
try {
result = deleteAccountPasswordPolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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)
*/
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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteGroupResult call() throws Exception {
DeleteGroupResult result;
try {
result = deleteGroup(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteGroupPolicyResult call() throws Exception {
DeleteGroupPolicyResult result;
try {
result = deleteGroupPolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteInstanceProfileResult call() throws Exception {
DeleteInstanceProfileResult result;
try {
result = deleteInstanceProfile(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteLoginProfileResult call() throws Exception {
DeleteLoginProfileResult result;
try {
result = deleteLoginProfile(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteOpenIDConnectProviderResult call() throws Exception {
DeleteOpenIDConnectProviderResult result;
try {
result = deleteOpenIDConnectProvider(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeletePolicyResult call() throws Exception {
DeletePolicyResult result;
try {
result = deletePolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeletePolicyVersionResult call() throws Exception {
DeletePolicyVersionResult result;
try {
result = deletePolicyVersion(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteRoleResult call() throws Exception {
DeleteRoleResult result;
try {
result = deleteRole(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteRolePolicyResult call() throws Exception {
DeleteRolePolicyResult result;
try {
result = deleteRolePolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteSAMLProviderResult call() throws Exception {
DeleteSAMLProviderResult result;
try {
result = deleteSAMLProvider(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteSSHPublicKeyResult call() throws Exception {
DeleteSSHPublicKeyResult result;
try {
result = deleteSSHPublicKey(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteServerCertificateResult call() throws Exception {
DeleteServerCertificateResult result;
try {
result = deleteServerCertificate(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteSigningCertificateResult call() throws Exception {
DeleteSigningCertificateResult result;
try {
result = deleteSigningCertificate(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserResult call() throws Exception {
DeleteUserResult result;
try {
result = deleteUser(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserPolicyResult call() throws Exception {
DeleteUserPolicyResult result;
try {
result = deleteUserPolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteVirtualMFADeviceResult call() throws Exception {
DeleteVirtualMFADeviceResult result;
try {
result = deleteVirtualMFADevice(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DetachGroupPolicyResult call() throws Exception {
DetachGroupPolicyResult result;
try {
result = detachGroupPolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DetachRolePolicyResult call() throws Exception {
DetachRolePolicyResult result;
try {
result = detachRolePolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DetachUserPolicyResult call() throws Exception {
DetachUserPolicyResult result;
try {
result = detachUserPolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public EnableMFADeviceResult call() throws Exception {
EnableMFADeviceResult result;
try {
result = enableMFADevice(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GenerateCredentialReportResult call() throws Exception {
GenerateCredentialReportResult result;
try {
result = generateCredentialReport(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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)
*/
public java.util.concurrent.Future generateCredentialReportAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return generateCredentialReportAsync(new GenerateCredentialReportRequest(), asyncHandler);
}
@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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetAccessKeyLastUsedResult call() throws Exception {
GetAccessKeyLastUsedResult result;
try {
result = getAccessKeyLastUsed(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetAccountAuthorizationDetailsResult call() throws Exception {
GetAccountAuthorizationDetailsResult result;
try {
result = getAccountAuthorizationDetails(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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)
*/
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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetAccountPasswordPolicyResult call() throws Exception {
GetAccountPasswordPolicyResult result;
try {
result = getAccountPasswordPolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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)
*/
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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetAccountSummaryResult call() throws Exception {
GetAccountSummaryResult result;
try {
result = getAccountSummary(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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)
*/
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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetContextKeysForCustomPolicyResult call() throws Exception {
GetContextKeysForCustomPolicyResult result;
try {
result = getContextKeysForCustomPolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, 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) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetContextKeysForPrincipalPolicyResult call() throws Exception {
GetContextKeysForPrincipalPolicyResult result;
try {
result = getContextKeysForPrincipalPolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getCredentialReportAsync(GetCredentialReportRequest request) {
return getCredentialReportAsync(request, null);
}
@Override
public java.util.concurrent.Future getCredentialReportAsync(final GetCredentialReportRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetCredentialReportResult call() throws Exception {
GetCredentialReportResult result;
try {
result = getCredentialReport(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the GetCredentialReport operation.
*
* @see #getCredentialReportAsync(GetCredentialReportRequest)
*/
@Override
public java.util.concurrent.Future getCredentialReportAsync() {
return getCredentialReportAsync(new GetCredentialReportRequest());
}
/**
* Simplified method form for invoking the GetCredentialReport operation with an AsyncHandler.
*
* @see #getCredentialReportAsync(GetCredentialReportRequest, com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future getCredentialReportAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return getCredentialReportAsync(new GetCredentialReportRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future getGroupAsync(GetGroupRequest request) {
return getGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future getGroupAsync(final GetGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetGroupResult call() throws Exception {
GetGroupResult result;
try {
result = getGroup(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getGroupPolicyAsync(GetGroupPolicyRequest request) {
return getGroupPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future getGroupPolicyAsync(final GetGroupPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetGroupPolicyResult call() throws Exception {
GetGroupPolicyResult result;
try {
result = getGroupPolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getInstanceProfileAsync(GetInstanceProfileRequest request) {
return getInstanceProfileAsync(request, null);
}
@Override
public java.util.concurrent.Future getInstanceProfileAsync(final GetInstanceProfileRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetInstanceProfileResult call() throws Exception {
GetInstanceProfileResult result;
try {
result = getInstanceProfile(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getLoginProfileAsync(GetLoginProfileRequest request) {
return getLoginProfileAsync(request, null);
}
@Override
public java.util.concurrent.Future getLoginProfileAsync(final GetLoginProfileRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetLoginProfileResult call() throws Exception {
GetLoginProfileResult result;
try {
result = getLoginProfile(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getOpenIDConnectProviderAsync(GetOpenIDConnectProviderRequest request) {
return getOpenIDConnectProviderAsync(request, null);
}
@Override
public java.util.concurrent.Future getOpenIDConnectProviderAsync(final GetOpenIDConnectProviderRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetOpenIDConnectProviderResult call() throws Exception {
GetOpenIDConnectProviderResult result;
try {
result = getOpenIDConnectProvider(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getPolicyAsync(GetPolicyRequest request) {
return getPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future getPolicyAsync(final GetPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable