/*
* Copyright 2018-2023 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 static java.util.concurrent.Executors.newFixedThreadPool;
import javax.annotation.Generated;
import com.amazonaws.services.iot.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.ClientConfiguration;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import java.util.concurrent.ExecutorService;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
/**
* Client for accessing 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.
*
* IoT
*
* IoT provides secure, bi-directional communication between Internet-connected devices (such as sensors, actuators,
* embedded devices, or smart appliances) and the Amazon Web Services 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 device (Registry), configure logging, and create and manage policies and credentials
* to authenticate devices.
*
*
* The service endpoints that expose this API are listed in Amazon Web Services IoT Core Endpoints and
* Quotas. You must use the endpoint for the region that has the resources you want to access.
*
*
* The service name used by Amazon Web
* Services Signature Version 4 to sign the request is: execute-api.
*
*
* For more information about how IoT works, see the Developer Guide.
*
*
* For information about how to use the credentials provider for IoT, see Authorizing Direct Calls to
* Amazon Web Services Services.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
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)
* @deprecated use {@link AWSIotAsyncClientBuilder#defaultClient()}
*/
@Deprecated
public AWSIotAsyncClient() {
this(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)
* @deprecated use {@link AWSIotAsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AWSIotAsyncClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration, 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)
* @deprecated use {@link AWSIotAsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AWSIotAsyncClient(AWSCredentials awsCredentials) {
this(awsCredentials, 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.
* @deprecated use {@link AWSIotAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSIotAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AWSIotAsyncClient(AWSCredentials awsCredentials, 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.
* @deprecated use {@link AWSIotAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSIotAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AWSIotAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AWSIotAsyncClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration, 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)
* @deprecated use {@link AWSIotAsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AWSIotAsyncClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, 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)
* @deprecated use {@link AWSIotAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSIotAsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AWSIotAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, 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.
* @deprecated use {@link AWSIotAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSIotAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AWSIotAsyncClient(AWSCredentialsProvider awsCredentialsProvider, 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.
* @deprecated use {@link AWSIotAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSIotAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AWSIotAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
*/
@Deprecated
public AWSIotAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
public static AWSIotAsyncClientBuilder asyncBuilder() {
return AWSIotAsyncClientBuilder.standard();
}
/**
* 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) {
this(asyncClientParams, false);
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS IoT using the specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
* @param endpointDiscoveryEnabled
* true will enable endpoint discovery if the service supports it.
*/
AWSIotAsyncClient(AwsAsyncClientParams asyncClientParams, boolean endpointDiscoveryEnabled) {
super(asyncClientParams, endpointDiscoveryEnabled);
this.executorService = asyncClientParams.getExecutor();
}
/**
* Returns the executor service used by this client to execute async requests.
*
* @return The executor service used by this client to execute async requests.
*/
public ExecutorService getExecutorService() {
return executorService;
}
@Override
public java.util.concurrent.Future acceptCertificateTransferAsync(AcceptCertificateTransferRequest request) {
return acceptCertificateTransferAsync(request, null);
}
@Override
public java.util.concurrent.Future acceptCertificateTransferAsync(final AcceptCertificateTransferRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AcceptCertificateTransferRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AcceptCertificateTransferResult call() throws Exception {
AcceptCertificateTransferResult result = null;
try {
result = executeAcceptCertificateTransfer(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future addThingToBillingGroupAsync(AddThingToBillingGroupRequest request) {
return addThingToBillingGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future addThingToBillingGroupAsync(final AddThingToBillingGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AddThingToBillingGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AddThingToBillingGroupResult call() throws Exception {
AddThingToBillingGroupResult result = null;
try {
result = executeAddThingToBillingGroup(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future addThingToThingGroupAsync(AddThingToThingGroupRequest request) {
return addThingToThingGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future addThingToThingGroupAsync(final AddThingToThingGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AddThingToThingGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AddThingToThingGroupResult call() throws Exception {
AddThingToThingGroupResult result = null;
try {
result = executeAddThingToThingGroup(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future associateTargetsWithJobAsync(AssociateTargetsWithJobRequest request) {
return associateTargetsWithJobAsync(request, null);
}
@Override
public java.util.concurrent.Future associateTargetsWithJobAsync(final AssociateTargetsWithJobRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AssociateTargetsWithJobRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AssociateTargetsWithJobResult call() throws Exception {
AssociateTargetsWithJobResult result = null;
try {
result = executeAssociateTargetsWithJob(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future attachPolicyAsync(AttachPolicyRequest request) {
return attachPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future attachPolicyAsync(final AttachPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AttachPolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachPolicyResult call() throws Exception {
AttachPolicyResult result = null;
try {
result = executeAttachPolicy(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
@Deprecated
public java.util.concurrent.Future attachPrincipalPolicyAsync(AttachPrincipalPolicyRequest request) {
return attachPrincipalPolicyAsync(request, null);
}
@Override
@Deprecated
public java.util.concurrent.Future attachPrincipalPolicyAsync(final AttachPrincipalPolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AttachPrincipalPolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachPrincipalPolicyResult call() throws Exception {
AttachPrincipalPolicyResult result = null;
try {
result = executeAttachPrincipalPolicy(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future attachSecurityProfileAsync(AttachSecurityProfileRequest request) {
return attachSecurityProfileAsync(request, null);
}
@Override
public java.util.concurrent.Future attachSecurityProfileAsync(final AttachSecurityProfileRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AttachSecurityProfileRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachSecurityProfileResult call() throws Exception {
AttachSecurityProfileResult result = null;
try {
result = executeAttachSecurityProfile(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future attachThingPrincipalAsync(AttachThingPrincipalRequest request) {
return attachThingPrincipalAsync(request, null);
}
@Override
public java.util.concurrent.Future attachThingPrincipalAsync(final AttachThingPrincipalRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final AttachThingPrincipalRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public AttachThingPrincipalResult call() throws Exception {
AttachThingPrincipalResult result = null;
try {
result = executeAttachThingPrincipal(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future cancelAuditMitigationActionsTaskAsync(
CancelAuditMitigationActionsTaskRequest request) {
return cancelAuditMitigationActionsTaskAsync(request, null);
}
@Override
public java.util.concurrent.Future cancelAuditMitigationActionsTaskAsync(
final CancelAuditMitigationActionsTaskRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CancelAuditMitigationActionsTaskRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CancelAuditMitigationActionsTaskResult call() throws Exception {
CancelAuditMitigationActionsTaskResult result = null;
try {
result = executeCancelAuditMitigationActionsTask(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future cancelAuditTaskAsync(CancelAuditTaskRequest request) {
return cancelAuditTaskAsync(request, null);
}
@Override
public java.util.concurrent.Future cancelAuditTaskAsync(final CancelAuditTaskRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CancelAuditTaskRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CancelAuditTaskResult call() throws Exception {
CancelAuditTaskResult result = null;
try {
result = executeCancelAuditTask(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future cancelCertificateTransferAsync(CancelCertificateTransferRequest request) {
return cancelCertificateTransferAsync(request, null);
}
@Override
public java.util.concurrent.Future cancelCertificateTransferAsync(final CancelCertificateTransferRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CancelCertificateTransferRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CancelCertificateTransferResult call() throws Exception {
CancelCertificateTransferResult result = null;
try {
result = executeCancelCertificateTransfer(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future cancelDetectMitigationActionsTaskAsync(
CancelDetectMitigationActionsTaskRequest request) {
return cancelDetectMitigationActionsTaskAsync(request, null);
}
@Override
public java.util.concurrent.Future cancelDetectMitigationActionsTaskAsync(
final CancelDetectMitigationActionsTaskRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CancelDetectMitigationActionsTaskRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CancelDetectMitigationActionsTaskResult call() throws Exception {
CancelDetectMitigationActionsTaskResult result = null;
try {
result = executeCancelDetectMitigationActionsTask(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future cancelJobAsync(CancelJobRequest request) {
return cancelJobAsync(request, null);
}
@Override
public java.util.concurrent.Future cancelJobAsync(final CancelJobRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CancelJobRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CancelJobResult call() throws Exception {
CancelJobResult result = null;
try {
result = executeCancelJob(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future cancelJobExecutionAsync(CancelJobExecutionRequest request) {
return cancelJobExecutionAsync(request, null);
}
@Override
public java.util.concurrent.Future cancelJobExecutionAsync(final CancelJobExecutionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CancelJobExecutionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CancelJobExecutionResult call() throws Exception {
CancelJobExecutionResult result = null;
try {
result = executeCancelJobExecution(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future clearDefaultAuthorizerAsync(ClearDefaultAuthorizerRequest request) {
return clearDefaultAuthorizerAsync(request, null);
}
@Override
public java.util.concurrent.Future clearDefaultAuthorizerAsync(final ClearDefaultAuthorizerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ClearDefaultAuthorizerRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ClearDefaultAuthorizerResult call() throws Exception {
ClearDefaultAuthorizerResult result = null;
try {
result = executeClearDefaultAuthorizer(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future confirmTopicRuleDestinationAsync(ConfirmTopicRuleDestinationRequest request) {
return confirmTopicRuleDestinationAsync(request, null);
}
@Override
public java.util.concurrent.Future confirmTopicRuleDestinationAsync(final ConfirmTopicRuleDestinationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ConfirmTopicRuleDestinationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ConfirmTopicRuleDestinationResult call() throws Exception {
ConfirmTopicRuleDestinationResult result = null;
try {
result = executeConfirmTopicRuleDestination(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createAuditSuppressionAsync(CreateAuditSuppressionRequest request) {
return createAuditSuppressionAsync(request, null);
}
@Override
public java.util.concurrent.Future createAuditSuppressionAsync(final CreateAuditSuppressionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateAuditSuppressionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateAuditSuppressionResult call() throws Exception {
CreateAuditSuppressionResult result = null;
try {
result = executeCreateAuditSuppression(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createAuthorizerAsync(CreateAuthorizerRequest request) {
return createAuthorizerAsync(request, null);
}
@Override
public java.util.concurrent.Future createAuthorizerAsync(final CreateAuthorizerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateAuthorizerRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateAuthorizerResult call() throws Exception {
CreateAuthorizerResult result = null;
try {
result = executeCreateAuthorizer(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createBillingGroupAsync(CreateBillingGroupRequest request) {
return createBillingGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future createBillingGroupAsync(final CreateBillingGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateBillingGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateBillingGroupResult call() throws Exception {
CreateBillingGroupResult result = null;
try {
result = executeCreateBillingGroup(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createCertificateFromCsrAsync(CreateCertificateFromCsrRequest request) {
return createCertificateFromCsrAsync(request, null);
}
@Override
public java.util.concurrent.Future createCertificateFromCsrAsync(final CreateCertificateFromCsrRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateCertificateFromCsrRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateCertificateFromCsrResult call() throws Exception {
CreateCertificateFromCsrResult result = null;
try {
result = executeCreateCertificateFromCsr(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createCustomMetricAsync(CreateCustomMetricRequest request) {
return createCustomMetricAsync(request, null);
}
@Override
public java.util.concurrent.Future createCustomMetricAsync(final CreateCustomMetricRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateCustomMetricRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateCustomMetricResult call() throws Exception {
CreateCustomMetricResult result = null;
try {
result = executeCreateCustomMetric(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createDimensionAsync(CreateDimensionRequest request) {
return createDimensionAsync(request, null);
}
@Override
public java.util.concurrent.Future createDimensionAsync(final CreateDimensionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateDimensionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateDimensionResult call() throws Exception {
CreateDimensionResult result = null;
try {
result = executeCreateDimension(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createDomainConfigurationAsync(CreateDomainConfigurationRequest request) {
return createDomainConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future createDomainConfigurationAsync(final CreateDomainConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateDomainConfigurationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateDomainConfigurationResult call() throws Exception {
CreateDomainConfigurationResult result = null;
try {
result = executeCreateDomainConfiguration(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createDynamicThingGroupAsync(CreateDynamicThingGroupRequest request) {
return createDynamicThingGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future createDynamicThingGroupAsync(final CreateDynamicThingGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateDynamicThingGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateDynamicThingGroupResult call() throws Exception {
CreateDynamicThingGroupResult result = null;
try {
result = executeCreateDynamicThingGroup(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createFleetMetricAsync(CreateFleetMetricRequest request) {
return createFleetMetricAsync(request, null);
}
@Override
public java.util.concurrent.Future createFleetMetricAsync(final CreateFleetMetricRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateFleetMetricRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateFleetMetricResult call() throws Exception {
CreateFleetMetricResult result = null;
try {
result = executeCreateFleetMetric(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createJobAsync(CreateJobRequest request) {
return createJobAsync(request, null);
}
@Override
public java.util.concurrent.Future createJobAsync(final CreateJobRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateJobRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateJobResult call() throws Exception {
CreateJobResult result = null;
try {
result = executeCreateJob(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createJobTemplateAsync(CreateJobTemplateRequest request) {
return createJobTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future createJobTemplateAsync(final CreateJobTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateJobTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateJobTemplateResult call() throws Exception {
CreateJobTemplateResult result = null;
try {
result = executeCreateJobTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createKeysAndCertificateAsync(CreateKeysAndCertificateRequest request) {
return createKeysAndCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future createKeysAndCertificateAsync(final CreateKeysAndCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateKeysAndCertificateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateKeysAndCertificateResult call() throws Exception {
CreateKeysAndCertificateResult result = null;
try {
result = executeCreateKeysAndCertificate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createMitigationActionAsync(CreateMitigationActionRequest request) {
return createMitigationActionAsync(request, null);
}
@Override
public java.util.concurrent.Future createMitigationActionAsync(final CreateMitigationActionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateMitigationActionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateMitigationActionResult call() throws Exception {
CreateMitigationActionResult result = null;
try {
result = executeCreateMitigationAction(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createOTAUpdateAsync(CreateOTAUpdateRequest request) {
return createOTAUpdateAsync(request, null);
}
@Override
public java.util.concurrent.Future createOTAUpdateAsync(final CreateOTAUpdateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateOTAUpdateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateOTAUpdateResult call() throws Exception {
CreateOTAUpdateResult result = null;
try {
result = executeCreateOTAUpdate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createPackageAsync(CreatePackageRequest request) {
return createPackageAsync(request, null);
}
@Override
public java.util.concurrent.Future createPackageAsync(final CreatePackageRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreatePackageRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreatePackageResult call() throws Exception {
CreatePackageResult result = null;
try {
result = executeCreatePackage(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createPackageVersionAsync(CreatePackageVersionRequest request) {
return createPackageVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future createPackageVersionAsync(final CreatePackageVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreatePackageVersionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreatePackageVersionResult call() throws Exception {
CreatePackageVersionResult result = null;
try {
result = executeCreatePackageVersion(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createPolicyAsync(CreatePolicyRequest request) {
return createPolicyAsync(request, null);
}
@Override
public java.util.concurrent.Future createPolicyAsync(final CreatePolicyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreatePolicyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreatePolicyResult call() throws Exception {
CreatePolicyResult result = null;
try {
result = executeCreatePolicy(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createPolicyVersionAsync(CreatePolicyVersionRequest request) {
return createPolicyVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future createPolicyVersionAsync(final CreatePolicyVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreatePolicyVersionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreatePolicyVersionResult call() throws Exception {
CreatePolicyVersionResult result = null;
try {
result = executeCreatePolicyVersion(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createProvisioningClaimAsync(CreateProvisioningClaimRequest request) {
return createProvisioningClaimAsync(request, null);
}
@Override
public java.util.concurrent.Future createProvisioningClaimAsync(final CreateProvisioningClaimRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateProvisioningClaimRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateProvisioningClaimResult call() throws Exception {
CreateProvisioningClaimResult result = null;
try {
result = executeCreateProvisioningClaim(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createProvisioningTemplateAsync(CreateProvisioningTemplateRequest request) {
return createProvisioningTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future createProvisioningTemplateAsync(final CreateProvisioningTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateProvisioningTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateProvisioningTemplateResult call() throws Exception {
CreateProvisioningTemplateResult result = null;
try {
result = executeCreateProvisioningTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createProvisioningTemplateVersionAsync(
CreateProvisioningTemplateVersionRequest request) {
return createProvisioningTemplateVersionAsync(request, null);
}
@Override
public java.util.concurrent.Future createProvisioningTemplateVersionAsync(
final CreateProvisioningTemplateVersionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateProvisioningTemplateVersionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateProvisioningTemplateVersionResult call() throws Exception {
CreateProvisioningTemplateVersionResult result = null;
try {
result = executeCreateProvisioningTemplateVersion(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createRoleAliasAsync(CreateRoleAliasRequest request) {
return createRoleAliasAsync(request, null);
}
@Override
public java.util.concurrent.Future createRoleAliasAsync(final CreateRoleAliasRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateRoleAliasRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateRoleAliasResult call() throws Exception {
CreateRoleAliasResult result = null;
try {
result = executeCreateRoleAlias(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createScheduledAuditAsync(CreateScheduledAuditRequest request) {
return createScheduledAuditAsync(request, null);
}
@Override
public java.util.concurrent.Future createScheduledAuditAsync(final CreateScheduledAuditRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateScheduledAuditRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateScheduledAuditResult call() throws Exception {
CreateScheduledAuditResult result = null;
try {
result = executeCreateScheduledAudit(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createSecurityProfileAsync(CreateSecurityProfileRequest request) {
return createSecurityProfileAsync(request, null);
}
@Override
public java.util.concurrent.Future createSecurityProfileAsync(final CreateSecurityProfileRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateSecurityProfileRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateSecurityProfileResult call() throws Exception {
CreateSecurityProfileResult result = null;
try {
result = executeCreateSecurityProfile(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createStreamAsync(CreateStreamRequest request) {
return createStreamAsync(request, null);
}
@Override
public java.util.concurrent.Future createStreamAsync(final CreateStreamRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateStreamRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateStreamResult call() throws Exception {
CreateStreamResult result = null;
try {
result = executeCreateStream(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createThingAsync(CreateThingRequest request) {
return createThingAsync(request, null);
}
@Override
public java.util.concurrent.Future createThingAsync(final CreateThingRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateThingRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateThingResult call() throws Exception {
CreateThingResult result = null;
try {
result = executeCreateThing(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createThingGroupAsync(CreateThingGroupRequest request) {
return createThingGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future createThingGroupAsync(final CreateThingGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateThingGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateThingGroupResult call() throws Exception {
CreateThingGroupResult result = null;
try {
result = executeCreateThingGroup(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createThingTypeAsync(CreateThingTypeRequest request) {
return createThingTypeAsync(request, null);
}
@Override
public java.util.concurrent.Future createThingTypeAsync(final CreateThingTypeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateThingTypeRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateThingTypeResult call() throws Exception {
CreateThingTypeResult result = null;
try {
result = executeCreateThingType(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createTopicRuleAsync(CreateTopicRuleRequest request) {
return createTopicRuleAsync(request, null);
}
@Override
public java.util.concurrent.Future createTopicRuleAsync(final CreateTopicRuleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateTopicRuleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateTopicRuleResult call() throws Exception {
CreateTopicRuleResult result = null;
try {
result = executeCreateTopicRule(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createTopicRuleDestinationAsync(CreateTopicRuleDestinationRequest request) {
return createTopicRuleDestinationAsync(request, null);
}
@Override
public java.util.concurrent.Future createTopicRuleDestinationAsync(final CreateTopicRuleDestinationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateTopicRuleDestinationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateTopicRuleDestinationResult call() throws Exception {
CreateTopicRuleDestinationResult result = null;
try {
result = executeCreateTopicRuleDestination(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteAccountAuditConfigurationAsync(
DeleteAccountAuditConfigurationRequest request) {
return deleteAccountAuditConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteAccountAuditConfigurationAsync(
final DeleteAccountAuditConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteAccountAuditConfigurationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAccountAuditConfigurationResult call() throws Exception {
DeleteAccountAuditConfigurationResult result = null;
try {
result = executeDeleteAccountAuditConfiguration(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteAuditSuppressionAsync(DeleteAuditSuppressionRequest request) {
return deleteAuditSuppressionAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteAuditSuppressionAsync(final DeleteAuditSuppressionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteAuditSuppressionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAuditSuppressionResult call() throws Exception {
DeleteAuditSuppressionResult result = null;
try {
result = executeDeleteAuditSuppression(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteAuthorizerAsync(DeleteAuthorizerRequest request) {
return deleteAuthorizerAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteAuthorizerAsync(final DeleteAuthorizerRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteAuthorizerRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAuthorizerResult call() throws Exception {
DeleteAuthorizerResult result = null;
try {
result = executeDeleteAuthorizer(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteBillingGroupAsync(DeleteBillingGroupRequest request) {
return deleteBillingGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteBillingGroupAsync(final DeleteBillingGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteBillingGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteBillingGroupResult call() throws Exception {
DeleteBillingGroupResult result = null;
try {
result = executeDeleteBillingGroup(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteCACertificateAsync(DeleteCACertificateRequest request) {
return deleteCACertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteCACertificateAsync(final DeleteCACertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteCACertificateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteCACertificateResult call() throws Exception {
DeleteCACertificateResult result = null;
try {
result = executeDeleteCACertificate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteCertificateAsync(DeleteCertificateRequest request) {
return deleteCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteCertificateAsync(final DeleteCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteCertificateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteCertificateResult call() throws Exception {
DeleteCertificateResult result = null;
try {
result = executeDeleteCertificate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteCustomMetricAsync(DeleteCustomMetricRequest request) {
return deleteCustomMetricAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteCustomMetricAsync(final DeleteCustomMetricRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteCustomMetricRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteCustomMetricResult call() throws Exception {
DeleteCustomMetricResult result = null;
try {
result = executeDeleteCustomMetric(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteDimensionAsync(DeleteDimensionRequest request) {
return deleteDimensionAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteDimensionAsync(final DeleteDimensionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteDimensionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteDimensionResult call() throws Exception {
DeleteDimensionResult result = null;
try {
result = executeDeleteDimension(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteDomainConfigurationAsync(DeleteDomainConfigurationRequest request) {
return deleteDomainConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteDomainConfigurationAsync(final DeleteDomainConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteDomainConfigurationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteDomainConfigurationResult call() throws Exception {
DeleteDomainConfigurationResult result = null;
try {
result = executeDeleteDomainConfiguration(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteDynamicThingGroupAsync(DeleteDynamicThingGroupRequest request) {
return deleteDynamicThingGroupAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteDynamicThingGroupAsync(final DeleteDynamicThingGroupRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteDynamicThingGroupRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteDynamicThingGroupResult call() throws Exception {
DeleteDynamicThingGroupResult result = null;
try {
result = executeDeleteDynamicThingGroup(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteFleetMetricAsync(DeleteFleetMetricRequest request) {
return deleteFleetMetricAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteFleetMetricAsync(final DeleteFleetMetricRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteFleetMetricRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteFleetMetricResult call() throws Exception {
DeleteFleetMetricResult result = null;
try {
result = executeDeleteFleetMetric(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteJobAsync(DeleteJobRequest request) {
return deleteJobAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteJobAsync(final DeleteJobRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteJobRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteJobResult call() throws Exception {
DeleteJobResult result = null;
try {
result = executeDeleteJob(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteJobExecutionAsync(DeleteJobExecutionRequest request) {
return deleteJobExecutionAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteJobExecutionAsync(final DeleteJobExecutionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteJobExecutionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteJobExecutionResult call() throws Exception {
DeleteJobExecutionResult result = null;
try {
result = executeDeleteJobExecution(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteJobTemplateAsync(DeleteJobTemplateRequest request) {
return deleteJobTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteJobTemplateAsync(final DeleteJobTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteJobTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteJobTemplateResult call() throws Exception {
DeleteJobTemplateResult result = null;
try {
result = executeDeleteJobTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteMitigationActionAsync(DeleteMitigationActionRequest request) {
return deleteMitigationActionAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteMitigationActionAsync(final DeleteMitigationActionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteMitigationActionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteMitigationActionResult call() throws Exception {
DeleteMitigationActionResult result = null;
try {
result = executeDeleteMitigationAction(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteOTAUpdateAsync(DeleteOTAUpdateRequest request) {
return deleteOTAUpdateAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteOTAUpdateAsync(final DeleteOTAUpdateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteOTAUpdateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteOTAUpdateResult call() throws Exception {
DeleteOTAUpdateResult result = null;
try {
result = executeDeleteOTAUpdate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deletePackageAsync(DeletePackageRequest request) {
return deletePackageAsync(request, null);
}
@Override
public java.util.concurrent.Future deletePackageAsync(final DeletePackageRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeletePackageRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable