com.amazonaws.services.iot.AWSIotAsyncClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-iot Show documentation
/*
* Copyright 2011-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.iot;
import com.amazonaws.services.iot.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
/**
* Interface for accessing AWS IoT 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 IoT
*
* AWS IoT provides secure, bi-directional communication between Internet-connected things (such as sensors, actuators,
* embedded devices, or smart appliances) and the AWS cloud. You can discover your custom IoT-Data endpoint to
* communicate with, configure rules for data processing and integration with other services, organize resources
* associated with each thing (Thing Registry), configure logging, and create and manage policies and credentials to
* authenticate things.
*
*
* For more information about how AWS IoT works, see the Developer Guide.
*
*/
@ThreadSafe
public class AWSIotAsyncClient extends AWSIotClient implements AWSIotAsync {
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 AWS IoT. 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 AWSIotAsyncClient() {
this(com.amazonaws.auth.DefaultAWSCredentialsProviderChain.getInstance());
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS IoT. 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 AWS IoT (ex: proxy settings,
* retry counts, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSIotAsyncClient(com.amazonaws.ClientConfiguration clientConfiguration) {
this(com.amazonaws.auth.DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration, java.util.concurrent.Executors
.newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS IoT 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 AWSIotAsyncClient(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 AWS IoT 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 AWSIotAsyncClient(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 AWS IoT 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 AWSIotAsyncClient(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 AWS IoT 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 AWSIotAsyncClient(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 AWS IoT 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 AWSIotAsyncClient(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 AWS IoT 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 AWSIotAsyncClient(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 AWS IoT 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 AWSIotAsyncClient(com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider, com.amazonaws.ClientConfiguration clientConfiguration,
java.util.concurrent.ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS IoT using the specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AWSIotAsyncClient(AwsAsyncClientParams asyncClientParams) {
super(asyncClientParams);
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 java.util.concurrent.ExecutorService getExecutorService() {
return executorService;
}
@Override
public java.util.concurrent.Future acceptCertificateTransferAsync(AcceptCertificateTransferRequest request) {
return acceptCertificateTransferAsync(request, null);
}
@Override
public java.util.concurrent.Future acceptCertificateTransferAsync(final AcceptCertificateTransferRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AcceptCertificateTransferResult call() throws Exception {
AcceptCertificateTransferResult result;
try {
result = acceptCertificateTransfer(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 attachPrincipalPolicyAsync(AttachPrincipalPolicyRequest request) {
return attachPrincipalPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future attachPrincipalPolicyAsync(final AttachPrincipalPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachPrincipalPolicyResult call() throws Exception {
AttachPrincipalPolicyResult result;
try {
result = attachPrincipalPolicy(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 attachThingPrincipalAsync(AttachThingPrincipalRequest request) {
return attachThingPrincipalAsync(request, null);
}
@Override
public java.util.concurrent.Future attachThingPrincipalAsync(final AttachThingPrincipalRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachThingPrincipalResult call() throws Exception {
AttachThingPrincipalResult result;
try {
result = attachThingPrincipal(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 cancelCertificateTransferAsync(CancelCertificateTransferRequest request) {
return cancelCertificateTransferAsync(request, null);
}
@Override
public java.util.concurrent.Future cancelCertificateTransferAsync(final CancelCertificateTransferRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CancelCertificateTransferResult call() throws Exception {
CancelCertificateTransferResult result;
try {
result = cancelCertificateTransfer(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 createCertificateFromCsrAsync(CreateCertificateFromCsrRequest request) {
return createCertificateFromCsrAsync(request, null);
}
@Override
public java.util.concurrent.Future createCertificateFromCsrAsync(final CreateCertificateFromCsrRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateCertificateFromCsrResult call() throws Exception {
CreateCertificateFromCsrResult result;
try {
result = createCertificateFromCsr(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 createKeysAndCertificateAsync(CreateKeysAndCertificateRequest request) {
return createKeysAndCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future createKeysAndCertificateAsync(final CreateKeysAndCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateKeysAndCertificateResult call() throws Exception {
CreateKeysAndCertificateResult result;
try {
result = createKeysAndCertificate(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createPolicyAsync(CreatePolicyRequest request) {
return createPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future createPolicyAsync(final CreatePolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreatePolicyResult call() throws Exception {
CreatePolicyResult result;
try {
result = createPolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createPolicyVersionAsync(CreatePolicyVersionRequest request) {
return createPolicyVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future createPolicyVersionAsync(final CreatePolicyVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreatePolicyVersionResult call() throws Exception {
CreatePolicyVersionResult result;
try {
result = createPolicyVersion(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createThingAsync(CreateThingRequest request) {
return createThingAsync(request, null);
}
@Override
public java.util.concurrent.Future createThingAsync(final CreateThingRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateThingResult call() throws Exception {
CreateThingResult result;
try {
result = createThing(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 createThingTypeAsync(CreateThingTypeRequest request) {
return createThingTypeAsync(request, null);
}
@Override
public java.util.concurrent.Future createThingTypeAsync(final CreateThingTypeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateThingTypeResult call() throws Exception {
CreateThingTypeResult result;
try {
result = createThingType(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 createTopicRuleAsync(CreateTopicRuleRequest request) {
return createTopicRuleAsync(request, null);
}
@Override
public java.util.concurrent.Future createTopicRuleAsync(final CreateTopicRuleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateTopicRuleResult call() throws Exception {
CreateTopicRuleResult result;
try {
result = createTopicRule(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 deleteCACertificateAsync(DeleteCACertificateRequest request) {
return deleteCACertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteCACertificateAsync(final DeleteCACertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteCACertificateResult call() throws Exception {
DeleteCACertificateResult result;
try {
result = deleteCACertificate(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 deleteCertificateAsync(DeleteCertificateRequest request) {
return deleteCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteCertificateAsync(final DeleteCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteCertificateResult call() throws Exception {
DeleteCertificateResult result;
try {
result = deleteCertificate(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deletePolicyAsync(DeletePolicyRequest request) {
return deletePolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future deletePolicyAsync(final DeletePolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeletePolicyResult call() throws Exception {
DeletePolicyResult result;
try {
result = deletePolicy(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deletePolicyVersionAsync(DeletePolicyVersionRequest request) {
return deletePolicyVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future deletePolicyVersionAsync(final DeletePolicyVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeletePolicyVersionResult call() throws Exception {
DeletePolicyVersionResult result;
try {
result = deletePolicyVersion(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteRegistrationCodeAsync(DeleteRegistrationCodeRequest request) {
return deleteRegistrationCodeAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteRegistrationCodeAsync(final DeleteRegistrationCodeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteRegistrationCodeResult call() throws Exception {
DeleteRegistrationCodeResult result;
try {
result = deleteRegistrationCode(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 deleteThingAsync(DeleteThingRequest request) {
return deleteThingAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteThingAsync(final DeleteThingRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteThingResult call() throws Exception {
DeleteThingResult result;
try {
result = deleteThing(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 deleteThingTypeAsync(DeleteThingTypeRequest request) {
return deleteThingTypeAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteThingTypeAsync(final DeleteThingTypeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteThingTypeResult call() throws Exception {
DeleteThingTypeResult result;
try {
result = deleteThingType(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 deleteTopicRuleAsync(DeleteTopicRuleRequest request) {
return deleteTopicRuleAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteTopicRuleAsync(final DeleteTopicRuleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteTopicRuleResult call() throws Exception {
DeleteTopicRuleResult result;
try {
result = deleteTopicRule(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 deprecateThingTypeAsync(DeprecateThingTypeRequest request) {
return deprecateThingTypeAsync(request, null);
}
@Override
public java.util.concurrent.Future deprecateThingTypeAsync(final DeprecateThingTypeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeprecateThingTypeResult call() throws Exception {
DeprecateThingTypeResult result;
try {
result = deprecateThingType(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 describeCACertificateAsync(DescribeCACertificateRequest request) {
return describeCACertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future describeCACertificateAsync(final DescribeCACertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeCACertificateResult call() throws Exception {
DescribeCACertificateResult result;
try {
result = describeCACertificate(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 describeCertificateAsync(DescribeCertificateRequest request) {
return describeCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future describeCertificateAsync(final DescribeCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeCertificateResult call() throws Exception {
DescribeCertificateResult result;
try {
result = describeCertificate(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 describeEndpointAsync(DescribeEndpointRequest request) {
return describeEndpointAsync(request, null);
}
@Override
public java.util.concurrent.Future describeEndpointAsync(final DescribeEndpointRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeEndpointResult call() throws Exception {
DescribeEndpointResult result;
try {
result = describeEndpoint(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 describeThingAsync(DescribeThingRequest request) {
return describeThingAsync(request, null);
}
@Override
public java.util.concurrent.Future describeThingAsync(final DescribeThingRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeThingResult call() throws Exception {
DescribeThingResult result;
try {
result = describeThing(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 describeThingTypeAsync(DescribeThingTypeRequest request) {
return describeThingTypeAsync(request, null);
}
@Override
public java.util.concurrent.Future describeThingTypeAsync(final DescribeThingTypeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeThingTypeResult call() throws Exception {
DescribeThingTypeResult result;
try {
result = describeThingType(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 detachPrincipalPolicyAsync(DetachPrincipalPolicyRequest request) {
return detachPrincipalPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future detachPrincipalPolicyAsync(final DetachPrincipalPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DetachPrincipalPolicyResult call() throws Exception {
DetachPrincipalPolicyResult result;
try {
result = detachPrincipalPolicy(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 detachThingPrincipalAsync(DetachThingPrincipalRequest request) {
return detachThingPrincipalAsync(request, null);
}
@Override
public java.util.concurrent.Future detachThingPrincipalAsync(final DetachThingPrincipalRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DetachThingPrincipalResult call() throws Exception {
DetachThingPrincipalResult result;
try {
result = detachThingPrincipal(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 disableTopicRuleAsync(DisableTopicRuleRequest request) {
return disableTopicRuleAsync(request, null);
}
@Override
public java.util.concurrent.Future disableTopicRuleAsync(final DisableTopicRuleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DisableTopicRuleResult call() throws Exception {
DisableTopicRuleResult result;
try {
result = disableTopicRule(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 enableTopicRuleAsync(EnableTopicRuleRequest request) {
return enableTopicRuleAsync(request, null);
}
@Override
public java.util.concurrent.Future enableTopicRuleAsync(final EnableTopicRuleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public EnableTopicRuleResult call() throws Exception {
EnableTopicRuleResult result;
try {
result = enableTopicRule(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 getLoggingOptionsAsync(GetLoggingOptionsRequest request) {
return getLoggingOptionsAsync(request, null);
}
@Override
public java.util.concurrent.Future getLoggingOptionsAsync(final GetLoggingOptionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetLoggingOptionsResult call() throws Exception {
GetLoggingOptionsResult result;
try {
result = getLoggingOptions(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getPolicyAsync(GetPolicyRequest request) {
return getPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future getPolicyAsync(final GetPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetPolicyResult call() throws Exception {
GetPolicyResult result;
try {
result = getPolicy(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 getPolicyVersionAsync(GetPolicyVersionRequest request) {
return getPolicyVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future getPolicyVersionAsync(final GetPolicyVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetPolicyVersionResult call() throws Exception {
GetPolicyVersionResult result;
try {
result = getPolicyVersion(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 getRegistrationCodeAsync(GetRegistrationCodeRequest request) {
return getRegistrationCodeAsync(request, null);
}
@Override
public java.util.concurrent.Future getRegistrationCodeAsync(final GetRegistrationCodeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetRegistrationCodeResult call() throws Exception {
GetRegistrationCodeResult result;
try {
result = getRegistrationCode(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 getTopicRuleAsync(GetTopicRuleRequest request) {
return getTopicRuleAsync(request, null);
}
@Override
public java.util.concurrent.Future getTopicRuleAsync(final GetTopicRuleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetTopicRuleResult call() throws Exception {
GetTopicRuleResult result;
try {
result = getTopicRule(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 listCACertificatesAsync(ListCACertificatesRequest request) {
return listCACertificatesAsync(request, null);
}
@Override
public java.util.concurrent.Future listCACertificatesAsync(final ListCACertificatesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListCACertificatesResult call() throws Exception {
ListCACertificatesResult result;
try {
result = listCACertificates(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 listCertificatesAsync(ListCertificatesRequest request) {
return listCertificatesAsync(request, null);
}
@Override
public java.util.concurrent.Future listCertificatesAsync(final ListCertificatesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListCertificatesResult call() throws Exception {
ListCertificatesResult result;
try {
result = listCertificates(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 listCertificatesByCAAsync(ListCertificatesByCARequest request) {
return listCertificatesByCAAsync(request, null);
}
@Override
public java.util.concurrent.Future listCertificatesByCAAsync(final ListCertificatesByCARequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListCertificatesByCAResult call() throws Exception {
ListCertificatesByCAResult result;
try {
result = listCertificatesByCA(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 listOutgoingCertificatesAsync(ListOutgoingCertificatesRequest request) {
return listOutgoingCertificatesAsync(request, null);
}
@Override
public java.util.concurrent.Future listOutgoingCertificatesAsync(final ListOutgoingCertificatesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListOutgoingCertificatesResult call() throws Exception {
ListOutgoingCertificatesResult result;
try {
result = listOutgoingCertificates(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 listPoliciesAsync(ListPoliciesRequest request) {
return listPoliciesAsync(request, null);
}
@Override
public java.util.concurrent.Future listPoliciesAsync(final ListPoliciesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListPoliciesResult call() throws Exception {
ListPoliciesResult result;
try {
result = listPolicies(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 listPolicyPrincipalsAsync(ListPolicyPrincipalsRequest request) {
return listPolicyPrincipalsAsync(request, null);
}
@Override
public java.util.concurrent.Future listPolicyPrincipalsAsync(final ListPolicyPrincipalsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListPolicyPrincipalsResult call() throws Exception {
ListPolicyPrincipalsResult result;
try {
result = listPolicyPrincipals(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 listPolicyVersionsAsync(ListPolicyVersionsRequest request) {
return listPolicyVersionsAsync(request, null);
}
@Override
public java.util.concurrent.Future listPolicyVersionsAsync(final ListPolicyVersionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListPolicyVersionsResult call() throws Exception {
ListPolicyVersionsResult result;
try {
result = listPolicyVersions(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 listPrincipalPoliciesAsync(ListPrincipalPoliciesRequest request) {
return listPrincipalPoliciesAsync(request, null);
}
@Override
public java.util.concurrent.Future listPrincipalPoliciesAsync(final ListPrincipalPoliciesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListPrincipalPoliciesResult call() throws Exception {
ListPrincipalPoliciesResult result;
try {
result = listPrincipalPolicies(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 listPrincipalThingsAsync(ListPrincipalThingsRequest request) {
return listPrincipalThingsAsync(request, null);
}
@Override
public java.util.concurrent.Future listPrincipalThingsAsync(final ListPrincipalThingsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListPrincipalThingsResult call() throws Exception {
ListPrincipalThingsResult result;
try {
result = listPrincipalThings(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 listThingPrincipalsAsync(ListThingPrincipalsRequest request) {
return listThingPrincipalsAsync(request, null);
}
@Override
public java.util.concurrent.Future listThingPrincipalsAsync(final ListThingPrincipalsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListThingPrincipalsResult call() throws Exception {
ListThingPrincipalsResult result;
try {
result = listThingPrincipals(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 listThingTypesAsync(ListThingTypesRequest request) {
return listThingTypesAsync(request, null);
}
@Override
public java.util.concurrent.Future listThingTypesAsync(final ListThingTypesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListThingTypesResult call() throws Exception {
ListThingTypesResult result;
try {
result = listThingTypes(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 listThingsAsync(ListThingsRequest request) {
return listThingsAsync(request, null);
}
@Override
public java.util.concurrent.Future listThingsAsync(final ListThingsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListThingsResult call() throws Exception {
ListThingsResult result;
try {
result = listThings(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 listTopicRulesAsync(ListTopicRulesRequest request) {
return listTopicRulesAsync(request, null);
}
@Override
public java.util.concurrent.Future listTopicRulesAsync(final ListTopicRulesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListTopicRulesResult call() throws Exception {
ListTopicRulesResult result;
try {
result = listTopicRules(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 registerCACertificateAsync(RegisterCACertificateRequest request) {
return registerCACertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future registerCACertificateAsync(final RegisterCACertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RegisterCACertificateResult call() throws Exception {
RegisterCACertificateResult result;
try {
result = registerCACertificate(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 registerCertificateAsync(RegisterCertificateRequest request) {
return registerCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future registerCertificateAsync(final RegisterCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RegisterCertificateResult call() throws Exception {
RegisterCertificateResult result;
try {
result = registerCertificate(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 rejectCertificateTransferAsync(RejectCertificateTransferRequest request) {
return rejectCertificateTransferAsync(request, null);
}
@Override
public java.util.concurrent.Future rejectCertificateTransferAsync(final RejectCertificateTransferRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RejectCertificateTransferResult call() throws Exception {
RejectCertificateTransferResult result;
try {
result = rejectCertificateTransfer(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 replaceTopicRuleAsync(ReplaceTopicRuleRequest request) {
return replaceTopicRuleAsync(request, null);
}
@Override
public java.util.concurrent.Future replaceTopicRuleAsync(final ReplaceTopicRuleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ReplaceTopicRuleResult call() throws Exception {
ReplaceTopicRuleResult result;
try {
result = replaceTopicRule(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 setDefaultPolicyVersionAsync(SetDefaultPolicyVersionRequest request) {
return setDefaultPolicyVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future setDefaultPolicyVersionAsync(final SetDefaultPolicyVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public SetDefaultPolicyVersionResult call() throws Exception {
SetDefaultPolicyVersionResult result;
try {
result = setDefaultPolicyVersion(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 setLoggingOptionsAsync(SetLoggingOptionsRequest request) {
return setLoggingOptionsAsync(request, null);
}
@Override
public java.util.concurrent.Future setLoggingOptionsAsync(final SetLoggingOptionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public SetLoggingOptionsResult call() throws Exception {
SetLoggingOptionsResult result;
try {
result = setLoggingOptions(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 transferCertificateAsync(TransferCertificateRequest request) {
return transferCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future transferCertificateAsync(final TransferCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public TransferCertificateResult call() throws Exception {
TransferCertificateResult result;
try {
result = transferCertificate(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 updateCACertificateAsync(UpdateCACertificateRequest request) {
return updateCACertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future updateCACertificateAsync(final UpdateCACertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateCACertificateResult call() throws Exception {
UpdateCACertificateResult result;
try {
result = updateCACertificate(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 updateCertificateAsync(UpdateCertificateRequest request) {
return updateCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future updateCertificateAsync(final UpdateCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateCertificateResult call() throws Exception {
UpdateCertificateResult result;
try {
result = updateCertificate(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 updateThingAsync(UpdateThingRequest request) {
return updateThingAsync(request, null);
}
@Override
public java.util.concurrent.Future updateThingAsync(final UpdateThingRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateThingResult call() throws Exception {
UpdateThingResult result;
try {
result = updateThing(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();
}
}