com.amazonaws.services.cognitoidp.AWSCognitoIdentityProviderAsyncClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-cognitoidp Show documentation
/*
* Copyright 2019-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.cognitoidp;
import static java.util.concurrent.Executors.newFixedThreadPool;
import javax.annotation.Generated;
import com.amazonaws.services.cognitoidp.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.ClientConfiguration;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import java.util.concurrent.ExecutorService;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
/**
* Client for accessing Amazon Cognito Identity Provider asynchronously. Each asynchronous method will return a Java
* Future object representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to
* receive notification when an asynchronous operation completes.
*
*
* With the Amazon Cognito user pools API, you can configure user pools and authenticate users. To authenticate users
* from third-party identity providers (IdPs) in this API, you can link IdP users to native user profiles. Learn more about the authentication and authorization of federated users
* at Adding
* user pool sign-in through a third party and in the User pool federation endpoints and hosted UI reference.
*
*
* This API reference provides detailed information about API operations and object types in Amazon Cognito.
*
*
* Along with resource management operations, the Amazon Cognito user pools API includes classes of operations and
* authorization models for client-side and server-side authentication of users. You can interact with operations in the
* Amazon Cognito user pools API as any of the following subjects.
*
*
* -
*
* An administrator who wants to configure user pools, app clients, users, groups, or other user pool functions.
*
*
* -
*
* A server-side app, like a web application, that wants to use its Amazon Web Services privileges to manage,
* authenticate, or authorize a user.
*
*
* -
*
* A client-side app, like a mobile app, that wants to make unauthenticated requests to manage, authenticate, or
* authorize a user.
*
*
*
*
* For more information, see Using the Amazon
* Cognito user pools API and user pool endpoints in the Amazon Cognito Developer Guide.
*
*
* With your Amazon Web Services SDK, you can build the logic to support operational flows in every use case for this
* API. You can also make direct REST API requests to Amazon Cognito user pools service endpoints. The following links can get you started with the
* CognitoIdentityProvider client in other supported Amazon Web Services SDKs.
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
*
*
* To get started with an Amazon Web Services SDK, see Tools to Build
* on Amazon Web Services. For example actions and scenarios, see Code
* examples for Amazon Cognito Identity Provider using Amazon Web Services SDKs.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSCognitoIdentityProviderAsyncClient extends AWSCognitoIdentityProviderClient implements AWSCognitoIdentityProviderAsync {
private static final int DEFAULT_THREAD_POOL_SIZE = 50;
private final java.util.concurrent.ExecutorService executorService;
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider. A credentials
* provider chain will be used that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
* Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
* maximum number of concurrent connections to the service).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AWSCognitoIdentityProviderAsyncClientBuilder#defaultClient()}
*/
@Deprecated
public AWSCognitoIdentityProviderAsyncClient() {
this(DefaultAWSCredentialsProviderChain.getInstance());
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider. A credentials
* provider chain will be used that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
* Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the
* maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}.
*
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon Cognito Identity Provider
* (ex: proxy settings, retry counts, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AWSCognitoIdentityProviderAsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AWSCognitoIdentityProviderAsyncClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* specified AWS account credentials.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
* maximum number of concurrent connections to the service).
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AWSCognitoIdentityProviderAsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AWSCognitoIdentityProviderAsyncClient(AWSCredentials awsCredentials) {
this(awsCredentials, newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* specified AWS account credentials and executor service. Default client settings will be used.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AWSCognitoIdentityProviderAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSCognitoIdentityProviderAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AWSCognitoIdentityProviderAsyncClient(AWSCredentials awsCredentials, ExecutorService executorService) {
this(awsCredentials, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* specified AWS account credentials, executor service, and client configuration options.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings, etc).
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AWSCognitoIdentityProviderAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSCognitoIdentityProviderAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AWSCognitoIdentityProviderAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AWSCognitoIdentityProviderAsyncClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentials, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* specified AWS account credentials provider. Default client settings will be used.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
* maximum number of concurrent connections to the service).
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AWSCognitoIdentityProviderAsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AWSCognitoIdentityProviderAsyncClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* provided AWS account credentials provider and client configuration options.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the
* maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
* @deprecated use {@link AWSCognitoIdentityProviderAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSCognitoIdentityProviderAsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AWSCognitoIdentityProviderAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* specified AWS account credentials provider and executor service. Default client settings will be used.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AWSCognitoIdentityProviderAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSCognitoIdentityProviderAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AWSCognitoIdentityProviderAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ExecutorService executorService) {
this(awsCredentialsProvider, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* specified AWS account credentials provider, executor service, and client configuration options.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings, etc).
* @param executorService
* The executor service by which all asynchronous requests will be executed.
* @deprecated use {@link AWSCognitoIdentityProviderAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSCognitoIdentityProviderAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AWSCognitoIdentityProviderAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AWSCognitoIdentityProviderAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration,
ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
public static AWSCognitoIdentityProviderAsyncClientBuilder asyncBuilder() {
return AWSCognitoIdentityProviderAsyncClientBuilder.standard();
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AWSCognitoIdentityProviderAsyncClient(AwsAsyncClientParams asyncClientParams) {
this(asyncClientParams, false);
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity Provider using the
* specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
* @param endpointDiscoveryEnabled
* true will enable endpoint discovery if the service supports it.
*/
AWSCognitoIdentityProviderAsyncClient(AwsAsyncClientParams asyncClientParams, boolean endpointDiscoveryEnabled) {
super(asyncClientParams, endpointDiscoveryEnabled);
this.executorService = asyncClientParams.getExecutor();
}
/**
* Returns the executor service used by this client to execute async requests.
*
* @return The executor service used by this client to execute async requests.
*/
public ExecutorService getExecutorService() {
return executorService;
}
@Override
public java.util.concurrent.Future addCustomAttributesAsync(AddCustomAttributesRequest request) {
return addCustomAttributesAsync(request, null);
}
@Override
public java.util.concurrent.Future addCustomAttributesAsync(final AddCustomAttributesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AddCustomAttributesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AddCustomAttributesResult call() throws Exception {
AddCustomAttributesResult result = null;
try {
result = executeAddCustomAttributes(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminAddUserToGroupAsync(AdminAddUserToGroupRequest request) {
return adminAddUserToGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future adminAddUserToGroupAsync(final AdminAddUserToGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminAddUserToGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminAddUserToGroupResult call() throws Exception {
AdminAddUserToGroupResult result = null;
try {
result = executeAdminAddUserToGroup(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminConfirmSignUpAsync(AdminConfirmSignUpRequest request) {
return adminConfirmSignUpAsync(request, null);
}
@Override
public java.util.concurrent.Future adminConfirmSignUpAsync(final AdminConfirmSignUpRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminConfirmSignUpRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminConfirmSignUpResult call() throws Exception {
AdminConfirmSignUpResult result = null;
try {
result = executeAdminConfirmSignUp(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminCreateUserAsync(AdminCreateUserRequest request) {
return adminCreateUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminCreateUserAsync(final AdminCreateUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminCreateUserRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminCreateUserResult call() throws Exception {
AdminCreateUserResult result = null;
try {
result = executeAdminCreateUser(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminDeleteUserAsync(AdminDeleteUserRequest request) {
return adminDeleteUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminDeleteUserAsync(final AdminDeleteUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminDeleteUserRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminDeleteUserResult call() throws Exception {
AdminDeleteUserResult result = null;
try {
result = executeAdminDeleteUser(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminDeleteUserAttributesAsync(AdminDeleteUserAttributesRequest request) {
return adminDeleteUserAttributesAsync(request, null);
}
@Override
public java.util.concurrent.Future adminDeleteUserAttributesAsync(final AdminDeleteUserAttributesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminDeleteUserAttributesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminDeleteUserAttributesResult call() throws Exception {
AdminDeleteUserAttributesResult result = null;
try {
result = executeAdminDeleteUserAttributes(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminDisableProviderForUserAsync(AdminDisableProviderForUserRequest request) {
return adminDisableProviderForUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminDisableProviderForUserAsync(final AdminDisableProviderForUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminDisableProviderForUserRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminDisableProviderForUserResult call() throws Exception {
AdminDisableProviderForUserResult result = null;
try {
result = executeAdminDisableProviderForUser(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminDisableUserAsync(AdminDisableUserRequest request) {
return adminDisableUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminDisableUserAsync(final AdminDisableUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminDisableUserRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminDisableUserResult call() throws Exception {
AdminDisableUserResult result = null;
try {
result = executeAdminDisableUser(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminEnableUserAsync(AdminEnableUserRequest request) {
return adminEnableUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminEnableUserAsync(final AdminEnableUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminEnableUserRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminEnableUserResult call() throws Exception {
AdminEnableUserResult result = null;
try {
result = executeAdminEnableUser(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminForgetDeviceAsync(AdminForgetDeviceRequest request) {
return adminForgetDeviceAsync(request, null);
}
@Override
public java.util.concurrent.Future adminForgetDeviceAsync(final AdminForgetDeviceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminForgetDeviceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminForgetDeviceResult call() throws Exception {
AdminForgetDeviceResult result = null;
try {
result = executeAdminForgetDevice(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminGetDeviceAsync(AdminGetDeviceRequest request) {
return adminGetDeviceAsync(request, null);
}
@Override
public java.util.concurrent.Future adminGetDeviceAsync(final AdminGetDeviceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminGetDeviceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminGetDeviceResult call() throws Exception {
AdminGetDeviceResult result = null;
try {
result = executeAdminGetDevice(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminGetUserAsync(AdminGetUserRequest request) {
return adminGetUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminGetUserAsync(final AdminGetUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminGetUserRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminGetUserResult call() throws Exception {
AdminGetUserResult result = null;
try {
result = executeAdminGetUser(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminInitiateAuthAsync(AdminInitiateAuthRequest request) {
return adminInitiateAuthAsync(request, null);
}
@Override
public java.util.concurrent.Future adminInitiateAuthAsync(final AdminInitiateAuthRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminInitiateAuthRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminInitiateAuthResult call() throws Exception {
AdminInitiateAuthResult result = null;
try {
result = executeAdminInitiateAuth(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminLinkProviderForUserAsync(AdminLinkProviderForUserRequest request) {
return adminLinkProviderForUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminLinkProviderForUserAsync(final AdminLinkProviderForUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminLinkProviderForUserRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminLinkProviderForUserResult call() throws Exception {
AdminLinkProviderForUserResult result = null;
try {
result = executeAdminLinkProviderForUser(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminListDevicesAsync(AdminListDevicesRequest request) {
return adminListDevicesAsync(request, null);
}
@Override
public java.util.concurrent.Future adminListDevicesAsync(final AdminListDevicesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminListDevicesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminListDevicesResult call() throws Exception {
AdminListDevicesResult result = null;
try {
result = executeAdminListDevices(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminListGroupsForUserAsync(AdminListGroupsForUserRequest request) {
return adminListGroupsForUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminListGroupsForUserAsync(final AdminListGroupsForUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminListGroupsForUserRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminListGroupsForUserResult call() throws Exception {
AdminListGroupsForUserResult result = null;
try {
result = executeAdminListGroupsForUser(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminListUserAuthEventsAsync(AdminListUserAuthEventsRequest request) {
return adminListUserAuthEventsAsync(request, null);
}
@Override
public java.util.concurrent.Future adminListUserAuthEventsAsync(final AdminListUserAuthEventsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminListUserAuthEventsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminListUserAuthEventsResult call() throws Exception {
AdminListUserAuthEventsResult result = null;
try {
result = executeAdminListUserAuthEvents(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminRemoveUserFromGroupAsync(AdminRemoveUserFromGroupRequest request) {
return adminRemoveUserFromGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future adminRemoveUserFromGroupAsync(final AdminRemoveUserFromGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminRemoveUserFromGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminRemoveUserFromGroupResult call() throws Exception {
AdminRemoveUserFromGroupResult result = null;
try {
result = executeAdminRemoveUserFromGroup(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminResetUserPasswordAsync(AdminResetUserPasswordRequest request) {
return adminResetUserPasswordAsync(request, null);
}
@Override
public java.util.concurrent.Future adminResetUserPasswordAsync(final AdminResetUserPasswordRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminResetUserPasswordRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminResetUserPasswordResult call() throws Exception {
AdminResetUserPasswordResult result = null;
try {
result = executeAdminResetUserPassword(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminRespondToAuthChallengeAsync(AdminRespondToAuthChallengeRequest request) {
return adminRespondToAuthChallengeAsync(request, null);
}
@Override
public java.util.concurrent.Future adminRespondToAuthChallengeAsync(final AdminRespondToAuthChallengeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminRespondToAuthChallengeRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminRespondToAuthChallengeResult call() throws Exception {
AdminRespondToAuthChallengeResult result = null;
try {
result = executeAdminRespondToAuthChallenge(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminSetUserMFAPreferenceAsync(AdminSetUserMFAPreferenceRequest request) {
return adminSetUserMFAPreferenceAsync(request, null);
}
@Override
public java.util.concurrent.Future adminSetUserMFAPreferenceAsync(final AdminSetUserMFAPreferenceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminSetUserMFAPreferenceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminSetUserMFAPreferenceResult call() throws Exception {
AdminSetUserMFAPreferenceResult result = null;
try {
result = executeAdminSetUserMFAPreference(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminSetUserPasswordAsync(AdminSetUserPasswordRequest request) {
return adminSetUserPasswordAsync(request, null);
}
@Override
public java.util.concurrent.Future adminSetUserPasswordAsync(final AdminSetUserPasswordRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminSetUserPasswordRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminSetUserPasswordResult call() throws Exception {
AdminSetUserPasswordResult result = null;
try {
result = executeAdminSetUserPassword(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminSetUserSettingsAsync(AdminSetUserSettingsRequest request) {
return adminSetUserSettingsAsync(request, null);
}
@Override
public java.util.concurrent.Future adminSetUserSettingsAsync(final AdminSetUserSettingsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminSetUserSettingsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminSetUserSettingsResult call() throws Exception {
AdminSetUserSettingsResult result = null;
try {
result = executeAdminSetUserSettings(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminUpdateAuthEventFeedbackAsync(AdminUpdateAuthEventFeedbackRequest request) {
return adminUpdateAuthEventFeedbackAsync(request, null);
}
@Override
public java.util.concurrent.Future adminUpdateAuthEventFeedbackAsync(final AdminUpdateAuthEventFeedbackRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminUpdateAuthEventFeedbackRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminUpdateAuthEventFeedbackResult call() throws Exception {
AdminUpdateAuthEventFeedbackResult result = null;
try {
result = executeAdminUpdateAuthEventFeedback(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminUpdateDeviceStatusAsync(AdminUpdateDeviceStatusRequest request) {
return adminUpdateDeviceStatusAsync(request, null);
}
@Override
public java.util.concurrent.Future adminUpdateDeviceStatusAsync(final AdminUpdateDeviceStatusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminUpdateDeviceStatusRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminUpdateDeviceStatusResult call() throws Exception {
AdminUpdateDeviceStatusResult result = null;
try {
result = executeAdminUpdateDeviceStatus(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminUpdateUserAttributesAsync(AdminUpdateUserAttributesRequest request) {
return adminUpdateUserAttributesAsync(request, null);
}
@Override
public java.util.concurrent.Future adminUpdateUserAttributesAsync(final AdminUpdateUserAttributesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminUpdateUserAttributesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminUpdateUserAttributesResult call() throws Exception {
AdminUpdateUserAttributesResult result = null;
try {
result = executeAdminUpdateUserAttributes(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminUserGlobalSignOutAsync(AdminUserGlobalSignOutRequest request) {
return adminUserGlobalSignOutAsync(request, null);
}
@Override
public java.util.concurrent.Future adminUserGlobalSignOutAsync(final AdminUserGlobalSignOutRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AdminUserGlobalSignOutRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AdminUserGlobalSignOutResult call() throws Exception {
AdminUserGlobalSignOutResult result = null;
try {
result = executeAdminUserGlobalSignOut(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future associateSoftwareTokenAsync(AssociateSoftwareTokenRequest request) {
return associateSoftwareTokenAsync(request, null);
}
@Override
public java.util.concurrent.Future associateSoftwareTokenAsync(final AssociateSoftwareTokenRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AssociateSoftwareTokenRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AssociateSoftwareTokenResult call() throws Exception {
AssociateSoftwareTokenResult result = null;
try {
result = executeAssociateSoftwareToken(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future changePasswordAsync(ChangePasswordRequest request) {
return changePasswordAsync(request, null);
}
@Override
public java.util.concurrent.Future changePasswordAsync(final ChangePasswordRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ChangePasswordRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ChangePasswordResult call() throws Exception {
ChangePasswordResult result = null;
try {
result = executeChangePassword(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future confirmDeviceAsync(ConfirmDeviceRequest request) {
return confirmDeviceAsync(request, null);
}
@Override
public java.util.concurrent.Future confirmDeviceAsync(final ConfirmDeviceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ConfirmDeviceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ConfirmDeviceResult call() throws Exception {
ConfirmDeviceResult result = null;
try {
result = executeConfirmDevice(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future confirmForgotPasswordAsync(ConfirmForgotPasswordRequest request) {
return confirmForgotPasswordAsync(request, null);
}
@Override
public java.util.concurrent.Future confirmForgotPasswordAsync(final ConfirmForgotPasswordRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ConfirmForgotPasswordRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ConfirmForgotPasswordResult call() throws Exception {
ConfirmForgotPasswordResult result = null;
try {
result = executeConfirmForgotPassword(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future confirmSignUpAsync(ConfirmSignUpRequest request) {
return confirmSignUpAsync(request, null);
}
@Override
public java.util.concurrent.Future confirmSignUpAsync(final ConfirmSignUpRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ConfirmSignUpRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ConfirmSignUpResult call() throws Exception {
ConfirmSignUpResult result = null;
try {
result = executeConfirmSignUp(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createGroupAsync(CreateGroupRequest request) {
return createGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future createGroupAsync(final CreateGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateGroupResult call() throws Exception {
CreateGroupResult result = null;
try {
result = executeCreateGroup(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createIdentityProviderAsync(CreateIdentityProviderRequest request) {
return createIdentityProviderAsync(request, null);
}
@Override
public java.util.concurrent.Future createIdentityProviderAsync(final CreateIdentityProviderRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateIdentityProviderRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateIdentityProviderResult call() throws Exception {
CreateIdentityProviderResult result = null;
try {
result = executeCreateIdentityProvider(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createResourceServerAsync(CreateResourceServerRequest request) {
return createResourceServerAsync(request, null);
}
@Override
public java.util.concurrent.Future createResourceServerAsync(final CreateResourceServerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateResourceServerRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateResourceServerResult call() throws Exception {
CreateResourceServerResult result = null;
try {
result = executeCreateResourceServer(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createUserImportJobAsync(CreateUserImportJobRequest request) {
return createUserImportJobAsync(request, null);
}
@Override
public java.util.concurrent.Future createUserImportJobAsync(final CreateUserImportJobRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateUserImportJobRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateUserImportJobResult call() throws Exception {
CreateUserImportJobResult result = null;
try {
result = executeCreateUserImportJob(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createUserPoolAsync(CreateUserPoolRequest request) {
return createUserPoolAsync(request, null);
}
@Override
public java.util.concurrent.Future createUserPoolAsync(final CreateUserPoolRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateUserPoolRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateUserPoolResult call() throws Exception {
CreateUserPoolResult result = null;
try {
result = executeCreateUserPool(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createUserPoolClientAsync(CreateUserPoolClientRequest request) {
return createUserPoolClientAsync(request, null);
}
@Override
public java.util.concurrent.Future createUserPoolClientAsync(final CreateUserPoolClientRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateUserPoolClientRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateUserPoolClientResult call() throws Exception {
CreateUserPoolClientResult result = null;
try {
result = executeCreateUserPoolClient(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createUserPoolDomainAsync(CreateUserPoolDomainRequest request) {
return createUserPoolDomainAsync(request, null);
}
@Override
public java.util.concurrent.Future createUserPoolDomainAsync(final CreateUserPoolDomainRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateUserPoolDomainRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateUserPoolDomainResult call() throws Exception {
CreateUserPoolDomainResult result = null;
try {
result = executeCreateUserPoolDomain(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteGroupAsync(DeleteGroupRequest request) {
return deleteGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteGroupAsync(final DeleteGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteGroupResult call() throws Exception {
DeleteGroupResult result = null;
try {
result = executeDeleteGroup(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteIdentityProviderAsync(DeleteIdentityProviderRequest request) {
return deleteIdentityProviderAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteIdentityProviderAsync(final DeleteIdentityProviderRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteIdentityProviderRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteIdentityProviderResult call() throws Exception {
DeleteIdentityProviderResult result = null;
try {
result = executeDeleteIdentityProvider(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteResourceServerAsync(DeleteResourceServerRequest request) {
return deleteResourceServerAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteResourceServerAsync(final DeleteResourceServerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteResourceServerRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteResourceServerResult call() throws Exception {
DeleteResourceServerResult result = null;
try {
result = executeDeleteResourceServer(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteUserAsync(DeleteUserRequest request) {
return deleteUserAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserAsync(final DeleteUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteUserRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserResult call() throws Exception {
DeleteUserResult result = null;
try {
result = executeDeleteUser(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteUserAttributesAsync(DeleteUserAttributesRequest request) {
return deleteUserAttributesAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserAttributesAsync(final DeleteUserAttributesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteUserAttributesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserAttributesResult call() throws Exception {
DeleteUserAttributesResult result = null;
try {
result = executeDeleteUserAttributes(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteUserPoolAsync(DeleteUserPoolRequest request) {
return deleteUserPoolAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserPoolAsync(final DeleteUserPoolRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteUserPoolRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserPoolResult call() throws Exception {
DeleteUserPoolResult result = null;
try {
result = executeDeleteUserPool(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteUserPoolClientAsync(DeleteUserPoolClientRequest request) {
return deleteUserPoolClientAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserPoolClientAsync(final DeleteUserPoolClientRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteUserPoolClientRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserPoolClientResult call() throws Exception {
DeleteUserPoolClientResult result = null;
try {
result = executeDeleteUserPoolClient(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteUserPoolDomainAsync(DeleteUserPoolDomainRequest request) {
return deleteUserPoolDomainAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserPoolDomainAsync(final DeleteUserPoolDomainRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteUserPoolDomainRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserPoolDomainResult call() throws Exception {
DeleteUserPoolDomainResult result = null;
try {
result = executeDeleteUserPoolDomain(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeIdentityProviderAsync(DescribeIdentityProviderRequest request) {
return describeIdentityProviderAsync(request, null);
}
@Override
public java.util.concurrent.Future describeIdentityProviderAsync(final DescribeIdentityProviderRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeIdentityProviderRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeIdentityProviderResult call() throws Exception {
DescribeIdentityProviderResult result = null;
try {
result = executeDescribeIdentityProvider(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeResourceServerAsync(DescribeResourceServerRequest request) {
return describeResourceServerAsync(request, null);
}
@Override
public java.util.concurrent.Future describeResourceServerAsync(final DescribeResourceServerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeResourceServerRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeResourceServerResult call() throws Exception {
DescribeResourceServerResult result = null;
try {
result = executeDescribeResourceServer(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeRiskConfigurationAsync(DescribeRiskConfigurationRequest request) {
return describeRiskConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future describeRiskConfigurationAsync(final DescribeRiskConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeRiskConfigurationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeRiskConfigurationResult call() throws Exception {
DescribeRiskConfigurationResult result = null;
try {
result = executeDescribeRiskConfiguration(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeUserImportJobAsync(DescribeUserImportJobRequest request) {
return describeUserImportJobAsync(request, null);
}
@Override
public java.util.concurrent.Future describeUserImportJobAsync(final DescribeUserImportJobRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeUserImportJobRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeUserImportJobResult call() throws Exception {
DescribeUserImportJobResult result = null;
try {
result = executeDescribeUserImportJob(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeUserPoolAsync(DescribeUserPoolRequest request) {
return describeUserPoolAsync(request, null);
}
@Override
public java.util.concurrent.Future describeUserPoolAsync(final DescribeUserPoolRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeUserPoolRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeUserPoolResult call() throws Exception {
DescribeUserPoolResult result = null;
try {
result = executeDescribeUserPool(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeUserPoolClientAsync(DescribeUserPoolClientRequest request) {
return describeUserPoolClientAsync(request, null);
}
@Override
public java.util.concurrent.Future describeUserPoolClientAsync(final DescribeUserPoolClientRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeUserPoolClientRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeUserPoolClientResult call() throws Exception {
DescribeUserPoolClientResult result = null;
try {
result = executeDescribeUserPoolClient(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeUserPoolDomainAsync(DescribeUserPoolDomainRequest request) {
return describeUserPoolDomainAsync(request, null);
}
@Override
public java.util.concurrent.Future describeUserPoolDomainAsync(final DescribeUserPoolDomainRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeUserPoolDomainRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeUserPoolDomainResult call() throws Exception {
DescribeUserPoolDomainResult result = null;
try {
result = executeDescribeUserPoolDomain(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future forgetDeviceAsync(ForgetDeviceRequest request) {
return forgetDeviceAsync(request, null);
}
@Override
public java.util.concurrent.Future forgetDeviceAsync(final ForgetDeviceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ForgetDeviceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ForgetDeviceResult call() throws Exception {
ForgetDeviceResult result = null;
try {
result = executeForgetDevice(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future forgotPasswordAsync(ForgotPasswordRequest request) {
return forgotPasswordAsync(request, null);
}
@Override
public java.util.concurrent.Future forgotPasswordAsync(final ForgotPasswordRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ForgotPasswordRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ForgotPasswordResult call() throws Exception {
ForgotPasswordResult result = null;
try {
result = executeForgotPassword(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getCSVHeaderAsync(GetCSVHeaderRequest request) {
return getCSVHeaderAsync(request, null);
}
@Override
public java.util.concurrent.Future getCSVHeaderAsync(final GetCSVHeaderRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetCSVHeaderRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetCSVHeaderResult call() throws Exception {
GetCSVHeaderResult result = null;
try {
result = executeGetCSVHeader(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getDeviceAsync(GetDeviceRequest request) {
return getDeviceAsync(request, null);
}
@Override
public java.util.concurrent.Future getDeviceAsync(final GetDeviceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetDeviceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetDeviceResult call() throws Exception {
GetDeviceResult result = null;
try {
result = executeGetDevice(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getGroupAsync(GetGroupRequest request) {
return getGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future getGroupAsync(final GetGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetGroupResult call() throws Exception {
GetGroupResult result = null;
try {
result = executeGetGroup(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getIdentityProviderByIdentifierAsync(
GetIdentityProviderByIdentifierRequest request) {
return getIdentityProviderByIdentifierAsync(request, null);
}
@Override
public java.util.concurrent.Future getIdentityProviderByIdentifierAsync(
final GetIdentityProviderByIdentifierRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetIdentityProviderByIdentifierRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetIdentityProviderByIdentifierResult call() throws Exception {
GetIdentityProviderByIdentifierResult result = null;
try {
result = executeGetIdentityProviderByIdentifier(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getLogDeliveryConfigurationAsync(GetLogDeliveryConfigurationRequest request) {
return getLogDeliveryConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future getLogDeliveryConfigurationAsync(final GetLogDeliveryConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetLogDeliveryConfigurationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetLogDeliveryConfigurationResult call() throws Exception {
GetLogDeliveryConfigurationResult result = null;
try {
result = executeGetLogDeliveryConfiguration(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getSigningCertificateAsync(GetSigningCertificateRequest request) {
return getSigningCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future getSigningCertificateAsync(final GetSigningCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetSigningCertificateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetSigningCertificateResult call() throws Exception {
GetSigningCertificateResult result = null;
try {
result = executeGetSigningCertificate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getUICustomizationAsync(GetUICustomizationRequest request) {
return getUICustomizationAsync(request, null);
}
@Override
public java.util.concurrent.Future