/*
* Copyright 2010-2012 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 java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.handlers.AsyncHandler;
import com.amazonaws.ClientConfiguration;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.services.identitymanagement.model.*;
/**
* Asynchronous client for accessing AmazonIdentityManagement.
* All asynchronous calls made using this client are non-blocking. Callers could either
* process the result and handle the exceptions in the worker thread by providing a callback handler
* when making the call, or use the returned Future object to check the result of the call in the calling thread.
* AWS Identity and Access Management <p>
* This guide provides descriptions of the Identity and Access Management (IAM) API as well as links to related content in the guide, <a
* href="http://docs.amazonwebservices.com/IAM/latest/UserGuide/"> Using IAM </a> .
* </p>
* <p>
* IAM is a web service that enables AWS customers to manage users and user permissions under their AWS account. For more information about this product
* go to <a href="http://aws.amazon.com/iam/"> AWS Identity and Access Management (IAM) </a> . For information about setting up signatures and
* authorization through the API, go to <a href="http://docs.amazonwebservices.com/general/latest/gr/signing_aws_api_requests.html"> Signing AWS API
* Requests </a> in the <i>AWS General Reference</i> . For general information about using the Query API with IAM, go to <a
* href="http://docs.amazonwebservices.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html"> Making Query Requests </a> in <i>Using IAM</i> .
* </p>
* <p>
* If you're new to AWS and need additional technical information about a specific AWS product, you can find the product's technical documentation at <a
* href="http://aws.amazon.com/documentation/"> http://aws.amazon.com/documentation/ </a> .
* </p>
*/
public class AmazonIdentityManagementAsyncClient extends AmazonIdentityManagementClient
implements AmazonIdentityManagementAsync {
/**
* Executor service for executing asynchronous requests.
*/
private ExecutorService executorService;
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonIdentityManagement. A credentials provider chain will be used
* that searches for credentials in this order:
* <ul>
* <li> Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY </li>
* <li> Java System Properties - aws.accessKeyId and aws.secretKey </li>
* <li> Instance profile credentials delivered through the Amazon EC2 metadata service </li>
* </ul>
*
* <p>
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @see DefaultAWSCredentialsProvider
*/
public AmazonIdentityManagementAsyncClient() {
this(new DefaultAWSCredentialsProviderChain());
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonIdentityManagement. A credentials provider chain will be used
* that searches for credentials in this order:
* <ul>
* <li> Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY </li>
* <li> Java System Properties - aws.accessKeyId and aws.secretKey </li>
* <li> Instance profile credentials delivered through the Amazon EC2 metadata service </li>
* </ul>
*
* <p>
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @param clientConfiguration The client configuration options controlling how this
* client connects to AmazonIdentityManagement
* (ex: proxy settings, retry counts, etc.).
*
* @see DefaultAWSCredentialsProvider
*/
public AmazonIdentityManagementAsyncClient(ClientConfiguration clientConfiguration) {
this(new DefaultAWSCredentialsProviderChain(), clientConfiguration, Executors.newCachedThreadPool());
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonIdentityManagement using the specified AWS account credentials.
* Default client settings will be used, and a default cached thread pool will be
* created for executing the asynchronous tasks.
*
* <p>
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentials The AWS credentials (access key ID and secret key) to use
* when authenticating with AWS services.
*/
public AmazonIdentityManagementAsyncClient(AWSCredentials awsCredentials) {
this(awsCredentials, Executors.newCachedThreadPool());
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonIdentityManagement using the specified AWS account credentials
* and executor service. Default client settings will be used.
*
* <p>
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @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(AWSCredentials awsCredentials, ExecutorService executorService) {
super(awsCredentials);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonIdentityManagement using the specified AWS account credentials,
* executor service, and client configuration options.
*
* <p>
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @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(AWSCredentials awsCredentials,
ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentials, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonIdentityManagement using the specified AWS account credentials provider.
* Default client settings will be used, and a default cached thread pool will be
* created for executing the asynchronous tasks.
*
* <p>
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials
* to authenticate requests with AWS services.
*/
public AmazonIdentityManagementAsyncClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, Executors.newCachedThreadPool());
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonIdentityManagement using the specified AWS account credentials provider
* and executor service. Default client settings will be used.
*
* <p>
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @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(AWSCredentialsProvider awsCredentialsProvider, ExecutorService executorService) {
this(awsCredentialsProvider, new ClientConfiguration(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonIdentityManagement using the specified AWS account credentials
* provider, executor service, and client configuration options.
*
* <p>
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @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(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
/**
* Returns the executor service used by this async client to execute
* requests.
*
* @return The executor service used by this async client to execute
* requests.
*/
public ExecutorService getExecutorService() {
return executorService;
}
/**
* Shuts down the client, releasing all managed resources. This includes
* forcibly terminating all pending asynchronous service calls. Clients who
* wish to give pending asynchronous service calls time to complete should
* call getExecutorService().shutdown() prior to calling this method.
*/
@Override
public void shutdown() {
super.shutdown();
executorService.shutdownNow();
}
/**
* <p>
* Deletes the specified AWS account alias. For information about using
* an AWS account alias, see <a
* ://docs.amazonwebservices.com/IAM/latest/UserGuide/AccountAlias.html">
* Using an Alias for Your AWS Account ID </a> in <i>Using AWS Identity
* and Access Management</i> .
* </p>
*
* @param deleteAccountAliasRequest Container for the necessary
* parameters to execute the DeleteAccountAlias operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* DeleteAccountAlias service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteAccountAliasAsync(final DeleteAccountAliasRequest deleteAccountAliasRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
deleteAccountAlias(deleteAccountAliasRequest);
return null;
}
});
}
/**
* <p>
* Deletes the specified AWS account alias. For information about using
* an AWS account alias, see <a
* ://docs.amazonwebservices.com/IAM/latest/UserGuide/AccountAlias.html">
* Using an Alias for Your AWS Account ID </a> in <i>Using AWS Identity
* and Access Management</i> .
* </p>
*
* @param deleteAccountAliasRequest Container for the necessary
* parameters to execute the DeleteAccountAlias operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteAccountAlias service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteAccountAliasAsync(
final DeleteAccountAliasRequest deleteAccountAliasRequest,
final AsyncHandler<DeleteAccountAliasRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
deleteAccountAlias(deleteAccountAliasRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteAccountAliasRequest, null);
return null;
}
});
}
/**
* <p>
* Lists the groups that have the specified path prefix.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listGroupsRequest Container for the necessary parameters to
* execute the ListGroups operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ListGroups service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListGroupsResult> listGroupsAsync(final ListGroupsRequest listGroupsRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListGroupsResult>() {
public ListGroupsResult call() throws Exception {
return listGroups(listGroupsRequest);
}
});
}
/**
* <p>
* Lists the groups that have the specified path prefix.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listGroupsRequest Container for the necessary parameters to
* execute the ListGroups operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListGroups service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListGroupsResult> listGroupsAsync(
final ListGroupsRequest listGroupsRequest,
final AsyncHandler<ListGroupsRequest, ListGroupsResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListGroupsResult>() {
public ListGroupsResult call() throws Exception {
ListGroupsResult result;
try {
result = listGroups(listGroupsRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listGroupsRequest, result);
return result;
}
});
}
/**
* <p>
* Deletes the access key associated with the specified user.
* </p>
* <p>
* If you do not specify a user name, IAM determines the user name
* implicitly based on the AWS Access Key ID signing the request. Because
* this action works for access keys under the AWS account, you can use
* this API to manage root credentials even if the AWS account has no
* associated users.
* </p>
*
* @param deleteAccessKeyRequest Container for the necessary parameters
* to execute the DeleteAccessKey operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* DeleteAccessKey service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteAccessKeyAsync(final DeleteAccessKeyRequest deleteAccessKeyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
deleteAccessKey(deleteAccessKeyRequest);
return null;
}
});
}
/**
* <p>
* Deletes the access key associated with the specified user.
* </p>
* <p>
* If you do not specify a user name, IAM determines the user name
* implicitly based on the AWS Access Key ID signing the request. Because
* this action works for access keys under the AWS account, you can use
* this API to manage root credentials even if the AWS account has no
* associated users.
* </p>
*
* @param deleteAccessKeyRequest Container for the necessary parameters
* to execute the DeleteAccessKey operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteAccessKey service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteAccessKeyAsync(
final DeleteAccessKeyRequest deleteAccessKeyRequest,
final AsyncHandler<DeleteAccessKeyRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
deleteAccessKey(deleteAccessKeyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteAccessKeyRequest, null);
return null;
}
});
}
/**
* <p>
* Deletes a virtual MFA device.
* </p>
* <p>
* <b>NOTE:</b>You must deactivate a user's virtual MFA device before you
* can delete it. For information about deactivating MFA devices, see
* DeactivateMFADevice.
* </p>
*
* @param deleteVirtualMFADeviceRequest Container for the necessary
* parameters to execute the DeleteVirtualMFADevice operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* DeleteVirtualMFADevice service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteVirtualMFADeviceAsync(final DeleteVirtualMFADeviceRequest deleteVirtualMFADeviceRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
deleteVirtualMFADevice(deleteVirtualMFADeviceRequest);
return null;
}
});
}
/**
* <p>
* Deletes a virtual MFA device.
* </p>
* <p>
* <b>NOTE:</b>You must deactivate a user's virtual MFA device before you
* can delete it. For information about deactivating MFA devices, see
* DeactivateMFADevice.
* </p>
*
* @param deleteVirtualMFADeviceRequest Container for the necessary
* parameters to execute the DeleteVirtualMFADevice operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteVirtualMFADevice service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteVirtualMFADeviceAsync(
final DeleteVirtualMFADeviceRequest deleteVirtualMFADeviceRequest,
final AsyncHandler<DeleteVirtualMFADeviceRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
deleteVirtualMFADevice(deleteVirtualMFADeviceRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteVirtualMFADeviceRequest, null);
return null;
}
});
}
/**
* <p>
* Deletes the specified policy associated with the specified user.
* </p>
*
* @param deleteUserPolicyRequest Container for the necessary parameters
* to execute the DeleteUserPolicy operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* DeleteUserPolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteUserPolicyAsync(final DeleteUserPolicyRequest deleteUserPolicyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
deleteUserPolicy(deleteUserPolicyRequest);
return null;
}
});
}
/**
* <p>
* Deletes the specified policy associated with the specified user.
* </p>
*
* @param deleteUserPolicyRequest Container for the necessary parameters
* to execute the DeleteUserPolicy operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteUserPolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteUserPolicyAsync(
final DeleteUserPolicyRequest deleteUserPolicyRequest,
final AsyncHandler<DeleteUserPolicyRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
deleteUserPolicy(deleteUserPolicyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteUserPolicyRequest, null);
return null;
}
});
}
/**
* <p>
* Adds (or updates) a policy document associated with the specified
* user. For information about policies, refer to <a
* ebservices.com/IAM/latest/UserGuide/index.html?PoliciesOverview.html">
* Overview of Policies </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* For information about limits on the number of policies you can
* associate with a user, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* <b>NOTE:</b>Because policy documents can be large, you should use POST
* rather than GET when calling PutUserPolicy. For information about
* setting up signatures and authorization through the API, go to Signing
* AWS API Requests in the AWS General Reference. For general information
* about using the Query API with IAM, go to Making Query Requests in
* Using IAM.
* </p>
*
* @param putUserPolicyRequest Container for the necessary parameters to
* execute the PutUserPolicy operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* PutUserPolicy service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> putUserPolicyAsync(final PutUserPolicyRequest putUserPolicyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
putUserPolicy(putUserPolicyRequest);
return null;
}
});
}
/**
* <p>
* Adds (or updates) a policy document associated with the specified
* user. For information about policies, refer to <a
* ebservices.com/IAM/latest/UserGuide/index.html?PoliciesOverview.html">
* Overview of Policies </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* For information about limits on the number of policies you can
* associate with a user, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* <b>NOTE:</b>Because policy documents can be large, you should use POST
* rather than GET when calling PutUserPolicy. For information about
* setting up signatures and authorization through the API, go to Signing
* AWS API Requests in the AWS General Reference. For general information
* about using the Query API with IAM, go to Making Query Requests in
* Using IAM.
* </p>
*
* @param putUserPolicyRequest Container for the necessary parameters to
* execute the PutUserPolicy operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* PutUserPolicy service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> putUserPolicyAsync(
final PutUserPolicyRequest putUserPolicyRequest,
final AsyncHandler<PutUserPolicyRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
putUserPolicy(putUserPolicyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(putUserPolicyRequest, null);
return null;
}
});
}
/**
* <p>
* Lists the server certificates that have the specified path prefix. If
* none exist, the action returns an empty list.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listServerCertificatesRequest Container for the necessary
* parameters to execute the ListServerCertificates operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ListServerCertificates service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListServerCertificatesResult> listServerCertificatesAsync(final ListServerCertificatesRequest listServerCertificatesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListServerCertificatesResult>() {
public ListServerCertificatesResult call() throws Exception {
return listServerCertificates(listServerCertificatesRequest);
}
});
}
/**
* <p>
* Lists the server certificates that have the specified path prefix. If
* none exist, the action returns an empty list.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listServerCertificatesRequest Container for the necessary
* parameters to execute the ListServerCertificates operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListServerCertificates service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListServerCertificatesResult> listServerCertificatesAsync(
final ListServerCertificatesRequest listServerCertificatesRequest,
final AsyncHandler<ListServerCertificatesRequest, ListServerCertificatesResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListServerCertificatesResult>() {
public ListServerCertificatesResult call() throws Exception {
ListServerCertificatesResult result;
try {
result = listServerCertificates(listServerCertificatesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listServerCertificatesRequest, result);
return result;
}
});
}
/**
* <p>
* Retrieves the specified policy document for the specified user. The
* returned policy is URL-encoded according to RFC 3986. For more
* information about RFC 3986, go to <a
* href="http://www.faqs.org/rfcs/rfc3986.html">
* http://www.faqs.org/rfcs/rfc3986.html </a> .
* </p>
*
* @param getUserPolicyRequest Container for the necessary parameters to
* execute the GetUserPolicy operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* GetUserPolicy service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetUserPolicyResult> getUserPolicyAsync(final GetUserPolicyRequest getUserPolicyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetUserPolicyResult>() {
public GetUserPolicyResult call() throws Exception {
return getUserPolicy(getUserPolicyRequest);
}
});
}
/**
* <p>
* Retrieves the specified policy document for the specified user. The
* returned policy is URL-encoded according to RFC 3986. For more
* information about RFC 3986, go to <a
* href="http://www.faqs.org/rfcs/rfc3986.html">
* http://www.faqs.org/rfcs/rfc3986.html </a> .
* </p>
*
* @param getUserPolicyRequest Container for the necessary parameters to
* execute the GetUserPolicy operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetUserPolicy service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetUserPolicyResult> getUserPolicyAsync(
final GetUserPolicyRequest getUserPolicyRequest,
final AsyncHandler<GetUserPolicyRequest, GetUserPolicyResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetUserPolicyResult>() {
public GetUserPolicyResult call() throws Exception {
GetUserPolicyResult result;
try {
result = getUserPolicy(getUserPolicyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getUserPolicyRequest, result);
return result;
}
});
}
/**
* <p>
* Updates the name and/or the path of the specified server certificate.
* </p>
* <p>
* <b>IMPORTANT:</b> You should understand the implications of changing a
* server certificate's path or name. For more information, see Managing
* Server Certificates in Using AWS Identity and Access Management.
* </p>
* <p>
* <b>NOTE:</b>To change a server certificate name the requester must
* have appropriate permissions on both the source object and the target
* object. For example, to change the name from ProductionCert to
* ProdCert, the entity making the request must have permission on
* ProductionCert and ProdCert, or must have permission on all (*). For
* more information about permissions, see Permissions and Policies.
* </p>
*
* @param updateServerCertificateRequest Container for the necessary
* parameters to execute the UpdateServerCertificate operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* UpdateServerCertificate service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateServerCertificateAsync(final UpdateServerCertificateRequest updateServerCertificateRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
updateServerCertificate(updateServerCertificateRequest);
return null;
}
});
}
/**
* <p>
* Updates the name and/or the path of the specified server certificate.
* </p>
* <p>
* <b>IMPORTANT:</b> You should understand the implications of changing a
* server certificate's path or name. For more information, see Managing
* Server Certificates in Using AWS Identity and Access Management.
* </p>
* <p>
* <b>NOTE:</b>To change a server certificate name the requester must
* have appropriate permissions on both the source object and the target
* object. For example, to change the name from ProductionCert to
* ProdCert, the entity making the request must have permission on
* ProductionCert and ProdCert, or must have permission on all (*). For
* more information about permissions, see Permissions and Policies.
* </p>
*
* @param updateServerCertificateRequest Container for the necessary
* parameters to execute the UpdateServerCertificate operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* UpdateServerCertificate service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateServerCertificateAsync(
final UpdateServerCertificateRequest updateServerCertificateRequest,
final AsyncHandler<UpdateServerCertificateRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
updateServerCertificate(updateServerCertificateRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(updateServerCertificateRequest, null);
return null;
}
});
}
/**
* <p>
* Updates the name and/or the path of the specified user.
* </p>
* <p>
* <b>IMPORTANT:</b> You should understand the implications of changing a
* user's path or name. For more information, see Renaming Users and
* Groups in Using AWS Identity and Access Management.
* </p>
* <p>
* <b>NOTE:</b>To change a user name the requester must have appropriate
* permissions on both the source object and the target object. For
* example, to change Bob to Robert, the entity making the request must
* have permission on Bob and Robert, or must have permission on all (*).
* For more information about permissions, see Permissions and Policies.
* </p>
*
* @param updateUserRequest Container for the necessary parameters to
* execute the UpdateUser operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* UpdateUser service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateUserAsync(final UpdateUserRequest updateUserRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
updateUser(updateUserRequest);
return null;
}
});
}
/**
* <p>
* Updates the name and/or the path of the specified user.
* </p>
* <p>
* <b>IMPORTANT:</b> You should understand the implications of changing a
* user's path or name. For more information, see Renaming Users and
* Groups in Using AWS Identity and Access Management.
* </p>
* <p>
* <b>NOTE:</b>To change a user name the requester must have appropriate
* permissions on both the source object and the target object. For
* example, to change Bob to Robert, the entity making the request must
* have permission on Bob and Robert, or must have permission on all (*).
* For more information about permissions, see Permissions and Policies.
* </p>
*
* @param updateUserRequest Container for the necessary parameters to
* execute the UpdateUser operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* UpdateUser service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateUserAsync(
final UpdateUserRequest updateUserRequest,
final AsyncHandler<UpdateUserRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
updateUser(updateUserRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(updateUserRequest, null);
return null;
}
});
}
/**
* <p>
* Adds (or updates) a policy document associated with the specified
* role. For information about policies, go to <a
* ebservices.com/IAM/latest/UserGuide/index.html?PoliciesOverview.html">
* Overview of Policies </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* For information about limits on the policies you can associate with a
* role, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* <b>NOTE:</b>Because policy documents can be large, you should use POST
* rather than GET when calling PutRolePolicy. For information about
* setting up signatures and authorization through the API, go to Signing
* AWS API Requests in the AWS General Reference. For general information
* about using the Query API with IAM, go to Making Query Requests in
* Using IAM.
* </p>
*
* @param putRolePolicyRequest Container for the necessary parameters to
* execute the PutRolePolicy operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* PutRolePolicy service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> putRolePolicyAsync(final PutRolePolicyRequest putRolePolicyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
putRolePolicy(putRolePolicyRequest);
return null;
}
});
}
/**
* <p>
* Adds (or updates) a policy document associated with the specified
* role. For information about policies, go to <a
* ebservices.com/IAM/latest/UserGuide/index.html?PoliciesOverview.html">
* Overview of Policies </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* For information about limits on the policies you can associate with a
* role, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* <b>NOTE:</b>Because policy documents can be large, you should use POST
* rather than GET when calling PutRolePolicy. For information about
* setting up signatures and authorization through the API, go to Signing
* AWS API Requests in the AWS General Reference. For general information
* about using the Query API with IAM, go to Making Query Requests in
* Using IAM.
* </p>
*
* @param putRolePolicyRequest Container for the necessary parameters to
* execute the PutRolePolicy operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* PutRolePolicy service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> putRolePolicyAsync(
final PutRolePolicyRequest putRolePolicyRequest,
final AsyncHandler<PutRolePolicyRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
putRolePolicy(putRolePolicyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(putRolePolicyRequest, null);
return null;
}
});
}
/**
* <p>
* Changes the status of the specified signing certificate from active to
* disabled, or vice versa. This action can be used to disable a user's
* signing certificate as part of a certificate rotation work flow.
* </p>
* <p>
* If the <code>UserName</code> field is not specified, the UserName is
* determined implicitly based on the AWS Access Key ID used to sign the
* request. Because this action works for access keys under the AWS
* account, this API can be used to manage root credentials even if the
* AWS account has no associated users.
* </p>
* <p>
* For information about rotating certificates, see <a
* ervices.com/IAM/latest/UserGuide/index.html?ManagingCredentials.html">
* Managing Keys and Certificates </a> in <i>Using AWS Identity and
* Access Management</i> .
* </p>
*
* @param updateSigningCertificateRequest Container for the necessary
* parameters to execute the UpdateSigningCertificate operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* UpdateSigningCertificate service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateSigningCertificateAsync(final UpdateSigningCertificateRequest updateSigningCertificateRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
updateSigningCertificate(updateSigningCertificateRequest);
return null;
}
});
}
/**
* <p>
* Changes the status of the specified signing certificate from active to
* disabled, or vice versa. This action can be used to disable a user's
* signing certificate as part of a certificate rotation work flow.
* </p>
* <p>
* If the <code>UserName</code> field is not specified, the UserName is
* determined implicitly based on the AWS Access Key ID used to sign the
* request. Because this action works for access keys under the AWS
* account, this API can be used to manage root credentials even if the
* AWS account has no associated users.
* </p>
* <p>
* For information about rotating certificates, see <a
* ervices.com/IAM/latest/UserGuide/index.html?ManagingCredentials.html">
* Managing Keys and Certificates </a> in <i>Using AWS Identity and
* Access Management</i> .
* </p>
*
* @param updateSigningCertificateRequest Container for the necessary
* parameters to execute the UpdateSigningCertificate operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* UpdateSigningCertificate service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateSigningCertificateAsync(
final UpdateSigningCertificateRequest updateSigningCertificateRequest,
final AsyncHandler<UpdateSigningCertificateRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
updateSigningCertificate(updateSigningCertificateRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(updateSigningCertificateRequest, null);
return null;
}
});
}
/**
* <p>
* Deletes the specified policy that is associated with the specified
* group.
* </p>
*
* @param deleteGroupPolicyRequest Container for the necessary parameters
* to execute the DeleteGroupPolicy operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* DeleteGroupPolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteGroupPolicyAsync(final DeleteGroupPolicyRequest deleteGroupPolicyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
deleteGroupPolicy(deleteGroupPolicyRequest);
return null;
}
});
}
/**
* <p>
* Deletes the specified policy that is associated with the specified
* group.
* </p>
*
* @param deleteGroupPolicyRequest Container for the necessary parameters
* to execute the DeleteGroupPolicy operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteGroupPolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteGroupPolicyAsync(
final DeleteGroupPolicyRequest deleteGroupPolicyRequest,
final AsyncHandler<DeleteGroupPolicyRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
deleteGroupPolicy(deleteGroupPolicyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteGroupPolicyRequest, null);
return null;
}
});
}
/**
* <p>
* Lists the users that have the specified path prefix. If there are
* none, the action returns an empty list.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listUsersRequest Container for the necessary parameters to
* execute the ListUsers operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ListUsers service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListUsersResult> listUsersAsync(final ListUsersRequest listUsersRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListUsersResult>() {
public ListUsersResult call() throws Exception {
return listUsers(listUsersRequest);
}
});
}
/**
* <p>
* Lists the users that have the specified path prefix. If there are
* none, the action returns an empty list.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listUsersRequest Container for the necessary parameters to
* execute the ListUsers operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListUsers service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListUsersResult> listUsersAsync(
final ListUsersRequest listUsersRequest,
final AsyncHandler<ListUsersRequest, ListUsersResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListUsersResult>() {
public ListUsersResult call() throws Exception {
ListUsersResult result;
try {
result = listUsers(listUsersRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listUsersRequest, result);
return result;
}
});
}
/**
* <p>
* Updates the name and/or the path of the specified group.
* </p>
* <p>
* <b>IMPORTANT:</b> You should understand the implications of changing a
* group's path or name. For more information, see Renaming Users and
* Groups in Using AWS Identity and Access Management.
* </p>
* <p>
* <b>NOTE:</b>To change a group name the requester must have appropriate
* permissions on both the source object and the target object. For
* example, to change Managers to MGRs, the entity making the request
* must have permission on Managers and MGRs, or must have permission on
* all (*). For more information about permissions, see Permissions and
* Policies.
* </p>
*
* @param updateGroupRequest Container for the necessary parameters to
* execute the UpdateGroup operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* UpdateGroup service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateGroupAsync(final UpdateGroupRequest updateGroupRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
updateGroup(updateGroupRequest);
return null;
}
});
}
/**
* <p>
* Updates the name and/or the path of the specified group.
* </p>
* <p>
* <b>IMPORTANT:</b> You should understand the implications of changing a
* group's path or name. For more information, see Renaming Users and
* Groups in Using AWS Identity and Access Management.
* </p>
* <p>
* <b>NOTE:</b>To change a group name the requester must have appropriate
* permissions on both the source object and the target object. For
* example, to change Managers to MGRs, the entity making the request
* must have permission on Managers and MGRs, or must have permission on
* all (*). For more information about permissions, see Permissions and
* Policies.
* </p>
*
* @param updateGroupRequest Container for the necessary parameters to
* execute the UpdateGroup operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* UpdateGroup service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateGroupAsync(
final UpdateGroupRequest updateGroupRequest,
final AsyncHandler<UpdateGroupRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
updateGroup(updateGroupRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(updateGroupRequest, null);
return null;
}
});
}
/**
* <p>
* Creates a new user for your AWS account.
* </p>
* <p>
* For information about limitations on the number of users you can
* create, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
*
* @param createUserRequest Container for the necessary parameters to
* execute the CreateUser operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* CreateUser service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<CreateUserResult> createUserAsync(final CreateUserRequest createUserRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<CreateUserResult>() {
public CreateUserResult call() throws Exception {
return createUser(createUserRequest);
}
});
}
/**
* <p>
* Creates a new user for your AWS account.
* </p>
* <p>
* For information about limitations on the number of users you can
* create, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
*
* @param createUserRequest Container for the necessary parameters to
* execute the CreateUser operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* CreateUser service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<CreateUserResult> createUserAsync(
final CreateUserRequest createUserRequest,
final AsyncHandler<CreateUserRequest, CreateUserResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<CreateUserResult>() {
public CreateUserResult call() throws Exception {
CreateUserResult result;
try {
result = createUser(createUserRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(createUserRequest, result);
return result;
}
});
}
/**
* <p>
* Enables the specified MFA device and associates it with the specified
* user name. When enabled, the MFA device is required for every
* subsequent login by the user name associated with the device.
* </p>
*
* @param enableMFADeviceRequest Container for the necessary parameters
* to execute the EnableMFADevice operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* EnableMFADevice service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> enableMFADeviceAsync(final EnableMFADeviceRequest enableMFADeviceRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
enableMFADevice(enableMFADeviceRequest);
return null;
}
});
}
/**
* <p>
* Enables the specified MFA device and associates it with the specified
* user name. When enabled, the MFA device is required for every
* subsequent login by the user name associated with the device.
* </p>
*
* @param enableMFADeviceRequest Container for the necessary parameters
* to execute the EnableMFADevice operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* EnableMFADevice service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> enableMFADeviceAsync(
final EnableMFADeviceRequest enableMFADeviceRequest,
final AsyncHandler<EnableMFADeviceRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
enableMFADevice(enableMFADeviceRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(enableMFADeviceRequest, null);
return null;
}
});
}
/**
* <p>
* Deletes the password policy for the AWS account.
* </p>
*
* @param deleteAccountPasswordPolicyRequest Container for the necessary
* parameters to execute the DeleteAccountPasswordPolicy operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* DeleteAccountPasswordPolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteAccountPasswordPolicyAsync(final DeleteAccountPasswordPolicyRequest deleteAccountPasswordPolicyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
deleteAccountPasswordPolicy(deleteAccountPasswordPolicyRequest);
return null;
}
});
}
/**
* <p>
* Deletes the password policy for the AWS account.
* </p>
*
* @param deleteAccountPasswordPolicyRequest Container for the necessary
* parameters to execute the DeleteAccountPasswordPolicy operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteAccountPasswordPolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteAccountPasswordPolicyAsync(
final DeleteAccountPasswordPolicyRequest deleteAccountPasswordPolicyRequest,
final AsyncHandler<DeleteAccountPasswordPolicyRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
deleteAccountPasswordPolicy(deleteAccountPasswordPolicyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteAccountPasswordPolicyRequest, null);
return null;
}
});
}
/**
* <p>
* Retrieves the user name and password create date for the specified
* user.
* </p>
*
* @param getLoginProfileRequest Container for the necessary parameters
* to execute the GetLoginProfile operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* GetLoginProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetLoginProfileResult> getLoginProfileAsync(final GetLoginProfileRequest getLoginProfileRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetLoginProfileResult>() {
public GetLoginProfileResult call() throws Exception {
return getLoginProfile(getLoginProfileRequest);
}
});
}
/**
* <p>
* Retrieves the user name and password create date for the specified
* user.
* </p>
*
* @param getLoginProfileRequest Container for the necessary parameters
* to execute the GetLoginProfile operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetLoginProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetLoginProfileResult> getLoginProfileAsync(
final GetLoginProfileRequest getLoginProfileRequest,
final AsyncHandler<GetLoginProfileRequest, GetLoginProfileResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetLoginProfileResult>() {
public GetLoginProfileResult call() throws Exception {
GetLoginProfileResult result;
try {
result = getLoginProfile(getLoginProfileRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getLoginProfileRequest, result);
return result;
}
});
}
/**
* <p>
* Uploads a server certificate entity for the AWS account. The server
* certificate entity includes a public key certificate, a private key,
* and an optional certificate chain, which should all be PEM-encoded.
* </p>
* <p>
* For information about the number of server certificates you can
* upload, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* <b>NOTE:</b>Because the body of the public key certificate, private
* key, and the certificate chain can be large, you should use POST
* rather than GET when calling UploadServerCertificate. For information
* about setting up signatures and authorization through the API, go to
* Signing AWS API Requests in the AWS General Reference. For general
* information about using the Query API with IAM, go to Making Query
* Requests in Using IAM.
* </p>
*
* @param uploadServerCertificateRequest Container for the necessary
* parameters to execute the UploadServerCertificate operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* UploadServerCertificate service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<UploadServerCertificateResult> uploadServerCertificateAsync(final UploadServerCertificateRequest uploadServerCertificateRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<UploadServerCertificateResult>() {
public UploadServerCertificateResult call() throws Exception {
return uploadServerCertificate(uploadServerCertificateRequest);
}
});
}
/**
* <p>
* Uploads a server certificate entity for the AWS account. The server
* certificate entity includes a public key certificate, a private key,
* and an optional certificate chain, which should all be PEM-encoded.
* </p>
* <p>
* For information about the number of server certificates you can
* upload, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* <b>NOTE:</b>Because the body of the public key certificate, private
* key, and the certificate chain can be large, you should use POST
* rather than GET when calling UploadServerCertificate. For information
* about setting up signatures and authorization through the API, go to
* Signing AWS API Requests in the AWS General Reference. For general
* information about using the Query API with IAM, go to Making Query
* Requests in Using IAM.
* </p>
*
* @param uploadServerCertificateRequest Container for the necessary
* parameters to execute the UploadServerCertificate operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* UploadServerCertificate service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<UploadServerCertificateResult> uploadServerCertificateAsync(
final UploadServerCertificateRequest uploadServerCertificateRequest,
final AsyncHandler<UploadServerCertificateRequest, UploadServerCertificateResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<UploadServerCertificateResult>() {
public UploadServerCertificateResult call() throws Exception {
UploadServerCertificateResult result;
try {
result = uploadServerCertificate(uploadServerCertificateRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(uploadServerCertificateRequest, result);
return result;
}
});
}
/**
* <p>
* Creates a new group.
* </p>
* <p>
* For information about the number of groups you can create, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
*
* @param createGroupRequest Container for the necessary parameters to
* execute the CreateGroup operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* CreateGroup service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<CreateGroupResult> createGroupAsync(final CreateGroupRequest createGroupRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<CreateGroupResult>() {
public CreateGroupResult call() throws Exception {
return createGroup(createGroupRequest);
}
});
}
/**
* <p>
* Creates a new group.
* </p>
* <p>
* For information about the number of groups you can create, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
*
* @param createGroupRequest Container for the necessary parameters to
* execute the CreateGroup operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* CreateGroup service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<CreateGroupResult> createGroupAsync(
final CreateGroupRequest createGroupRequest,
final AsyncHandler<CreateGroupRequest, CreateGroupResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<CreateGroupResult>() {
public CreateGroupResult call() throws Exception {
CreateGroupResult result;
try {
result = createGroup(createGroupRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(createGroupRequest, result);
return result;
}
});
}
/**
* <p>
* This action creates an alias for your AWS account. For information
* about using an AWS account alias, see <a
* ://docs.amazonwebservices.com/IAM/latest/UserGuide/AccountAlias.html">
* Using an Alias for Your AWS Account ID </a> in <i>Using AWS Identity
* and Access Management</i> .
* </p>
*
* @param createAccountAliasRequest Container for the necessary
* parameters to execute the CreateAccountAlias operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* CreateAccountAlias service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> createAccountAliasAsync(final CreateAccountAliasRequest createAccountAliasRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
createAccountAlias(createAccountAliasRequest);
return null;
}
});
}
/**
* <p>
* This action creates an alias for your AWS account. For information
* about using an AWS account alias, see <a
* ://docs.amazonwebservices.com/IAM/latest/UserGuide/AccountAlias.html">
* Using an Alias for Your AWS Account ID </a> in <i>Using AWS Identity
* and Access Management</i> .
* </p>
*
* @param createAccountAliasRequest Container for the necessary
* parameters to execute the CreateAccountAlias operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* CreateAccountAlias service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> createAccountAliasAsync(
final CreateAccountAliasRequest createAccountAliasRequest,
final AsyncHandler<CreateAccountAliasRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
createAccountAlias(createAccountAliasRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(createAccountAliasRequest, null);
return null;
}
});
}
/**
* <p>
* Deletes the specified user. The user must not belong to any groups,
* have any keys or signing certificates, or have any attached policies.
* </p>
*
* @param deleteUserRequest Container for the necessary parameters to
* execute the DeleteUser operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* DeleteUser service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteUserAsync(final DeleteUserRequest deleteUserRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
deleteUser(deleteUserRequest);
return null;
}
});
}
/**
* <p>
* Deletes the specified user. The user must not belong to any groups,
* have any keys or signing certificates, or have any attached policies.
* </p>
*
* @param deleteUserRequest Container for the necessary parameters to
* execute the DeleteUser operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteUser service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteUserAsync(
final DeleteUserRequest deleteUserRequest,
final AsyncHandler<DeleteUserRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
deleteUser(deleteUserRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteUserRequest, null);
return null;
}
});
}
/**
* <p>
* Deactivates the specified MFA device and removes it from association
* with the user name for which it was originally enabled.
* </p>
*
* @param deactivateMFADeviceRequest Container for the necessary
* parameters to execute the DeactivateMFADevice operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* DeactivateMFADevice service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deactivateMFADeviceAsync(final DeactivateMFADeviceRequest deactivateMFADeviceRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
deactivateMFADevice(deactivateMFADeviceRequest);
return null;
}
});
}
/**
* <p>
* Deactivates the specified MFA device and removes it from association
* with the user name for which it was originally enabled.
* </p>
*
* @param deactivateMFADeviceRequest Container for the necessary
* parameters to execute the DeactivateMFADevice operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeactivateMFADevice service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deactivateMFADeviceAsync(
final DeactivateMFADeviceRequest deactivateMFADeviceRequest,
final AsyncHandler<DeactivateMFADeviceRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
deactivateMFADevice(deactivateMFADeviceRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deactivateMFADeviceRequest, null);
return null;
}
});
}
/**
* <p>
* Removes the specified user from the specified group.
* </p>
*
* @param removeUserFromGroupRequest Container for the necessary
* parameters to execute the RemoveUserFromGroup operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* RemoveUserFromGroup service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> removeUserFromGroupAsync(final RemoveUserFromGroupRequest removeUserFromGroupRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
removeUserFromGroup(removeUserFromGroupRequest);
return null;
}
});
}
/**
* <p>
* Removes the specified user from the specified group.
* </p>
*
* @param removeUserFromGroupRequest Container for the necessary
* parameters to execute the RemoveUserFromGroup operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* RemoveUserFromGroup service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> removeUserFromGroupAsync(
final RemoveUserFromGroupRequest removeUserFromGroupRequest,
final AsyncHandler<RemoveUserFromGroupRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
removeUserFromGroup(removeUserFromGroupRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(removeUserFromGroupRequest, null);
return null;
}
});
}
/**
* <p>
* Deletes the specified role. The role must not have any policies
* attached. For more information about roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> .
* </p>
* <p>
* <b>IMPORTANT:</b>Make sure you do not have any Amazon EC2 instances
* running with the role you are about to delete. Deleting a role or
* instance profile that is associated with a running instance will break
* any applications running on the instance.
* </p>
*
* @param deleteRoleRequest Container for the necessary parameters to
* execute the DeleteRole operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* DeleteRole service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteRoleAsync(final DeleteRoleRequest deleteRoleRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
deleteRole(deleteRoleRequest);
return null;
}
});
}
/**
* <p>
* Deletes the specified role. The role must not have any policies
* attached. For more information about roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> .
* </p>
* <p>
* <b>IMPORTANT:</b>Make sure you do not have any Amazon EC2 instances
* running with the role you are about to delete. Deleting a role or
* instance profile that is associated with a running instance will break
* any applications running on the instance.
* </p>
*
* @param deleteRoleRequest Container for the necessary parameters to
* execute the DeleteRole operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteRole service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteRoleAsync(
final DeleteRoleRequest deleteRoleRequest,
final AsyncHandler<DeleteRoleRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
deleteRole(deleteRoleRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteRoleRequest, null);
return null;
}
});
}
/**
* <p>
* Deletes the specified server certificate.
* </p>
* <p>
* <b>IMPORTANT:</b>If you are using a server certificate with Elastic
* Load Balancing, deleting the certificate could have implications for
* your application. If Elastic Load Balancing doesn't detect the
* deletion of bound certificates, it may continue to use the
* certificates. This could cause Elastic Load Balancing to stop
* accepting traffic. We recommend that you remove the reference to the
* certificate from Elastic Load Balancing before using this command to
* delete the certificate. For more information, go to
* DeleteLoadBalancerListeners in the Elastic Load Balancing API
* Reference.
* </p>
*
* @param deleteServerCertificateRequest Container for the necessary
* parameters to execute the DeleteServerCertificate operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* DeleteServerCertificate service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteServerCertificateAsync(final DeleteServerCertificateRequest deleteServerCertificateRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
deleteServerCertificate(deleteServerCertificateRequest);
return null;
}
});
}
/**
* <p>
* Deletes the specified server certificate.
* </p>
* <p>
* <b>IMPORTANT:</b>If you are using a server certificate with Elastic
* Load Balancing, deleting the certificate could have implications for
* your application. If Elastic Load Balancing doesn't detect the
* deletion of bound certificates, it may continue to use the
* certificates. This could cause Elastic Load Balancing to stop
* accepting traffic. We recommend that you remove the reference to the
* certificate from Elastic Load Balancing before using this command to
* delete the certificate. For more information, go to
* DeleteLoadBalancerListeners in the Elastic Load Balancing API
* Reference.
* </p>
*
* @param deleteServerCertificateRequest Container for the necessary
* parameters to execute the DeleteServerCertificate operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteServerCertificate service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteServerCertificateAsync(
final DeleteServerCertificateRequest deleteServerCertificateRequest,
final AsyncHandler<DeleteServerCertificateRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
deleteServerCertificate(deleteServerCertificateRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteServerCertificateRequest, null);
return null;
}
});
}
/**
* <p>
* Creates a new AWS Secret Access Key and corresponding AWS Access Key
* ID for the specified user. The default status for new keys is
* <code>Active</code> .
* </p>
* <p>
* If you do not specify a user name, IAM determines the user name
* implicitly based on the AWS Access Key ID signing the request. Because
* this action works for access keys under the AWS account, you can use
* this API to manage root credentials even if the AWS account has no
* associated users.
* </p>
* <p>
* For information about limits on the number of keys you can create, see
* <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* <b>IMPORTANT:</b>To ensure the security of your AWS account, the
* Secret Access Key is accessible only during key and user creation.
* You must save the key (for example, in a text file) if you want to be
* able to access it again. If a secret key is lost, you can delete the
* access keys for the associated user and then create new keys.
* </p>
*
* @param createAccessKeyRequest Container for the necessary parameters
* to execute the CreateAccessKey operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* CreateAccessKey service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<CreateAccessKeyResult> createAccessKeyAsync(final CreateAccessKeyRequest createAccessKeyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<CreateAccessKeyResult>() {
public CreateAccessKeyResult call() throws Exception {
return createAccessKey(createAccessKeyRequest);
}
});
}
/**
* <p>
* Creates a new AWS Secret Access Key and corresponding AWS Access Key
* ID for the specified user. The default status for new keys is
* <code>Active</code> .
* </p>
* <p>
* If you do not specify a user name, IAM determines the user name
* implicitly based on the AWS Access Key ID signing the request. Because
* this action works for access keys under the AWS account, you can use
* this API to manage root credentials even if the AWS account has no
* associated users.
* </p>
* <p>
* For information about limits on the number of keys you can create, see
* <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* <b>IMPORTANT:</b>To ensure the security of your AWS account, the
* Secret Access Key is accessible only during key and user creation.
* You must save the key (for example, in a text file) if you want to be
* able to access it again. If a secret key is lost, you can delete the
* access keys for the associated user and then create new keys.
* </p>
*
* @param createAccessKeyRequest Container for the necessary parameters
* to execute the CreateAccessKey operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* CreateAccessKey service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<CreateAccessKeyResult> createAccessKeyAsync(
final CreateAccessKeyRequest createAccessKeyRequest,
final AsyncHandler<CreateAccessKeyRequest, CreateAccessKeyResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<CreateAccessKeyResult>() {
public CreateAccessKeyResult call() throws Exception {
CreateAccessKeyResult result;
try {
result = createAccessKey(createAccessKeyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(createAccessKeyRequest, result);
return result;
}
});
}
/**
* <p>
* Retrieves information about the specified user, including the user's
* path, GUID, and ARN.
* </p>
* <p>
* If you do not specify a user name, IAM determines the user name
* implicitly based on the AWS Access Key ID signing the request.
* </p>
*
* @param getUserRequest Container for the necessary parameters to
* execute the GetUser operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the GetUser
* service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetUserResult> getUserAsync(final GetUserRequest getUserRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetUserResult>() {
public GetUserResult call() throws Exception {
return getUser(getUserRequest);
}
});
}
/**
* <p>
* Retrieves information about the specified user, including the user's
* path, GUID, and ARN.
* </p>
* <p>
* If you do not specify a user name, IAM determines the user name
* implicitly based on the AWS Access Key ID signing the request.
* </p>
*
* @param getUserRequest Container for the necessary parameters to
* execute the GetUser operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the GetUser
* service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetUserResult> getUserAsync(
final GetUserRequest getUserRequest,
final AsyncHandler<GetUserRequest, GetUserResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetUserResult>() {
public GetUserResult call() throws Exception {
GetUserResult result;
try {
result = getUser(getUserRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getUserRequest, result);
return result;
}
});
}
/**
* <p>
* Synchronizes the specified MFA device with AWS servers.
* </p>
*
* @param resyncMFADeviceRequest Container for the necessary parameters
* to execute the ResyncMFADevice operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ResyncMFADevice service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> resyncMFADeviceAsync(final ResyncMFADeviceRequest resyncMFADeviceRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
resyncMFADevice(resyncMFADeviceRequest);
return null;
}
});
}
/**
* <p>
* Synchronizes the specified MFA device with AWS servers.
* </p>
*
* @param resyncMFADeviceRequest Container for the necessary parameters
* to execute the ResyncMFADevice operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ResyncMFADevice service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> resyncMFADeviceAsync(
final ResyncMFADeviceRequest resyncMFADeviceRequest,
final AsyncHandler<ResyncMFADeviceRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
resyncMFADevice(resyncMFADeviceRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(resyncMFADeviceRequest, null);
return null;
}
});
}
/**
* <p>
* Lists the MFA devices. If the request includes the user name, then
* this action lists all the MFA devices associated with the specified
* user name. If you do not specify a user name, IAM determines the user
* name implicitly based on the AWS Access Key ID signing the request.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listMFADevicesRequest Container for the necessary parameters to
* execute the ListMFADevices operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ListMFADevices service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListMFADevicesResult> listMFADevicesAsync(final ListMFADevicesRequest listMFADevicesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListMFADevicesResult>() {
public ListMFADevicesResult call() throws Exception {
return listMFADevices(listMFADevicesRequest);
}
});
}
/**
* <p>
* Lists the MFA devices. If the request includes the user name, then
* this action lists all the MFA devices associated with the specified
* user name. If you do not specify a user name, IAM determines the user
* name implicitly based on the AWS Access Key ID signing the request.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listMFADevicesRequest Container for the necessary parameters to
* execute the ListMFADevices operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListMFADevices service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListMFADevicesResult> listMFADevicesAsync(
final ListMFADevicesRequest listMFADevicesRequest,
final AsyncHandler<ListMFADevicesRequest, ListMFADevicesResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListMFADevicesResult>() {
public ListMFADevicesResult call() throws Exception {
ListMFADevicesResult result;
try {
result = listMFADevices(listMFADevicesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listMFADevicesRequest, result);
return result;
}
});
}
/**
* <p>
* Creates a new virtual MFA device for the AWS account. After creating
* the virtual MFA, use <a
* azonwebservices.com/IAM/latest/APIReference/API_EnableMFADevice.html">
* EnableMFADevice </a> to attach the MFA device to an IAM user. For more
* information about creating and working with virtual MFA devices, go to
* <a
* ebservices.com/IAM/latest/UserGuide/index.html?Using_VirtualMFA.html">
* Using a Virtual MFA Device </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* For information about limits on the number of MFA devices you can
* create, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* <b>IMPORTANT:</b>The seed information contained in the QR code and the
* Base32 string should be treated like any other secret access
* information, such as your AWS access keys or your passwords. After you
* provision your virtual device, you should ensure that the information
* is destroyed following secure procedures.
* </p>
*
* @param createVirtualMFADeviceRequest Container for the necessary
* parameters to execute the CreateVirtualMFADevice operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* CreateVirtualMFADevice service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<CreateVirtualMFADeviceResult> createVirtualMFADeviceAsync(final CreateVirtualMFADeviceRequest createVirtualMFADeviceRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<CreateVirtualMFADeviceResult>() {
public CreateVirtualMFADeviceResult call() throws Exception {
return createVirtualMFADevice(createVirtualMFADeviceRequest);
}
});
}
/**
* <p>
* Creates a new virtual MFA device for the AWS account. After creating
* the virtual MFA, use <a
* azonwebservices.com/IAM/latest/APIReference/API_EnableMFADevice.html">
* EnableMFADevice </a> to attach the MFA device to an IAM user. For more
* information about creating and working with virtual MFA devices, go to
* <a
* ebservices.com/IAM/latest/UserGuide/index.html?Using_VirtualMFA.html">
* Using a Virtual MFA Device </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* For information about limits on the number of MFA devices you can
* create, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* <b>IMPORTANT:</b>The seed information contained in the QR code and the
* Base32 string should be treated like any other secret access
* information, such as your AWS access keys or your passwords. After you
* provision your virtual device, you should ensure that the information
* is destroyed following secure procedures.
* </p>
*
* @param createVirtualMFADeviceRequest Container for the necessary
* parameters to execute the CreateVirtualMFADevice operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* CreateVirtualMFADevice service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<CreateVirtualMFADeviceResult> createVirtualMFADeviceAsync(
final CreateVirtualMFADeviceRequest createVirtualMFADeviceRequest,
final AsyncHandler<CreateVirtualMFADeviceRequest, CreateVirtualMFADeviceResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<CreateVirtualMFADeviceResult>() {
public CreateVirtualMFADeviceResult call() throws Exception {
CreateVirtualMFADeviceResult result;
try {
result = createVirtualMFADevice(createVirtualMFADeviceRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(createVirtualMFADeviceRequest, result);
return result;
}
});
}
/**
* <p>
* Lists the instance profiles that have the specified path prefix. If
* there are none, the action returns an empty list. For more information
* about instance profiles, go to <a
* mazonwebservices.com/IAM/latest/UserGuide/AboutInstanceProfiles.html">
* About Instance Profiles </a> .
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listInstanceProfilesRequest Container for the necessary
* parameters to execute the ListInstanceProfiles operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ListInstanceProfiles service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListInstanceProfilesResult> listInstanceProfilesAsync(final ListInstanceProfilesRequest listInstanceProfilesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListInstanceProfilesResult>() {
public ListInstanceProfilesResult call() throws Exception {
return listInstanceProfiles(listInstanceProfilesRequest);
}
});
}
/**
* <p>
* Lists the instance profiles that have the specified path prefix. If
* there are none, the action returns an empty list. For more information
* about instance profiles, go to <a
* mazonwebservices.com/IAM/latest/UserGuide/AboutInstanceProfiles.html">
* About Instance Profiles </a> .
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listInstanceProfilesRequest Container for the necessary
* parameters to execute the ListInstanceProfiles operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListInstanceProfiles service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListInstanceProfilesResult> listInstanceProfilesAsync(
final ListInstanceProfilesRequest listInstanceProfilesRequest,
final AsyncHandler<ListInstanceProfilesRequest, ListInstanceProfilesResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListInstanceProfilesResult>() {
public ListInstanceProfilesResult call() throws Exception {
ListInstanceProfilesResult result;
try {
result = listInstanceProfiles(listInstanceProfilesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listInstanceProfilesRequest, result);
return result;
}
});
}
/**
* <p>
* Changes the status of the specified access key from Active to
* Inactive, or vice versa. This action can be used to disable a user's
* key as part of a key rotation work flow.
* </p>
* <p>
* If the <code>UserName</code> field is not specified, the UserName is
* determined implicitly based on the AWS Access Key ID used to sign the
* request. Because this action works for access keys under the AWS
* account, this API can be used to manage root credentials even if the
* AWS account has no associated users.
* </p>
* <p>
* For information about rotating keys, see <a
* ervices.com/IAM/latest/UserGuide/index.html?ManagingCredentials.html">
* Managing Keys and Certificates </a> in <i>Using AWS Identity and
* Access Management</i> .
* </p>
*
* @param updateAccessKeyRequest Container for the necessary parameters
* to execute the UpdateAccessKey operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* UpdateAccessKey service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateAccessKeyAsync(final UpdateAccessKeyRequest updateAccessKeyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
updateAccessKey(updateAccessKeyRequest);
return null;
}
});
}
/**
* <p>
* Changes the status of the specified access key from Active to
* Inactive, or vice versa. This action can be used to disable a user's
* key as part of a key rotation work flow.
* </p>
* <p>
* If the <code>UserName</code> field is not specified, the UserName is
* determined implicitly based on the AWS Access Key ID used to sign the
* request. Because this action works for access keys under the AWS
* account, this API can be used to manage root credentials even if the
* AWS account has no associated users.
* </p>
* <p>
* For information about rotating keys, see <a
* ervices.com/IAM/latest/UserGuide/index.html?ManagingCredentials.html">
* Managing Keys and Certificates </a> in <i>Using AWS Identity and
* Access Management</i> .
* </p>
*
* @param updateAccessKeyRequest Container for the necessary parameters
* to execute the UpdateAccessKey operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* UpdateAccessKey service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateAccessKeyAsync(
final UpdateAccessKeyRequest updateAccessKeyRequest,
final AsyncHandler<UpdateAccessKeyRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
updateAccessKey(updateAccessKeyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(updateAccessKeyRequest, null);
return null;
}
});
}
/**
* <p>
* Adds the specified user to the specified group.
* </p>
*
* @param addUserToGroupRequest Container for the necessary parameters to
* execute the AddUserToGroup operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* AddUserToGroup service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> addUserToGroupAsync(final AddUserToGroupRequest addUserToGroupRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
addUserToGroup(addUserToGroupRequest);
return null;
}
});
}
/**
* <p>
* Adds the specified user to the specified group.
* </p>
*
* @param addUserToGroupRequest Container for the necessary parameters to
* execute the AddUserToGroup operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* AddUserToGroup service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> addUserToGroupAsync(
final AddUserToGroupRequest addUserToGroupRequest,
final AsyncHandler<AddUserToGroupRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
addUserToGroup(addUserToGroupRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(addUserToGroupRequest, null);
return null;
}
});
}
/**
* <p>
* Returns a list of users that are in the specified group. You can
* paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param getGroupRequest Container for the necessary parameters to
* execute the GetGroup operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the GetGroup
* service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetGroupResult> getGroupAsync(final GetGroupRequest getGroupRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetGroupResult>() {
public GetGroupResult call() throws Exception {
return getGroup(getGroupRequest);
}
});
}
/**
* <p>
* Returns a list of users that are in the specified group. You can
* paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param getGroupRequest Container for the necessary parameters to
* execute the GetGroup operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the GetGroup
* service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetGroupResult> getGroupAsync(
final GetGroupRequest getGroupRequest,
final AsyncHandler<GetGroupRequest, GetGroupResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetGroupResult>() {
public GetGroupResult call() throws Exception {
GetGroupResult result;
try {
result = getGroup(getGroupRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getGroupRequest, result);
return result;
}
});
}
/**
* <p>
* Lists the account aliases associated with the account. For information
* about using an AWS account alias, see <a
* ://docs.amazonwebservices.com/IAM/latest/UserGuide/AccountAlias.html">
* Using an Alias for Your AWS Account ID </a> in <i>Using AWS Identity
* and Access Management</i> .
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listAccountAliasesRequest Container for the necessary
* parameters to execute the ListAccountAliases operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ListAccountAliases service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListAccountAliasesResult> listAccountAliasesAsync(final ListAccountAliasesRequest listAccountAliasesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListAccountAliasesResult>() {
public ListAccountAliasesResult call() throws Exception {
return listAccountAliases(listAccountAliasesRequest);
}
});
}
/**
* <p>
* Lists the account aliases associated with the account. For information
* about using an AWS account alias, see <a
* ://docs.amazonwebservices.com/IAM/latest/UserGuide/AccountAlias.html">
* Using an Alias for Your AWS Account ID </a> in <i>Using AWS Identity
* and Access Management</i> .
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listAccountAliasesRequest Container for the necessary
* parameters to execute the ListAccountAliases operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListAccountAliases service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListAccountAliasesResult> listAccountAliasesAsync(
final ListAccountAliasesRequest listAccountAliasesRequest,
final AsyncHandler<ListAccountAliasesRequest, ListAccountAliasesResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListAccountAliasesResult>() {
public ListAccountAliasesResult call() throws Exception {
ListAccountAliasesResult result;
try {
result = listAccountAliases(listAccountAliasesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listAccountAliasesRequest, result);
return result;
}
});
}
/**
* <p>
* Deletes the specified group. The group must not contain any users or
* have any attached policies.
* </p>
*
* @param deleteGroupRequest Container for the necessary parameters to
* execute the DeleteGroup operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* DeleteGroup service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteGroupAsync(final DeleteGroupRequest deleteGroupRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
deleteGroup(deleteGroupRequest);
return null;
}
});
}
/**
* <p>
* Deletes the specified group. The group must not contain any users or
* have any attached policies.
* </p>
*
* @param deleteGroupRequest Container for the necessary parameters to
* execute the DeleteGroup operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteGroup service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteGroupAsync(
final DeleteGroupRequest deleteGroupRequest,
final AsyncHandler<DeleteGroupRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
deleteGroup(deleteGroupRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteGroupRequest, null);
return null;
}
});
}
/**
* <p>
* Retrieves information about the specified role, including the role's
* path, GUID, ARN, and the policy granting permission to EC2 to assume
* the role. For more information about ARNs, go to ARNs. For more
* information about roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> .
* </p>
* <p>
* The returned policy is URL-encoded according to RFC 3986. For more
* information about RFC 3986, go to <a
* href="http://www.faqs.org/rfcs/rfc3986.html">
* http://www.faqs.org/rfcs/rfc3986.html </a> .
* </p>
*
* @param getRoleRequest Container for the necessary parameters to
* execute the GetRole operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the GetRole
* service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetRoleResult> getRoleAsync(final GetRoleRequest getRoleRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetRoleResult>() {
public GetRoleResult call() throws Exception {
return getRole(getRoleRequest);
}
});
}
/**
* <p>
* Retrieves information about the specified role, including the role's
* path, GUID, ARN, and the policy granting permission to EC2 to assume
* the role. For more information about ARNs, go to ARNs. For more
* information about roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> .
* </p>
* <p>
* The returned policy is URL-encoded according to RFC 3986. For more
* information about RFC 3986, go to <a
* href="http://www.faqs.org/rfcs/rfc3986.html">
* http://www.faqs.org/rfcs/rfc3986.html </a> .
* </p>
*
* @param getRoleRequest Container for the necessary parameters to
* execute the GetRole operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the GetRole
* service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetRoleResult> getRoleAsync(
final GetRoleRequest getRoleRequest,
final AsyncHandler<GetRoleRequest, GetRoleResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetRoleResult>() {
public GetRoleResult call() throws Exception {
GetRoleResult result;
try {
result = getRole(getRoleRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getRoleRequest, result);
return result;
}
});
}
/**
* <p>
* Lists the names of the policies associated with the specified role. If
* there are none, the action returns an empty list.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listRolePoliciesRequest Container for the necessary parameters
* to execute the ListRolePolicies operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ListRolePolicies service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListRolePoliciesResult> listRolePoliciesAsync(final ListRolePoliciesRequest listRolePoliciesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListRolePoliciesResult>() {
public ListRolePoliciesResult call() throws Exception {
return listRolePolicies(listRolePoliciesRequest);
}
});
}
/**
* <p>
* Lists the names of the policies associated with the specified role. If
* there are none, the action returns an empty list.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listRolePoliciesRequest Container for the necessary parameters
* to execute the ListRolePolicies operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListRolePolicies service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListRolePoliciesResult> listRolePoliciesAsync(
final ListRolePoliciesRequest listRolePoliciesRequest,
final AsyncHandler<ListRolePoliciesRequest, ListRolePoliciesResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListRolePoliciesResult>() {
public ListRolePoliciesResult call() throws Exception {
ListRolePoliciesResult result;
try {
result = listRolePolicies(listRolePoliciesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listRolePoliciesRequest, result);
return result;
}
});
}
/**
* <p>
* Returns information about the signing certificates associated with the
* specified user. If there are none, the action returns an empty list.
* </p>
* <p>
* Although each user is limited to a small number of signing
* certificates, you can still paginate the results using the
* <code>MaxItems</code> and <code>Marker</code> parameters.
* </p>
* <p>
* If the <code>UserName</code> field is not specified, the user name is
* determined implicitly based on the AWS Access Key ID used to sign the
* request. Because this action works for access keys under the AWS
* account, this API can be used to manage root credentials even if the
* AWS account has no associated users.
* </p>
*
* @param listSigningCertificatesRequest Container for the necessary
* parameters to execute the ListSigningCertificates operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ListSigningCertificates service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListSigningCertificatesResult> listSigningCertificatesAsync(final ListSigningCertificatesRequest listSigningCertificatesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListSigningCertificatesResult>() {
public ListSigningCertificatesResult call() throws Exception {
return listSigningCertificates(listSigningCertificatesRequest);
}
});
}
/**
* <p>
* Returns information about the signing certificates associated with the
* specified user. If there are none, the action returns an empty list.
* </p>
* <p>
* Although each user is limited to a small number of signing
* certificates, you can still paginate the results using the
* <code>MaxItems</code> and <code>Marker</code> parameters.
* </p>
* <p>
* If the <code>UserName</code> field is not specified, the user name is
* determined implicitly based on the AWS Access Key ID used to sign the
* request. Because this action works for access keys under the AWS
* account, this API can be used to manage root credentials even if the
* AWS account has no associated users.
* </p>
*
* @param listSigningCertificatesRequest Container for the necessary
* parameters to execute the ListSigningCertificates operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListSigningCertificates service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListSigningCertificatesResult> listSigningCertificatesAsync(
final ListSigningCertificatesRequest listSigningCertificatesRequest,
final AsyncHandler<ListSigningCertificatesRequest, ListSigningCertificatesResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListSigningCertificatesResult>() {
public ListSigningCertificatesResult call() throws Exception {
ListSigningCertificatesResult result;
try {
result = listSigningCertificates(listSigningCertificatesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listSigningCertificatesRequest, result);
return result;
}
});
}
/**
* <p>
* Uploads an X.509 signing certificate and associates it with the
* specified user. Some AWS services use X.509 signing certificates to
* validate requests that are signed with a corresponding private key.
* When you upload the certificate, its default status is
* <code>Active</code> .
* </p>
* <p>
* If the <code>UserName</code> field is not specified, the user name is
* determined implicitly based on the AWS Access Key ID used to sign the
* request. Because this action works for access keys under the AWS
* account, this API can be used to manage root credentials even if the
* AWS account has no associated users.
* </p>
* <p>
* <b>NOTE:</b>Because the body of a X.509 certificate can be large, you
* should use POST rather than GET when calling UploadSigningCertificate.
* For information about setting up signatures and authorization through
* the API, go to Signing AWS API Requests in the AWS General Reference.
* For general information about using the Query API with IAM, go to
* Making Query Requests in Using IAM.
* </p>
*
* @param uploadSigningCertificateRequest Container for the necessary
* parameters to execute the UploadSigningCertificate operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* UploadSigningCertificate service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<UploadSigningCertificateResult> uploadSigningCertificateAsync(final UploadSigningCertificateRequest uploadSigningCertificateRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<UploadSigningCertificateResult>() {
public UploadSigningCertificateResult call() throws Exception {
return uploadSigningCertificate(uploadSigningCertificateRequest);
}
});
}
/**
* <p>
* Uploads an X.509 signing certificate and associates it with the
* specified user. Some AWS services use X.509 signing certificates to
* validate requests that are signed with a corresponding private key.
* When you upload the certificate, its default status is
* <code>Active</code> .
* </p>
* <p>
* If the <code>UserName</code> field is not specified, the user name is
* determined implicitly based on the AWS Access Key ID used to sign the
* request. Because this action works for access keys under the AWS
* account, this API can be used to manage root credentials even if the
* AWS account has no associated users.
* </p>
* <p>
* <b>NOTE:</b>Because the body of a X.509 certificate can be large, you
* should use POST rather than GET when calling UploadSigningCertificate.
* For information about setting up signatures and authorization through
* the API, go to Signing AWS API Requests in the AWS General Reference.
* For general information about using the Query API with IAM, go to
* Making Query Requests in Using IAM.
* </p>
*
* @param uploadSigningCertificateRequest Container for the necessary
* parameters to execute the UploadSigningCertificate operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* UploadSigningCertificate service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<UploadSigningCertificateResult> uploadSigningCertificateAsync(
final UploadSigningCertificateRequest uploadSigningCertificateRequest,
final AsyncHandler<UploadSigningCertificateRequest, UploadSigningCertificateResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<UploadSigningCertificateResult>() {
public UploadSigningCertificateResult call() throws Exception {
UploadSigningCertificateResult result;
try {
result = uploadSigningCertificate(uploadSigningCertificateRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(uploadSigningCertificateRequest, result);
return result;
}
});
}
/**
* <p>
* Deletes the specified instance profile. The instance profile must not
* have an associated role.
* </p>
* <p>
* <b>IMPORTANT:</b>Make sure you do not have any Amazon EC2 instances
* running with the instance profile you are about to delete. Deleting a
* role or instance profile that is associated with a running instance
* will break any applications running on the instance.
* </p>
* <p>
* For more information about instance profiles, go to <a
* mazonwebservices.com/IAM/latest/UserGuide/AboutInstanceProfiles.html">
* About Instance Profiles </a> .
* </p>
*
* @param deleteInstanceProfileRequest Container for the necessary
* parameters to execute the DeleteInstanceProfile operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* DeleteInstanceProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteInstanceProfileAsync(final DeleteInstanceProfileRequest deleteInstanceProfileRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
deleteInstanceProfile(deleteInstanceProfileRequest);
return null;
}
});
}
/**
* <p>
* Deletes the specified instance profile. The instance profile must not
* have an associated role.
* </p>
* <p>
* <b>IMPORTANT:</b>Make sure you do not have any Amazon EC2 instances
* running with the instance profile you are about to delete. Deleting a
* role or instance profile that is associated with a running instance
* will break any applications running on the instance.
* </p>
* <p>
* For more information about instance profiles, go to <a
* mazonwebservices.com/IAM/latest/UserGuide/AboutInstanceProfiles.html">
* About Instance Profiles </a> .
* </p>
*
* @param deleteInstanceProfileRequest Container for the necessary
* parameters to execute the DeleteInstanceProfile operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteInstanceProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteInstanceProfileAsync(
final DeleteInstanceProfileRequest deleteInstanceProfileRequest,
final AsyncHandler<DeleteInstanceProfileRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
deleteInstanceProfile(deleteInstanceProfileRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteInstanceProfileRequest, null);
return null;
}
});
}
/**
* <p>
* Creates a new role for your AWS account. For more information about
* roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> . For information about limitations on role
* names and the number of roles you can create, go to <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* The policy grants permission to an EC2 instance to assume the role.
* The policy is URL-encoded according to RFC 3986. For more information
* about RFC 3986, go to <a href="http://www.faqs.org/rfcs/rfc3986.html">
* http://www.faqs.org/rfcs/rfc3986.html </a> . Currently, only EC2
* instances can assume roles.
* </p>
*
* @param createRoleRequest Container for the necessary parameters to
* execute the CreateRole operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* CreateRole service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<CreateRoleResult> createRoleAsync(final CreateRoleRequest createRoleRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<CreateRoleResult>() {
public CreateRoleResult call() throws Exception {
return createRole(createRoleRequest);
}
});
}
/**
* <p>
* Creates a new role for your AWS account. For more information about
* roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> . For information about limitations on role
* names and the number of roles you can create, go to <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* The policy grants permission to an EC2 instance to assume the role.
* The policy is URL-encoded according to RFC 3986. For more information
* about RFC 3986, go to <a href="http://www.faqs.org/rfcs/rfc3986.html">
* http://www.faqs.org/rfcs/rfc3986.html </a> . Currently, only EC2
* instances can assume roles.
* </p>
*
* @param createRoleRequest Container for the necessary parameters to
* execute the CreateRole operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* CreateRole service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<CreateRoleResult> createRoleAsync(
final CreateRoleRequest createRoleRequest,
final AsyncHandler<CreateRoleRequest, CreateRoleResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<CreateRoleResult>() {
public CreateRoleResult call() throws Exception {
CreateRoleResult result;
try {
result = createRole(createRoleRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(createRoleRequest, result);
return result;
}
});
}
/**
* <p>
* Changes the password for the specified user.
* </p>
*
* @param updateLoginProfileRequest Container for the necessary
* parameters to execute the UpdateLoginProfile operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* UpdateLoginProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateLoginProfileAsync(final UpdateLoginProfileRequest updateLoginProfileRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
updateLoginProfile(updateLoginProfileRequest);
return null;
}
});
}
/**
* <p>
* Changes the password for the specified user.
* </p>
*
* @param updateLoginProfileRequest Container for the necessary
* parameters to execute the UpdateLoginProfile operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* UpdateLoginProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateLoginProfileAsync(
final UpdateLoginProfileRequest updateLoginProfileRequest,
final AsyncHandler<UpdateLoginProfileRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
updateLoginProfile(updateLoginProfileRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(updateLoginProfileRequest, null);
return null;
}
});
}
/**
* <p>
* Deletes the password for the specified user, which terminates the
* user's ability to access AWS services through the AWS Management
* Console.
* </p>
* <p>
* <b>IMPORTANT:</b>Deleting a user's password does not prevent a user
* from accessing IAM through the command line interface or the API. To
* prevent all user access you must also either make the access key
* inactive or delete it. For more information about making keys
* inactive or deleting them, see UpdateAccessKey and DeleteAccessKey.
* </p>
*
* @param deleteLoginProfileRequest Container for the necessary
* parameters to execute the DeleteLoginProfile operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* DeleteLoginProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteLoginProfileAsync(final DeleteLoginProfileRequest deleteLoginProfileRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
deleteLoginProfile(deleteLoginProfileRequest);
return null;
}
});
}
/**
* <p>
* Deletes the password for the specified user, which terminates the
* user's ability to access AWS services through the AWS Management
* Console.
* </p>
* <p>
* <b>IMPORTANT:</b>Deleting a user's password does not prevent a user
* from accessing IAM through the command line interface or the API. To
* prevent all user access you must also either make the access key
* inactive or delete it. For more information about making keys
* inactive or deleting them, see UpdateAccessKey and DeleteAccessKey.
* </p>
*
* @param deleteLoginProfileRequest Container for the necessary
* parameters to execute the DeleteLoginProfile operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteLoginProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteLoginProfileAsync(
final DeleteLoginProfileRequest deleteLoginProfileRequest,
final AsyncHandler<DeleteLoginProfileRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
deleteLoginProfile(deleteLoginProfileRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteLoginProfileRequest, null);
return null;
}
});
}
/**
* <p>
* Changes the password of the IAM user calling
* <code>ChangePassword</code> . The root account password is not
* affected by this action. For information about modifying passwords,
* see <a
* amazonwebservices.com/IAM/latest/UserGuide/Using_ManagingLogins.html">
* Managing Passwords </a> .
* </p>
*
* @param changePasswordRequest Container for the necessary parameters to
* execute the ChangePassword operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ChangePassword service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> changePasswordAsync(final ChangePasswordRequest changePasswordRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
changePassword(changePasswordRequest);
return null;
}
});
}
/**
* <p>
* Changes the password of the IAM user calling
* <code>ChangePassword</code> . The root account password is not
* affected by this action. For information about modifying passwords,
* see <a
* amazonwebservices.com/IAM/latest/UserGuide/Using_ManagingLogins.html">
* Managing Passwords </a> .
* </p>
*
* @param changePasswordRequest Container for the necessary parameters to
* execute the ChangePassword operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ChangePassword service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> changePasswordAsync(
final ChangePasswordRequest changePasswordRequest,
final AsyncHandler<ChangePasswordRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
changePassword(changePasswordRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(changePasswordRequest, null);
return null;
}
});
}
/**
* <p>
* Retrieves information about the specified server certificate.
* </p>
*
* @param getServerCertificateRequest Container for the necessary
* parameters to execute the GetServerCertificate operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* GetServerCertificate service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetServerCertificateResult> getServerCertificateAsync(final GetServerCertificateRequest getServerCertificateRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetServerCertificateResult>() {
public GetServerCertificateResult call() throws Exception {
return getServerCertificate(getServerCertificateRequest);
}
});
}
/**
* <p>
* Retrieves information about the specified server certificate.
* </p>
*
* @param getServerCertificateRequest Container for the necessary
* parameters to execute the GetServerCertificate operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetServerCertificate service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetServerCertificateResult> getServerCertificateAsync(
final GetServerCertificateRequest getServerCertificateRequest,
final AsyncHandler<GetServerCertificateRequest, GetServerCertificateResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetServerCertificateResult>() {
public GetServerCertificateResult call() throws Exception {
GetServerCertificateResult result;
try {
result = getServerCertificate(getServerCertificateRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getServerCertificateRequest, result);
return result;
}
});
}
/**
* <p>
* Adds (or updates) a policy document associated with the specified
* group. For information about policies, refer to <a
* ebservices.com/IAM/latest/UserGuide/index.html?PoliciesOverview.html">
* Overview of Policies </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* For information about limits on the number of policies you can
* associate with a group, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* <b>NOTE:</b>Because policy documents can be large, you should use POST
* rather than GET when calling PutGroupPolicy. For information about
* setting up signatures and authorization through the API, go to Signing
* AWS API Requests in the AWS General Reference. For general information
* about using the Query API with IAM, go to Making Query Requests in
* Using IAM.
* </p>
*
* @param putGroupPolicyRequest Container for the necessary parameters to
* execute the PutGroupPolicy operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* PutGroupPolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> putGroupPolicyAsync(final PutGroupPolicyRequest putGroupPolicyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
putGroupPolicy(putGroupPolicyRequest);
return null;
}
});
}
/**
* <p>
* Adds (or updates) a policy document associated with the specified
* group. For information about policies, refer to <a
* ebservices.com/IAM/latest/UserGuide/index.html?PoliciesOverview.html">
* Overview of Policies </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* For information about limits on the number of policies you can
* associate with a group, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
* <p>
* <b>NOTE:</b>Because policy documents can be large, you should use POST
* rather than GET when calling PutGroupPolicy. For information about
* setting up signatures and authorization through the API, go to Signing
* AWS API Requests in the AWS General Reference. For general information
* about using the Query API with IAM, go to Making Query Requests in
* Using IAM.
* </p>
*
* @param putGroupPolicyRequest Container for the necessary parameters to
* execute the PutGroupPolicy operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* PutGroupPolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> putGroupPolicyAsync(
final PutGroupPolicyRequest putGroupPolicyRequest,
final AsyncHandler<PutGroupPolicyRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
putGroupPolicy(putGroupPolicyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(putGroupPolicyRequest, null);
return null;
}
});
}
/**
* <p>
* Deletes the specified signing certificate associated with the
* specified user.
* </p>
* <p>
* If you do not specify a user name, IAM determines the user name
* implicitly based on the AWS Access Key ID signing the request. Because
* this action works for access keys under the AWS account, you can use
* this API to manage root credentials even if the AWS account has no
* associated users.
* </p>
*
* @param deleteSigningCertificateRequest Container for the necessary
* parameters to execute the DeleteSigningCertificate operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* DeleteSigningCertificate service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteSigningCertificateAsync(final DeleteSigningCertificateRequest deleteSigningCertificateRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
deleteSigningCertificate(deleteSigningCertificateRequest);
return null;
}
});
}
/**
* <p>
* Deletes the specified signing certificate associated with the
* specified user.
* </p>
* <p>
* If you do not specify a user name, IAM determines the user name
* implicitly based on the AWS Access Key ID signing the request. Because
* this action works for access keys under the AWS account, you can use
* this API to manage root credentials even if the AWS account has no
* associated users.
* </p>
*
* @param deleteSigningCertificateRequest Container for the necessary
* parameters to execute the DeleteSigningCertificate operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteSigningCertificate service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteSigningCertificateAsync(
final DeleteSigningCertificateRequest deleteSigningCertificateRequest,
final AsyncHandler<DeleteSigningCertificateRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
deleteSigningCertificate(deleteSigningCertificateRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteSigningCertificateRequest, null);
return null;
}
});
}
/**
* <p>
* Lists the names of the policies associated with the specified user. If
* there are none, the action returns an empty list.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listUserPoliciesRequest Container for the necessary parameters
* to execute the ListUserPolicies operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ListUserPolicies service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListUserPoliciesResult> listUserPoliciesAsync(final ListUserPoliciesRequest listUserPoliciesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListUserPoliciesResult>() {
public ListUserPoliciesResult call() throws Exception {
return listUserPolicies(listUserPoliciesRequest);
}
});
}
/**
* <p>
* Lists the names of the policies associated with the specified user. If
* there are none, the action returns an empty list.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listUserPoliciesRequest Container for the necessary parameters
* to execute the ListUserPolicies operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListUserPolicies service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListUserPoliciesResult> listUserPoliciesAsync(
final ListUserPoliciesRequest listUserPoliciesRequest,
final AsyncHandler<ListUserPoliciesRequest, ListUserPoliciesResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListUserPoliciesResult>() {
public ListUserPoliciesResult call() throws Exception {
ListUserPoliciesResult result;
try {
result = listUserPolicies(listUserPoliciesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listUserPoliciesRequest, result);
return result;
}
});
}
/**
* <p>
* Returns information about the Access Key IDs associated with the
* specified user. If there are none, the action returns an empty list.
* </p>
* <p>
* Although each user is limited to a small number of keys, you can still
* paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
* <p>
* If the <code>UserName</code> field is not specified, the UserName is
* determined implicitly based on the AWS Access Key ID used to sign the
* request. Because this action works for access keys under the AWS
* account, this API can be used to manage root credentials even if the
* AWS account has no associated users.
* </p>
* <p>
* <b>NOTE:</b>To ensure the security of your AWS account, the secret
* access key is accessible only during key and user creation.
* </p>
*
* @param listAccessKeysRequest Container for the necessary parameters to
* execute the ListAccessKeys operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ListAccessKeys service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListAccessKeysResult> listAccessKeysAsync(final ListAccessKeysRequest listAccessKeysRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListAccessKeysResult>() {
public ListAccessKeysResult call() throws Exception {
return listAccessKeys(listAccessKeysRequest);
}
});
}
/**
* <p>
* Returns information about the Access Key IDs associated with the
* specified user. If there are none, the action returns an empty list.
* </p>
* <p>
* Although each user is limited to a small number of keys, you can still
* paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
* <p>
* If the <code>UserName</code> field is not specified, the UserName is
* determined implicitly based on the AWS Access Key ID used to sign the
* request. Because this action works for access keys under the AWS
* account, this API can be used to manage root credentials even if the
* AWS account has no associated users.
* </p>
* <p>
* <b>NOTE:</b>To ensure the security of your AWS account, the secret
* access key is accessible only during key and user creation.
* </p>
*
* @param listAccessKeysRequest Container for the necessary parameters to
* execute the ListAccessKeys operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListAccessKeys service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListAccessKeysResult> listAccessKeysAsync(
final ListAccessKeysRequest listAccessKeysRequest,
final AsyncHandler<ListAccessKeysRequest, ListAccessKeysResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListAccessKeysResult>() {
public ListAccessKeysResult call() throws Exception {
ListAccessKeysResult result;
try {
result = listAccessKeys(listAccessKeysRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listAccessKeysRequest, result);
return result;
}
});
}
/**
* <p>
* Lists the groups the specified user belongs to.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listGroupsForUserRequest Container for the necessary parameters
* to execute the ListGroupsForUser operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ListGroupsForUser service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListGroupsForUserResult> listGroupsForUserAsync(final ListGroupsForUserRequest listGroupsForUserRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListGroupsForUserResult>() {
public ListGroupsForUserResult call() throws Exception {
return listGroupsForUser(listGroupsForUserRequest);
}
});
}
/**
* <p>
* Lists the groups the specified user belongs to.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listGroupsForUserRequest Container for the necessary parameters
* to execute the ListGroupsForUser operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListGroupsForUser service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListGroupsForUserResult> listGroupsForUserAsync(
final ListGroupsForUserRequest listGroupsForUserRequest,
final AsyncHandler<ListGroupsForUserRequest, ListGroupsForUserResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListGroupsForUserResult>() {
public ListGroupsForUserResult call() throws Exception {
ListGroupsForUserResult result;
try {
result = listGroupsForUser(listGroupsForUserRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listGroupsForUserRequest, result);
return result;
}
});
}
/**
* <p>
* Adds the specified role to the specified instance profile. For more
* information about roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> . For more information about instance
* profiles, go to <a
* mazonwebservices.com/IAM/latest/UserGuide/AboutInstanceProfiles.html">
* About Instance Profiles </a> .
* </p>
*
* @param addRoleToInstanceProfileRequest Container for the necessary
* parameters to execute the AddRoleToInstanceProfile operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* AddRoleToInstanceProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> addRoleToInstanceProfileAsync(final AddRoleToInstanceProfileRequest addRoleToInstanceProfileRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
addRoleToInstanceProfile(addRoleToInstanceProfileRequest);
return null;
}
});
}
/**
* <p>
* Adds the specified role to the specified instance profile. For more
* information about roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> . For more information about instance
* profiles, go to <a
* mazonwebservices.com/IAM/latest/UserGuide/AboutInstanceProfiles.html">
* About Instance Profiles </a> .
* </p>
*
* @param addRoleToInstanceProfileRequest Container for the necessary
* parameters to execute the AddRoleToInstanceProfile operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* AddRoleToInstanceProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> addRoleToInstanceProfileAsync(
final AddRoleToInstanceProfileRequest addRoleToInstanceProfileRequest,
final AsyncHandler<AddRoleToInstanceProfileRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
addRoleToInstanceProfile(addRoleToInstanceProfileRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(addRoleToInstanceProfileRequest, null);
return null;
}
});
}
/**
* <p>
* Retrieves the specified policy document for the specified group. The
* returned policy is URL-encoded according to RFC 3986. For more
* information about RFC 3986, go to <a
* href="http://www.faqs.org/rfcs/rfc3986.html">
* http://www.faqs.org/rfcs/rfc3986.html </a> .
* </p>
*
* @param getGroupPolicyRequest Container for the necessary parameters to
* execute the GetGroupPolicy operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* GetGroupPolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetGroupPolicyResult> getGroupPolicyAsync(final GetGroupPolicyRequest getGroupPolicyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetGroupPolicyResult>() {
public GetGroupPolicyResult call() throws Exception {
return getGroupPolicy(getGroupPolicyRequest);
}
});
}
/**
* <p>
* Retrieves the specified policy document for the specified group. The
* returned policy is URL-encoded according to RFC 3986. For more
* information about RFC 3986, go to <a
* href="http://www.faqs.org/rfcs/rfc3986.html">
* http://www.faqs.org/rfcs/rfc3986.html </a> .
* </p>
*
* @param getGroupPolicyRequest Container for the necessary parameters to
* execute the GetGroupPolicy operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetGroupPolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetGroupPolicyResult> getGroupPolicyAsync(
final GetGroupPolicyRequest getGroupPolicyRequest,
final AsyncHandler<GetGroupPolicyRequest, GetGroupPolicyResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetGroupPolicyResult>() {
public GetGroupPolicyResult call() throws Exception {
GetGroupPolicyResult result;
try {
result = getGroupPolicy(getGroupPolicyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getGroupPolicyRequest, result);
return result;
}
});
}
/**
* <p>
* Retrieves the specified policy document for the specified role. For
* more information about roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> .
* </p>
* <p>
* The returned policy is URL-encoded according to RFC 3986. For more
* information about RFC 3986, go to <a
* href="http://www.faqs.org/rfcs/rfc3986.html">
* http://www.faqs.org/rfcs/rfc3986.html </a> .
* </p>
*
* @param getRolePolicyRequest Container for the necessary parameters to
* execute the GetRolePolicy operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* GetRolePolicy service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetRolePolicyResult> getRolePolicyAsync(final GetRolePolicyRequest getRolePolicyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetRolePolicyResult>() {
public GetRolePolicyResult call() throws Exception {
return getRolePolicy(getRolePolicyRequest);
}
});
}
/**
* <p>
* Retrieves the specified policy document for the specified role. For
* more information about roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> .
* </p>
* <p>
* The returned policy is URL-encoded according to RFC 3986. For more
* information about RFC 3986, go to <a
* href="http://www.faqs.org/rfcs/rfc3986.html">
* http://www.faqs.org/rfcs/rfc3986.html </a> .
* </p>
*
* @param getRolePolicyRequest Container for the necessary parameters to
* execute the GetRolePolicy operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetRolePolicy service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetRolePolicyResult> getRolePolicyAsync(
final GetRolePolicyRequest getRolePolicyRequest,
final AsyncHandler<GetRolePolicyRequest, GetRolePolicyResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetRolePolicyResult>() {
public GetRolePolicyResult call() throws Exception {
GetRolePolicyResult result;
try {
result = getRolePolicy(getRolePolicyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getRolePolicyRequest, result);
return result;
}
});
}
/**
* <p>
* Lists the instance profiles that have the specified associated role.
* If there are none, the action returns an empty list. For more
* information about instance profiles, go to <a
* mazonwebservices.com/IAM/latest/UserGuide/AboutInstanceProfiles.html">
* About Instance Profiles </a> .
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listInstanceProfilesForRoleRequest Container for the necessary
* parameters to execute the ListInstanceProfilesForRole operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ListInstanceProfilesForRole service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListInstanceProfilesForRoleResult> listInstanceProfilesForRoleAsync(final ListInstanceProfilesForRoleRequest listInstanceProfilesForRoleRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListInstanceProfilesForRoleResult>() {
public ListInstanceProfilesForRoleResult call() throws Exception {
return listInstanceProfilesForRole(listInstanceProfilesForRoleRequest);
}
});
}
/**
* <p>
* Lists the instance profiles that have the specified associated role.
* If there are none, the action returns an empty list. For more
* information about instance profiles, go to <a
* mazonwebservices.com/IAM/latest/UserGuide/AboutInstanceProfiles.html">
* About Instance Profiles </a> .
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listInstanceProfilesForRoleRequest Container for the necessary
* parameters to execute the ListInstanceProfilesForRole operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListInstanceProfilesForRole service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListInstanceProfilesForRoleResult> listInstanceProfilesForRoleAsync(
final ListInstanceProfilesForRoleRequest listInstanceProfilesForRoleRequest,
final AsyncHandler<ListInstanceProfilesForRoleRequest, ListInstanceProfilesForRoleResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListInstanceProfilesForRoleResult>() {
public ListInstanceProfilesForRoleResult call() throws Exception {
ListInstanceProfilesForRoleResult result;
try {
result = listInstanceProfilesForRole(listInstanceProfilesForRoleRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listInstanceProfilesForRoleRequest, result);
return result;
}
});
}
/**
* <p>
* Lists the virtual MFA devices under the AWS account by assignment
* status. If you do not specify an assignment status, the action returns
* a list of all virtual MFA devices. Assignment status can be
* <code>Assigned</code> ,
*
* <code>Unassigned</code> , or <code>Any</code> .
*
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listVirtualMFADevicesRequest Container for the necessary
* parameters to execute the ListVirtualMFADevices operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ListVirtualMFADevices service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListVirtualMFADevicesResult> listVirtualMFADevicesAsync(final ListVirtualMFADevicesRequest listVirtualMFADevicesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListVirtualMFADevicesResult>() {
public ListVirtualMFADevicesResult call() throws Exception {
return listVirtualMFADevices(listVirtualMFADevicesRequest);
}
});
}
/**
* <p>
* Lists the virtual MFA devices under the AWS account by assignment
* status. If you do not specify an assignment status, the action returns
* a list of all virtual MFA devices. Assignment status can be
* <code>Assigned</code> ,
*
* <code>Unassigned</code> , or <code>Any</code> .
*
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listVirtualMFADevicesRequest Container for the necessary
* parameters to execute the ListVirtualMFADevices operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListVirtualMFADevices service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListVirtualMFADevicesResult> listVirtualMFADevicesAsync(
final ListVirtualMFADevicesRequest listVirtualMFADevicesRequest,
final AsyncHandler<ListVirtualMFADevicesRequest, ListVirtualMFADevicesResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListVirtualMFADevicesResult>() {
public ListVirtualMFADevicesResult call() throws Exception {
ListVirtualMFADevicesResult result;
try {
result = listVirtualMFADevices(listVirtualMFADevicesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listVirtualMFADevicesRequest, result);
return result;
}
});
}
/**
* <p>
* Deletes the specified policy associated with the specified role.
* </p>
*
* @param deleteRolePolicyRequest Container for the necessary parameters
* to execute the DeleteRolePolicy operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* DeleteRolePolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteRolePolicyAsync(final DeleteRolePolicyRequest deleteRolePolicyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
deleteRolePolicy(deleteRolePolicyRequest);
return null;
}
});
}
/**
* <p>
* Deletes the specified policy associated with the specified role.
* </p>
*
* @param deleteRolePolicyRequest Container for the necessary parameters
* to execute the DeleteRolePolicy operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteRolePolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> deleteRolePolicyAsync(
final DeleteRolePolicyRequest deleteRolePolicyRequest,
final AsyncHandler<DeleteRolePolicyRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
deleteRolePolicy(deleteRolePolicyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteRolePolicyRequest, null);
return null;
}
});
}
/**
* <p>
* Creates a new instance profile. For information about instance
* profiles, go to <a
* mazonwebservices.com/IAM/latest/UserGuide/AboutInstanceProfiles.html">
* About Instance Profiles </a> .
* </p>
* <p>
* For information about the number of instance profiles you can create,
* see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
*
* @param createInstanceProfileRequest Container for the necessary
* parameters to execute the CreateInstanceProfile operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* CreateInstanceProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<CreateInstanceProfileResult> createInstanceProfileAsync(final CreateInstanceProfileRequest createInstanceProfileRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<CreateInstanceProfileResult>() {
public CreateInstanceProfileResult call() throws Exception {
return createInstanceProfile(createInstanceProfileRequest);
}
});
}
/**
* <p>
* Creates a new instance profile. For information about instance
* profiles, go to <a
* mazonwebservices.com/IAM/latest/UserGuide/AboutInstanceProfiles.html">
* About Instance Profiles </a> .
* </p>
* <p>
* For information about the number of instance profiles you can create,
* see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
*
* @param createInstanceProfileRequest Container for the necessary
* parameters to execute the CreateInstanceProfile operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* CreateInstanceProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<CreateInstanceProfileResult> createInstanceProfileAsync(
final CreateInstanceProfileRequest createInstanceProfileRequest,
final AsyncHandler<CreateInstanceProfileRequest, CreateInstanceProfileResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<CreateInstanceProfileResult>() {
public CreateInstanceProfileResult call() throws Exception {
CreateInstanceProfileResult result;
try {
result = createInstanceProfile(createInstanceProfileRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(createInstanceProfileRequest, result);
return result;
}
});
}
/**
* <p>
* Lists the names of the policies associated with the specified group.
* If there are none, the action returns an empty list.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listGroupPoliciesRequest Container for the necessary parameters
* to execute the ListGroupPolicies operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ListGroupPolicies service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListGroupPoliciesResult> listGroupPoliciesAsync(final ListGroupPoliciesRequest listGroupPoliciesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListGroupPoliciesResult>() {
public ListGroupPoliciesResult call() throws Exception {
return listGroupPolicies(listGroupPoliciesRequest);
}
});
}
/**
* <p>
* Lists the names of the policies associated with the specified group.
* If there are none, the action returns an empty list.
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
*
* @param listGroupPoliciesRequest Container for the necessary parameters
* to execute the ListGroupPolicies operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListGroupPolicies service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListGroupPoliciesResult> listGroupPoliciesAsync(
final ListGroupPoliciesRequest listGroupPoliciesRequest,
final AsyncHandler<ListGroupPoliciesRequest, ListGroupPoliciesResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListGroupPoliciesResult>() {
public ListGroupPoliciesResult call() throws Exception {
ListGroupPoliciesResult result;
try {
result = listGroupPolicies(listGroupPoliciesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listGroupPoliciesRequest, result);
return result;
}
});
}
/**
* <p>
* Creates a password for the specified user, giving the user the ability
* to access AWS services through the AWS Management Console. For more
* information about managing passwords, see <a
* rvices.com/IAM/latest/UserGuide/index.html?Using_ManagingLogins.html">
* Managing Passwords </a> in <i>Using IAM</i> .
* </p>
*
* @param createLoginProfileRequest Container for the necessary
* parameters to execute the CreateLoginProfile operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* CreateLoginProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<CreateLoginProfileResult> createLoginProfileAsync(final CreateLoginProfileRequest createLoginProfileRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<CreateLoginProfileResult>() {
public CreateLoginProfileResult call() throws Exception {
return createLoginProfile(createLoginProfileRequest);
}
});
}
/**
* <p>
* Creates a password for the specified user, giving the user the ability
* to access AWS services through the AWS Management Console. For more
* information about managing passwords, see <a
* rvices.com/IAM/latest/UserGuide/index.html?Using_ManagingLogins.html">
* Managing Passwords </a> in <i>Using IAM</i> .
* </p>
*
* @param createLoginProfileRequest Container for the necessary
* parameters to execute the CreateLoginProfile operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* CreateLoginProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<CreateLoginProfileResult> createLoginProfileAsync(
final CreateLoginProfileRequest createLoginProfileRequest,
final AsyncHandler<CreateLoginProfileRequest, CreateLoginProfileResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<CreateLoginProfileResult>() {
public CreateLoginProfileResult call() throws Exception {
CreateLoginProfileResult result;
try {
result = createLoginProfile(createLoginProfileRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(createLoginProfileRequest, result);
return result;
}
});
}
/**
* <p>
* Removes the specified role from the specified instance profile.
* </p>
* <p>
* <b>IMPORTANT:</b>Make sure you do not have any Amazon EC2 instances
* running with the role you are about to remove from the instance
* profile. Removing a role from an instance profile that is associated
* with a running instance will break any applications running on the
* instance.
* </p>
* <p>
* For more information about roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> . For more information about instance
* profiles, go to <a
* mazonwebservices.com/IAM/latest/UserGuide/AboutInstanceProfiles.html">
* About Instance Profiles </a> .
* </p>
*
* @param removeRoleFromInstanceProfileRequest Container for the
* necessary parameters to execute the RemoveRoleFromInstanceProfile
* operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* RemoveRoleFromInstanceProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> removeRoleFromInstanceProfileAsync(final RemoveRoleFromInstanceProfileRequest removeRoleFromInstanceProfileRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
removeRoleFromInstanceProfile(removeRoleFromInstanceProfileRequest);
return null;
}
});
}
/**
* <p>
* Removes the specified role from the specified instance profile.
* </p>
* <p>
* <b>IMPORTANT:</b>Make sure you do not have any Amazon EC2 instances
* running with the role you are about to remove from the instance
* profile. Removing a role from an instance profile that is associated
* with a running instance will break any applications running on the
* instance.
* </p>
* <p>
* For more information about roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> . For more information about instance
* profiles, go to <a
* mazonwebservices.com/IAM/latest/UserGuide/AboutInstanceProfiles.html">
* About Instance Profiles </a> .
* </p>
*
* @param removeRoleFromInstanceProfileRequest Container for the
* necessary parameters to execute the RemoveRoleFromInstanceProfile
* operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* RemoveRoleFromInstanceProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> removeRoleFromInstanceProfileAsync(
final RemoveRoleFromInstanceProfileRequest removeRoleFromInstanceProfileRequest,
final AsyncHandler<RemoveRoleFromInstanceProfileRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
removeRoleFromInstanceProfile(removeRoleFromInstanceProfileRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(removeRoleFromInstanceProfileRequest, null);
return null;
}
});
}
/**
* <p>
* Updates the password policy settings for the account. For more
* information about using a password policy, go to <a
* ervices.com/IAM/latest/UserGuide/Using_ManagingPasswordPolicies.html">
* Managing an IAM Password Policy </a> .
* </p>
*
* @param updateAccountPasswordPolicyRequest Container for the necessary
* parameters to execute the UpdateAccountPasswordPolicy operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* UpdateAccountPasswordPolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateAccountPasswordPolicyAsync(final UpdateAccountPasswordPolicyRequest updateAccountPasswordPolicyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
updateAccountPasswordPolicy(updateAccountPasswordPolicyRequest);
return null;
}
});
}
/**
* <p>
* Updates the password policy settings for the account. For more
* information about using a password policy, go to <a
* ervices.com/IAM/latest/UserGuide/Using_ManagingPasswordPolicies.html">
* Managing an IAM Password Policy </a> .
* </p>
*
* @param updateAccountPasswordPolicyRequest Container for the necessary
* parameters to execute the UpdateAccountPasswordPolicy operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* UpdateAccountPasswordPolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateAccountPasswordPolicyAsync(
final UpdateAccountPasswordPolicyRequest updateAccountPasswordPolicyRequest,
final AsyncHandler<UpdateAccountPasswordPolicyRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
updateAccountPasswordPolicy(updateAccountPasswordPolicyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(updateAccountPasswordPolicyRequest, null);
return null;
}
});
}
/**
* <p>
* Updates the policy that grants an entity permission to assume a role.
* Currently, only an Amazon EC2 instance can assume a role. For more
* information about roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> .
* </p>
*
* @param updateAssumeRolePolicyRequest Container for the necessary
* parameters to execute the UpdateAssumeRolePolicy operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* UpdateAssumeRolePolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateAssumeRolePolicyAsync(final UpdateAssumeRolePolicyRequest updateAssumeRolePolicyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
updateAssumeRolePolicy(updateAssumeRolePolicyRequest);
return null;
}
});
}
/**
* <p>
* Updates the policy that grants an entity permission to assume a role.
* Currently, only an Amazon EC2 instance can assume a role. For more
* information about roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> .
* </p>
*
* @param updateAssumeRolePolicyRequest Container for the necessary
* parameters to execute the UpdateAssumeRolePolicy operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* UpdateAssumeRolePolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<Void> updateAssumeRolePolicyAsync(
final UpdateAssumeRolePolicyRequest updateAssumeRolePolicyRequest,
final AsyncHandler<UpdateAssumeRolePolicyRequest, Void> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<Void>() {
public Void call() throws Exception {
try {
updateAssumeRolePolicy(updateAssumeRolePolicyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(updateAssumeRolePolicyRequest, null);
return null;
}
});
}
/**
* <p>
* Retrieves information about the specified instance profile, including
* the instance profile's path, GUID, ARN, and role. For more information
* about instance profiles, go to <a
* mazonwebservices.com/IAM/latest/UserGuide/AboutInstanceProfiles.html">
* About Instance Profiles </a> . For more information about ARNs, go to
* <a
* ces.com/IAM/latest/UserGuide/Using_Identifiers.html#Identifiers_ARNs">
* ARNs </a> .
* </p>
*
* @param getInstanceProfileRequest Container for the necessary
* parameters to execute the GetInstanceProfile operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* GetInstanceProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetInstanceProfileResult> getInstanceProfileAsync(final GetInstanceProfileRequest getInstanceProfileRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetInstanceProfileResult>() {
public GetInstanceProfileResult call() throws Exception {
return getInstanceProfile(getInstanceProfileRequest);
}
});
}
/**
* <p>
* Retrieves information about the specified instance profile, including
* the instance profile's path, GUID, ARN, and role. For more information
* about instance profiles, go to <a
* mazonwebservices.com/IAM/latest/UserGuide/AboutInstanceProfiles.html">
* About Instance Profiles </a> . For more information about ARNs, go to
* <a
* ces.com/IAM/latest/UserGuide/Using_Identifiers.html#Identifiers_ARNs">
* ARNs </a> .
* </p>
*
* @param getInstanceProfileRequest Container for the necessary
* parameters to execute the GetInstanceProfile operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetInstanceProfile service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetInstanceProfileResult> getInstanceProfileAsync(
final GetInstanceProfileRequest getInstanceProfileRequest,
final AsyncHandler<GetInstanceProfileRequest, GetInstanceProfileResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetInstanceProfileResult>() {
public GetInstanceProfileResult call() throws Exception {
GetInstanceProfileResult result;
try {
result = getInstanceProfile(getInstanceProfileRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getInstanceProfileRequest, result);
return result;
}
});
}
/**
* <p>
* Lists the roles that have the specified path prefix. If there are
* none, the action returns an empty list. For more information about
* roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> .
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
* <p>
* The returned policy is URL-encoded according to RFC 3986. For more
* information about RFC 3986, go to <a
* href="http://www.faqs.org/rfcs/rfc3986.html">
* http://www.faqs.org/rfcs/rfc3986.html </a> .
* </p>
*
* @param listRolesRequest Container for the necessary parameters to
* execute the ListRoles operation on AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* ListRoles service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListRolesResult> listRolesAsync(final ListRolesRequest listRolesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListRolesResult>() {
public ListRolesResult call() throws Exception {
return listRoles(listRolesRequest);
}
});
}
/**
* <p>
* Lists the roles that have the specified path prefix. If there are
* none, the action returns an empty list. For more information about
* roles, go to <a
* ocs.amazonwebservices.com/IAM/latest/UserGuide/WorkingWithRoles.html">
* Working with Roles </a> .
* </p>
* <p>
* You can paginate the results using the <code>MaxItems</code> and
* <code>Marker</code> parameters.
* </p>
* <p>
* The returned policy is URL-encoded according to RFC 3986. For more
* information about RFC 3986, go to <a
* href="http://www.faqs.org/rfcs/rfc3986.html">
* http://www.faqs.org/rfcs/rfc3986.html </a> .
* </p>
*
* @param listRolesRequest Container for the necessary parameters to
* execute the ListRoles operation on AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListRoles service method, as returned by AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<ListRolesResult> listRolesAsync(
final ListRolesRequest listRolesRequest,
final AsyncHandler<ListRolesRequest, ListRolesResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<ListRolesResult>() {
public ListRolesResult call() throws Exception {
ListRolesResult result;
try {
result = listRoles(listRolesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listRolesRequest, result);
return result;
}
});
}
/**
* <p>
* Retrieves account level information about account entity usage and IAM
* quotas.
* </p>
* <p>
* For information about limitations on IAM entities, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
*
* @param getAccountSummaryRequest Container for the necessary parameters
* to execute the GetAccountSummary operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* GetAccountSummary service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetAccountSummaryResult> getAccountSummaryAsync(final GetAccountSummaryRequest getAccountSummaryRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetAccountSummaryResult>() {
public GetAccountSummaryResult call() throws Exception {
return getAccountSummary(getAccountSummaryRequest);
}
});
}
/**
* <p>
* Retrieves account level information about account entity usage and IAM
* quotas.
* </p>
* <p>
* For information about limitations on IAM entities, see <a
* vices.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">
* Limitations on IAM Entities </a> in <i>Using AWS Identity and Access
* Management</i> .
* </p>
*
* @param getAccountSummaryRequest Container for the necessary parameters
* to execute the GetAccountSummary operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetAccountSummary service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetAccountSummaryResult> getAccountSummaryAsync(
final GetAccountSummaryRequest getAccountSummaryRequest,
final AsyncHandler<GetAccountSummaryRequest, GetAccountSummaryResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetAccountSummaryResult>() {
public GetAccountSummaryResult call() throws Exception {
GetAccountSummaryResult result;
try {
result = getAccountSummary(getAccountSummaryRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getAccountSummaryRequest, result);
return result;
}
});
}
/**
* <p>
* Retrieves the password policy for the AWS account. For more
* information about using a password policy, go to <a
* ervices.com/IAM/latest/UserGuide/Using_ManagingPasswordPolicies.html">
* Managing an IAM Password Policy </a> .
* </p>
*
* @param getAccountPasswordPolicyRequest Container for the necessary
* parameters to execute the GetAccountPasswordPolicy operation on
* AmazonIdentityManagement.
*
* @return A Java Future object containing the response from the
* GetAccountPasswordPolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetAccountPasswordPolicyResult> getAccountPasswordPolicyAsync(final GetAccountPasswordPolicyRequest getAccountPasswordPolicyRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetAccountPasswordPolicyResult>() {
public GetAccountPasswordPolicyResult call() throws Exception {
return getAccountPasswordPolicy(getAccountPasswordPolicyRequest);
}
});
}
/**
* <p>
* Retrieves the password policy for the AWS account. For more
* information about using a password policy, go to <a
* ervices.com/IAM/latest/UserGuide/Using_ManagingPasswordPolicies.html">
* Managing an IAM Password Policy </a> .
* </p>
*
* @param getAccountPasswordPolicyRequest Container for the necessary
* parameters to execute the GetAccountPasswordPolicy operation on
* AmazonIdentityManagement.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* GetAccountPasswordPolicy service method, as returned by
* AmazonIdentityManagement.
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonIdentityManagement indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future<GetAccountPasswordPolicyResult> getAccountPasswordPolicyAsync(
final GetAccountPasswordPolicyRequest getAccountPasswordPolicyRequest,
final AsyncHandler<GetAccountPasswordPolicyRequest, GetAccountPasswordPolicyResult> asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable<GetAccountPasswordPolicyResult>() {
public GetAccountPasswordPolicyResult call() throws Exception {
GetAccountPasswordPolicyResult result;
try {
result = getAccountPasswordPolicy(getAccountPasswordPolicyRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getAccountPasswordPolicyRequest, result);
return result;
}
});
}
}