com.amazonaws.services.cognitoidp.AWSCognitoIdentityProviderAsyncClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-cognitoidp Show documentation
/*
* Copyright 2010-2016 Amazon.com, Inc. or its affiliates. All Rights
* Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.amazonaws.services.cognitoidp;
import com.amazonaws.services.cognitoidp.model.*;
import com.amazonaws.annotation.ThreadSafe;
/**
* Interface 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.
*
*
* You can create a user pool in Amazon Cognito Identity to manage directories
* and users. You can authenticate a user to obtain tokens related to user
* identity and access policies.
*
*
* This API reference provides information about user pools in Amazon Cognito
* Identity, which is a new capability that is available as a beta.
*
*/
@ThreadSafe
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)
*/
public AWSCognitoIdentityProviderAsyncClient() {
this(new com.amazonaws.auth.DefaultAWSCredentialsProviderChain());
}
/**
* 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)
*/
public AWSCognitoIdentityProviderAsyncClient(
com.amazonaws.ClientConfiguration clientConfiguration) {
this(new com.amazonaws.auth.DefaultAWSCredentialsProviderChain(),
clientConfiguration, java.util.concurrent.Executors
.newFixedThreadPool(clientConfiguration
.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on 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)
*/
public AWSCognitoIdentityProviderAsyncClient(
com.amazonaws.auth.AWSCredentials awsCredentials) {
this(awsCredentials, java.util.concurrent.Executors
.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on 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.
*/
public AWSCognitoIdentityProviderAsyncClient(
com.amazonaws.auth.AWSCredentials awsCredentials,
java.util.concurrent.ExecutorService executorService) {
this(awsCredentials, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on 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.
*/
public AWSCognitoIdentityProviderAsyncClient(
com.amazonaws.auth.AWSCredentials awsCredentials,
com.amazonaws.ClientConfiguration clientConfiguration,
java.util.concurrent.ExecutorService executorService) {
super(awsCredentials, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on 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)
*/
public AWSCognitoIdentityProviderAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, java.util.concurrent.Executors
.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on 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)
*/
public AWSCognitoIdentityProviderAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
com.amazonaws.ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration,
java.util.concurrent.Executors
.newFixedThreadPool(clientConfiguration
.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on 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.
*/
public AWSCognitoIdentityProviderAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
java.util.concurrent.ExecutorService executorService) {
this(awsCredentialsProvider, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on 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.
*/
public AWSCognitoIdentityProviderAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
com.amazonaws.ClientConfiguration clientConfiguration,
java.util.concurrent.ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
/**
* Returns the executor service used by this client to execute async
* requests.
*
* @return The executor service used by this client to execute async
* requests.
*/
public java.util.concurrent.ExecutorService getExecutorService() {
return executorService;
}
@Override
public java.util.concurrent.Future addCustomAttributesAsync(
AddCustomAttributesRequest request) {
return addCustomAttributesAsync(request, null);
}
@Override
public java.util.concurrent.Future addCustomAttributesAsync(
final AddCustomAttributesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AddCustomAttributesResult call() throws Exception {
AddCustomAttributesResult result;
try {
result = addCustomAttributes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminConfirmSignUpAsync(
AdminConfirmSignUpRequest request) {
return adminConfirmSignUpAsync(request, null);
}
@Override
public java.util.concurrent.Future adminConfirmSignUpAsync(
final AdminConfirmSignUpRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AdminConfirmSignUpResult call() throws Exception {
AdminConfirmSignUpResult result;
try {
result = adminConfirmSignUp(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminDeleteUserAsync(
AdminDeleteUserRequest request) {
return adminDeleteUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminDeleteUserAsync(
final AdminDeleteUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AdminDeleteUserResult call() throws Exception {
AdminDeleteUserResult result;
try {
result = adminDeleteUser(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminDeleteUserAttributesAsync(
AdminDeleteUserAttributesRequest request) {
return adminDeleteUserAttributesAsync(request, null);
}
@Override
public java.util.concurrent.Future adminDeleteUserAttributesAsync(
final AdminDeleteUserAttributesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AdminDeleteUserAttributesResult call()
throws Exception {
AdminDeleteUserAttributesResult result;
try {
result = adminDeleteUserAttributes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminDisableUserAsync(
AdminDisableUserRequest request) {
return adminDisableUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminDisableUserAsync(
final AdminDisableUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AdminDisableUserResult call() throws Exception {
AdminDisableUserResult result;
try {
result = adminDisableUser(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminEnableUserAsync(
AdminEnableUserRequest request) {
return adminEnableUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminEnableUserAsync(
final AdminEnableUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AdminEnableUserResult call() throws Exception {
AdminEnableUserResult result;
try {
result = adminEnableUser(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminGetUserAsync(
AdminGetUserRequest request) {
return adminGetUserAsync(request, null);
}
@Override
public java.util.concurrent.Future adminGetUserAsync(
final AdminGetUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AdminGetUserResult call() throws Exception {
AdminGetUserResult result;
try {
result = adminGetUser(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminResetUserPasswordAsync(
AdminResetUserPasswordRequest request) {
return adminResetUserPasswordAsync(request, null);
}
@Override
public java.util.concurrent.Future adminResetUserPasswordAsync(
final AdminResetUserPasswordRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AdminResetUserPasswordResult call() throws Exception {
AdminResetUserPasswordResult result;
try {
result = adminResetUserPassword(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminSetUserSettingsAsync(
AdminSetUserSettingsRequest request) {
return adminSetUserSettingsAsync(request, null);
}
@Override
public java.util.concurrent.Future adminSetUserSettingsAsync(
final AdminSetUserSettingsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AdminSetUserSettingsResult call() throws Exception {
AdminSetUserSettingsResult result;
try {
result = adminSetUserSettings(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future adminUpdateUserAttributesAsync(
AdminUpdateUserAttributesRequest request) {
return adminUpdateUserAttributesAsync(request, null);
}
@Override
public java.util.concurrent.Future adminUpdateUserAttributesAsync(
final AdminUpdateUserAttributesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AdminUpdateUserAttributesResult call()
throws Exception {
AdminUpdateUserAttributesResult result;
try {
result = adminUpdateUserAttributes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future changePasswordAsync(
ChangePasswordRequest request) {
return changePasswordAsync(request, null);
}
@Override
public java.util.concurrent.Future changePasswordAsync(
final ChangePasswordRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ChangePasswordResult call() throws Exception {
ChangePasswordResult result;
try {
result = changePassword(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future confirmForgotPasswordAsync(
ConfirmForgotPasswordRequest request) {
return confirmForgotPasswordAsync(request, null);
}
@Override
public java.util.concurrent.Future confirmForgotPasswordAsync(
final ConfirmForgotPasswordRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ConfirmForgotPasswordResult call() throws Exception {
ConfirmForgotPasswordResult result;
try {
result = confirmForgotPassword(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future confirmSignUpAsync(
ConfirmSignUpRequest request) {
return confirmSignUpAsync(request, null);
}
@Override
public java.util.concurrent.Future confirmSignUpAsync(
final ConfirmSignUpRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ConfirmSignUpResult call() throws Exception {
ConfirmSignUpResult result;
try {
result = confirmSignUp(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createUserPoolAsync(
CreateUserPoolRequest request) {
return createUserPoolAsync(request, null);
}
@Override
public java.util.concurrent.Future createUserPoolAsync(
final CreateUserPoolRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateUserPoolResult call() throws Exception {
CreateUserPoolResult result;
try {
result = createUserPool(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createUserPoolClientAsync(
CreateUserPoolClientRequest request) {
return createUserPoolClientAsync(request, null);
}
@Override
public java.util.concurrent.Future createUserPoolClientAsync(
final CreateUserPoolClientRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateUserPoolClientResult call() throws Exception {
CreateUserPoolClientResult result;
try {
result = createUserPoolClient(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteUserAsync(
DeleteUserRequest request) {
return deleteUserAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserAsync(
final DeleteUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserResult call() throws Exception {
DeleteUserResult result;
try {
result = deleteUser(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteUserAttributesAsync(
DeleteUserAttributesRequest request) {
return deleteUserAttributesAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserAttributesAsync(
final DeleteUserAttributesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserAttributesResult call() throws Exception {
DeleteUserAttributesResult result;
try {
result = deleteUserAttributes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteUserPoolAsync(
DeleteUserPoolRequest request) {
return deleteUserPoolAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserPoolAsync(
final DeleteUserPoolRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserPoolResult call() throws Exception {
DeleteUserPoolResult result;
try {
result = deleteUserPool(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteUserPoolClientAsync(
DeleteUserPoolClientRequest request) {
return deleteUserPoolClientAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteUserPoolClientAsync(
final DeleteUserPoolClientRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteUserPoolClientResult call() throws Exception {
DeleteUserPoolClientResult result;
try {
result = deleteUserPoolClient(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeUserPoolAsync(
DescribeUserPoolRequest request) {
return describeUserPoolAsync(request, null);
}
@Override
public java.util.concurrent.Future describeUserPoolAsync(
final DescribeUserPoolRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeUserPoolResult call() throws Exception {
DescribeUserPoolResult result;
try {
result = describeUserPool(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeUserPoolClientAsync(
DescribeUserPoolClientRequest request) {
return describeUserPoolClientAsync(request, null);
}
@Override
public java.util.concurrent.Future describeUserPoolClientAsync(
final DescribeUserPoolClientRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeUserPoolClientResult call() throws Exception {
DescribeUserPoolClientResult result;
try {
result = describeUserPoolClient(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future forgotPasswordAsync(
ForgotPasswordRequest request) {
return forgotPasswordAsync(request, null);
}
@Override
public java.util.concurrent.Future forgotPasswordAsync(
final ForgotPasswordRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ForgotPasswordResult call() throws Exception {
ForgotPasswordResult result;
try {
result = forgotPassword(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getUserAsync(
GetUserRequest request) {
return getUserAsync(request, null);
}
@Override
public java.util.concurrent.Future getUserAsync(
final GetUserRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public GetUserResult call() throws Exception {
GetUserResult result;
try {
result = getUser(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getUserAttributeVerificationCodeAsync(
GetUserAttributeVerificationCodeRequest request) {
return getUserAttributeVerificationCodeAsync(request, null);
}
@Override
public java.util.concurrent.Future getUserAttributeVerificationCodeAsync(
final GetUserAttributeVerificationCodeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public GetUserAttributeVerificationCodeResult call()
throws Exception {
GetUserAttributeVerificationCodeResult result;
try {
result = getUserAttributeVerificationCode(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listUserPoolClientsAsync(
ListUserPoolClientsRequest request) {
return listUserPoolClientsAsync(request, null);
}
@Override
public java.util.concurrent.Future listUserPoolClientsAsync(
final ListUserPoolClientsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ListUserPoolClientsResult call() throws Exception {
ListUserPoolClientsResult result;
try {
result = listUserPoolClients(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listUserPoolsAsync(
ListUserPoolsRequest request) {
return listUserPoolsAsync(request, null);
}
@Override
public java.util.concurrent.Future listUserPoolsAsync(
final ListUserPoolsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ListUserPoolsResult call() throws Exception {
ListUserPoolsResult result;
try {
result = listUserPools(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listUsersAsync(
ListUsersRequest request) {
return listUsersAsync(request, null);
}
@Override
public java.util.concurrent.Future listUsersAsync(
final ListUsersRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ListUsersResult call() throws Exception {
ListUsersResult result;
try {
result = listUsers(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future resendConfirmationCodeAsync(
ResendConfirmationCodeRequest request) {
return resendConfirmationCodeAsync(request, null);
}
@Override
public java.util.concurrent.Future resendConfirmationCodeAsync(
final ResendConfirmationCodeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ResendConfirmationCodeResult call() throws Exception {
ResendConfirmationCodeResult result;
try {
result = resendConfirmationCode(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future setUserSettingsAsync(
SetUserSettingsRequest request) {
return setUserSettingsAsync(request, null);
}
@Override
public java.util.concurrent.Future setUserSettingsAsync(
final SetUserSettingsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public SetUserSettingsResult call() throws Exception {
SetUserSettingsResult result;
try {
result = setUserSettings(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future signUpAsync(
SignUpRequest request) {
return signUpAsync(request, null);
}
@Override
public java.util.concurrent.Future signUpAsync(
final SignUpRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public SignUpResult call() throws Exception {
SignUpResult result;
try {
result = signUp(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateUserAttributesAsync(
UpdateUserAttributesRequest request) {
return updateUserAttributesAsync(request, null);
}
@Override
public java.util.concurrent.Future updateUserAttributesAsync(
final UpdateUserAttributesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public UpdateUserAttributesResult call() throws Exception {
UpdateUserAttributesResult result;
try {
result = updateUserAttributes(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateUserPoolAsync(
UpdateUserPoolRequest request) {
return updateUserPoolAsync(request, null);
}
@Override
public java.util.concurrent.Future updateUserPoolAsync(
final UpdateUserPoolRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public UpdateUserPoolResult call() throws Exception {
UpdateUserPoolResult result;
try {
result = updateUserPool(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateUserPoolClientAsync(
UpdateUserPoolClientRequest request) {
return updateUserPoolClientAsync(request, null);
}
@Override
public java.util.concurrent.Future updateUserPoolClientAsync(
final UpdateUserPoolClientRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public UpdateUserPoolClientResult call() throws Exception {
UpdateUserPoolClientResult result;
try {
result = updateUserPoolClient(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future verifyUserAttributeAsync(
VerifyUserAttributeRequest request) {
return verifyUserAttributeAsync(request, null);
}
@Override
public java.util.concurrent.Future verifyUserAttributeAsync(
final VerifyUserAttributeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public VerifyUserAttributeResult call() throws Exception {
VerifyUserAttributeResult result;
try {
result = verifyUserAttribute(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* 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 {@code getExecutorService().shutdown()} followed by
* {@code getExecutorService().awaitTermination()} prior to calling this
* method.
*/
@Override
public void shutdown() {
super.shutdown();
executorService.shutdownNow();
}
}