com.amazonaws.services.directory.AWSDirectoryServiceAsyncClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-directory 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.directory;
import com.amazonaws.services.directory.model.*;
import com.amazonaws.annotation.ThreadSafe;
/**
* Interface for accessing Directory Service asynchronously. Each asynchronous
* method will return a Java Future object representing the asynchronous
* operation; overloads which accept an {@code AsyncHandler} can be used to
* receive notification when an asynchronous operation completes.
*
* AWS Directory Service
*
* This is the AWS Directory Service API Reference. This guide provides
* detailed information about AWS Directory Service operations, data types,
* parameters, and errors.
*
*/
@ThreadSafe
public class AWSDirectoryServiceAsyncClient extends AWSDirectoryServiceClient
implements AWSDirectoryServiceAsync {
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
* Directory Service. 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 AWSDirectoryServiceAsyncClient() {
this(new com.amazonaws.auth.DefaultAWSCredentialsProviderChain());
}
/**
* Constructs a new asynchronous client to invoke service methods on
* Directory Service. 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 Directory Service (ex: proxy settings, retry counts,
* etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSDirectoryServiceAsyncClient(
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
* Directory Service 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 AWSDirectoryServiceAsyncClient(
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
* Directory Service 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 AWSDirectoryServiceAsyncClient(
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
* Directory Service 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 AWSDirectoryServiceAsyncClient(
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
* Directory Service 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 AWSDirectoryServiceAsyncClient(
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
* Directory Service 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 AWSDirectoryServiceAsyncClient(
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
* Directory Service 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 AWSDirectoryServiceAsyncClient(
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
* Directory Service 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 AWSDirectoryServiceAsyncClient(
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 addTagsToResourceAsync(
AddTagsToResourceRequest request) {
return addTagsToResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future addTagsToResourceAsync(
final AddTagsToResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AddTagsToResourceResult call() throws Exception {
AddTagsToResourceResult result;
try {
result = addTagsToResource(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 connectDirectoryAsync(
ConnectDirectoryRequest request) {
return connectDirectoryAsync(request, null);
}
@Override
public java.util.concurrent.Future connectDirectoryAsync(
final ConnectDirectoryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ConnectDirectoryResult call() throws Exception {
ConnectDirectoryResult result;
try {
result = connectDirectory(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 createAliasAsync(
CreateAliasRequest request) {
return createAliasAsync(request, null);
}
@Override
public java.util.concurrent.Future createAliasAsync(
final CreateAliasRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateAliasResult call() throws Exception {
CreateAliasResult result;
try {
result = createAlias(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 createComputerAsync(
CreateComputerRequest request) {
return createComputerAsync(request, null);
}
@Override
public java.util.concurrent.Future createComputerAsync(
final CreateComputerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateComputerResult call() throws Exception {
CreateComputerResult result;
try {
result = createComputer(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 createConditionalForwarderAsync(
CreateConditionalForwarderRequest request) {
return createConditionalForwarderAsync(request, null);
}
@Override
public java.util.concurrent.Future createConditionalForwarderAsync(
final CreateConditionalForwarderRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateConditionalForwarderResult call()
throws Exception {
CreateConditionalForwarderResult result;
try {
result = createConditionalForwarder(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 createDirectoryAsync(
CreateDirectoryRequest request) {
return createDirectoryAsync(request, null);
}
@Override
public java.util.concurrent.Future createDirectoryAsync(
final CreateDirectoryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateDirectoryResult call() throws Exception {
CreateDirectoryResult result;
try {
result = createDirectory(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 createMicrosoftADAsync(
CreateMicrosoftADRequest request) {
return createMicrosoftADAsync(request, null);
}
@Override
public java.util.concurrent.Future createMicrosoftADAsync(
final CreateMicrosoftADRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateMicrosoftADResult call() throws Exception {
CreateMicrosoftADResult result;
try {
result = createMicrosoftAD(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 createSnapshotAsync(
CreateSnapshotRequest request) {
return createSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future createSnapshotAsync(
final CreateSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateSnapshotResult call() throws Exception {
CreateSnapshotResult result;
try {
result = createSnapshot(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 createTrustAsync(
CreateTrustRequest request) {
return createTrustAsync(request, null);
}
@Override
public java.util.concurrent.Future createTrustAsync(
final CreateTrustRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateTrustResult call() throws Exception {
CreateTrustResult result;
try {
result = createTrust(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 deleteConditionalForwarderAsync(
DeleteConditionalForwarderRequest request) {
return deleteConditionalForwarderAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteConditionalForwarderAsync(
final DeleteConditionalForwarderRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteConditionalForwarderResult call()
throws Exception {
DeleteConditionalForwarderResult result;
try {
result = deleteConditionalForwarder(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 deleteDirectoryAsync(
DeleteDirectoryRequest request) {
return deleteDirectoryAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteDirectoryAsync(
final DeleteDirectoryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteDirectoryResult call() throws Exception {
DeleteDirectoryResult result;
try {
result = deleteDirectory(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 deleteSnapshotAsync(
DeleteSnapshotRequest request) {
return deleteSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteSnapshotAsync(
final DeleteSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteSnapshotResult call() throws Exception {
DeleteSnapshotResult result;
try {
result = deleteSnapshot(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 deleteTrustAsync(
DeleteTrustRequest request) {
return deleteTrustAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteTrustAsync(
final DeleteTrustRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteTrustResult call() throws Exception {
DeleteTrustResult result;
try {
result = deleteTrust(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 deregisterEventTopicAsync(
DeregisterEventTopicRequest request) {
return deregisterEventTopicAsync(request, null);
}
@Override
public java.util.concurrent.Future deregisterEventTopicAsync(
final DeregisterEventTopicRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeregisterEventTopicResult call() throws Exception {
DeregisterEventTopicResult result;
try {
result = deregisterEventTopic(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 describeConditionalForwardersAsync(
DescribeConditionalForwardersRequest request) {
return describeConditionalForwardersAsync(request, null);
}
@Override
public java.util.concurrent.Future describeConditionalForwardersAsync(
final DescribeConditionalForwardersRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeConditionalForwardersResult call()
throws Exception {
DescribeConditionalForwardersResult result;
try {
result = describeConditionalForwarders(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 describeDirectoriesAsync(
DescribeDirectoriesRequest request) {
return describeDirectoriesAsync(request, null);
}
@Override
public java.util.concurrent.Future describeDirectoriesAsync(
final DescribeDirectoriesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeDirectoriesResult call() throws Exception {
DescribeDirectoriesResult result;
try {
result = describeDirectories(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeDirectories operation.
*
* @see #describeDirectoriesAsync(DescribeDirectoriesRequest)
*/
@Override
public java.util.concurrent.Future describeDirectoriesAsync() {
return describeDirectoriesAsync(new DescribeDirectoriesRequest());
}
/**
* Simplified method form for invoking the DescribeDirectories operation
* with an AsyncHandler.
*
* @see #describeDirectoriesAsync(DescribeDirectoriesRequest,
* com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeDirectoriesAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeDirectoriesAsync(new DescribeDirectoriesRequest(),
asyncHandler);
}
@Override
public java.util.concurrent.Future describeEventTopicsAsync(
DescribeEventTopicsRequest request) {
return describeEventTopicsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeEventTopicsAsync(
final DescribeEventTopicsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeEventTopicsResult call() throws Exception {
DescribeEventTopicsResult result;
try {
result = describeEventTopics(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 describeSnapshotsAsync(
DescribeSnapshotsRequest request) {
return describeSnapshotsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeSnapshotsAsync(
final DescribeSnapshotsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeSnapshotsResult call() throws Exception {
DescribeSnapshotsResult result;
try {
result = describeSnapshots(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the DescribeSnapshots operation.
*
* @see #describeSnapshotsAsync(DescribeSnapshotsRequest)
*/
@Override
public java.util.concurrent.Future describeSnapshotsAsync() {
return describeSnapshotsAsync(new DescribeSnapshotsRequest());
}
/**
* Simplified method form for invoking the DescribeSnapshots operation with
* an AsyncHandler.
*
* @see #describeSnapshotsAsync(DescribeSnapshotsRequest,
* com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future describeSnapshotsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return describeSnapshotsAsync(new DescribeSnapshotsRequest(),
asyncHandler);
}
@Override
public java.util.concurrent.Future describeTrustsAsync(
DescribeTrustsRequest request) {
return describeTrustsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeTrustsAsync(
final DescribeTrustsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeTrustsResult call() throws Exception {
DescribeTrustsResult result;
try {
result = describeTrusts(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 disableRadiusAsync(
DisableRadiusRequest request) {
return disableRadiusAsync(request, null);
}
@Override
public java.util.concurrent.Future disableRadiusAsync(
final DisableRadiusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DisableRadiusResult call() throws Exception {
DisableRadiusResult result;
try {
result = disableRadius(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 disableSsoAsync(
DisableSsoRequest request) {
return disableSsoAsync(request, null);
}
@Override
public java.util.concurrent.Future disableSsoAsync(
final DisableSsoRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DisableSsoResult call() throws Exception {
DisableSsoResult result;
try {
result = disableSso(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 enableRadiusAsync(
EnableRadiusRequest request) {
return enableRadiusAsync(request, null);
}
@Override
public java.util.concurrent.Future enableRadiusAsync(
final EnableRadiusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public EnableRadiusResult call() throws Exception {
EnableRadiusResult result;
try {
result = enableRadius(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 enableSsoAsync(
EnableSsoRequest request) {
return enableSsoAsync(request, null);
}
@Override
public java.util.concurrent.Future enableSsoAsync(
final EnableSsoRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public EnableSsoResult call() throws Exception {
EnableSsoResult result;
try {
result = enableSso(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 getDirectoryLimitsAsync(
GetDirectoryLimitsRequest request) {
return getDirectoryLimitsAsync(request, null);
}
@Override
public java.util.concurrent.Future getDirectoryLimitsAsync(
final GetDirectoryLimitsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public GetDirectoryLimitsResult call() throws Exception {
GetDirectoryLimitsResult result;
try {
result = getDirectoryLimits(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the GetDirectoryLimits operation.
*
* @see #getDirectoryLimitsAsync(GetDirectoryLimitsRequest)
*/
@Override
public java.util.concurrent.Future getDirectoryLimitsAsync() {
return getDirectoryLimitsAsync(new GetDirectoryLimitsRequest());
}
/**
* Simplified method form for invoking the GetDirectoryLimits operation with
* an AsyncHandler.
*
* @see #getDirectoryLimitsAsync(GetDirectoryLimitsRequest,
* com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future getDirectoryLimitsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return getDirectoryLimitsAsync(new GetDirectoryLimitsRequest(),
asyncHandler);
}
@Override
public java.util.concurrent.Future getSnapshotLimitsAsync(
GetSnapshotLimitsRequest request) {
return getSnapshotLimitsAsync(request, null);
}
@Override
public java.util.concurrent.Future getSnapshotLimitsAsync(
final GetSnapshotLimitsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public GetSnapshotLimitsResult call() throws Exception {
GetSnapshotLimitsResult result;
try {
result = getSnapshotLimits(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 listTagsForResourceAsync(
ListTagsForResourceRequest request) {
return listTagsForResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future listTagsForResourceAsync(
final ListTagsForResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ListTagsForResourceResult call() throws Exception {
ListTagsForResourceResult result;
try {
result = listTagsForResource(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 registerEventTopicAsync(
RegisterEventTopicRequest request) {
return registerEventTopicAsync(request, null);
}
@Override
public java.util.concurrent.Future registerEventTopicAsync(
final RegisterEventTopicRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public RegisterEventTopicResult call() throws Exception {
RegisterEventTopicResult result;
try {
result = registerEventTopic(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 removeTagsFromResourceAsync(
RemoveTagsFromResourceRequest request) {
return removeTagsFromResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future removeTagsFromResourceAsync(
final RemoveTagsFromResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public RemoveTagsFromResourceResult call() throws Exception {
RemoveTagsFromResourceResult result;
try {
result = removeTagsFromResource(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 restoreFromSnapshotAsync(
RestoreFromSnapshotRequest request) {
return restoreFromSnapshotAsync(request, null);
}
@Override
public java.util.concurrent.Future restoreFromSnapshotAsync(
final RestoreFromSnapshotRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public RestoreFromSnapshotResult call() throws Exception {
RestoreFromSnapshotResult result;
try {
result = restoreFromSnapshot(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 updateConditionalForwarderAsync(
UpdateConditionalForwarderRequest request) {
return updateConditionalForwarderAsync(request, null);
}
@Override
public java.util.concurrent.Future updateConditionalForwarderAsync(
final UpdateConditionalForwarderRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public UpdateConditionalForwarderResult call()
throws Exception {
UpdateConditionalForwarderResult result;
try {
result = updateConditionalForwarder(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 updateRadiusAsync(
UpdateRadiusRequest request) {
return updateRadiusAsync(request, null);
}
@Override
public java.util.concurrent.Future updateRadiusAsync(
final UpdateRadiusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public UpdateRadiusResult call() throws Exception {
UpdateRadiusResult result;
try {
result = updateRadius(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 verifyTrustAsync(
VerifyTrustRequest request) {
return verifyTrustAsync(request, null);
}
@Override
public java.util.concurrent.Future verifyTrustAsync(
final VerifyTrustRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public VerifyTrustResult call() throws Exception {
VerifyTrustResult result;
try {
result = verifyTrust(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();
}
}