com.amazonaws.services.identitymanagement.AmazonIdentityManagementAsyncClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-iam Show documentation
/*
* Copyright 2010-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.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(new com.amazonaws.auth.DefaultAWSCredentialsProviderChain());
}
/**
* 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(new com.amazonaws.auth.DefaultAWSCredentialsProviderChain(),
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;
}
/**
* 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