com.amazonaws.services.iot.AWSIotAsyncClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-osgi 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(new com.amazonaws.auth.DefaultAWSCredentialsProviderChain());
}
/**
* 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(new com.amazonaws.auth.DefaultAWSCredentialsProviderChain(),
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 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();
}
}