Java tutorial
/* * Copyright 2014-2019 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.cloudwatch; import static java.util.concurrent.Executors.newFixedThreadPool; import javax.annotation.Generated; import com.amazonaws.services.cloudwatch.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 CloudWatch 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. * <p> * <p> * Amazon CloudWatch monitors your Amazon Web Services (AWS) resources and the applications you run on AWS in real time. * You can use CloudWatch to collect and track metrics, which are the variables you want to measure for your resources * and applications. * </p> * <p> * CloudWatch alarms send notifications or automatically change the resources you are monitoring based on rules that you * define. For example, you can monitor the CPU usage and disk reads and writes of your Amazon EC2 instances. Then, use * this data to determine whether you should launch additional instances to handle increased load. You can also use this * data to stop under-used instances to save money. * </p> * <p> * In addition to monitoring the built-in metrics that come with AWS, you can monitor your own custom metrics. With * CloudWatch, you gain system-wide visibility into resource utilization, application performance, and operational * health. * </p> */ @ThreadSafe @Generated("com.amazonaws:aws-java-sdk-code-generator") public class AmazonCloudWatchAsyncClient extends AmazonCloudWatchClient implements AmazonCloudWatchAsync { 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 CloudWatch. A credentials provider chain will * be used that searches for credentials in this order: * <ul> * <li>Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY</li> * <li>Java System Properties - aws.accessKeyId and aws.secretKey</li> * <li>Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI</li> * <li>Instance profile credentials delivered through the Amazon EC2 metadata service</li> * </ul> * <p> * 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 AmazonCloudWatchAsyncClientBuilder#defaultClient()} */ @Deprecated public AmazonCloudWatchAsyncClient() { this(DefaultAWSCredentialsProviderChain.getInstance()); } /** * Constructs a new asynchronous client to invoke service methods on CloudWatch. A credentials provider chain will * be used that searches for credentials in this order: * <ul> * <li>Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY</li> * <li>Java System Properties - aws.accessKeyId and aws.secretKey</li> * <li>Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI</li> * <li>Instance profile credentials delivered through the Amazon EC2 metadata service</li> * </ul> * <p> * 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 CloudWatch (ex: proxy settings, * retry counts, etc). * * @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain * @see java.util.concurrent.Executors#newFixedThreadPool(int) * @deprecated use {@link AmazonCloudWatchAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} */ @Deprecated public AmazonCloudWatchAsyncClient(ClientConfiguration clientConfiguration) { this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections())); } /** * Constructs a new asynchronous client to invoke service methods on CloudWatch using the specified AWS account * credentials. * <p> * 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 AmazonCloudWatchAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} */ @Deprecated public AmazonCloudWatchAsyncClient(AWSCredentials awsCredentials) { this(awsCredentials, newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE)); } /** * Constructs a new asynchronous client to invoke service methods on CloudWatch 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 AmazonCloudWatchAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and * {@link AmazonCloudWatchAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)} */ @Deprecated public AmazonCloudWatchAsyncClient(AWSCredentials awsCredentials, ExecutorService executorService) { this(awsCredentials, configFactory.getConfig(), executorService); } /** * Constructs a new asynchronous client to invoke service methods on CloudWatch 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 AmazonCloudWatchAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and * {@link AmazonCloudWatchAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and * {@link AmazonCloudWatchAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)} */ @Deprecated public AmazonCloudWatchAsyncClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration, ExecutorService executorService) { super(awsCredentials, clientConfiguration); this.executorService = executorService; } /** * Constructs a new asynchronous client to invoke service methods on CloudWatch using the specified AWS account * credentials provider. Default client settings will be used. * <p> * 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 AmazonCloudWatchAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} */ @Deprecated public AmazonCloudWatchAsyncClient(AWSCredentialsProvider awsCredentialsProvider) { this(awsCredentialsProvider, newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE)); } /** * Constructs a new asynchronous client to invoke service methods on CloudWatch using the provided AWS account * credentials provider and client configuration options. * <p> * 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 AmazonCloudWatchAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and * {@link AmazonCloudWatchAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} */ @Deprecated public AmazonCloudWatchAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) { this(awsCredentialsProvider, clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections())); } /** * Constructs a new asynchronous client to invoke service methods on CloudWatch 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 AmazonCloudWatchAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and * {@link AmazonCloudWatchAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)} */ @Deprecated public AmazonCloudWatchAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ExecutorService executorService) { this(awsCredentialsProvider, configFactory.getConfig(), executorService); } /** * Constructs a new asynchronous client to invoke service methods on CloudWatch 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 AmazonCloudWatchAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and * {@link AmazonCloudWatchAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and * {@link AmazonCloudWatchAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)} */ @Deprecated public AmazonCloudWatchAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration, ExecutorService executorService) { super(awsCredentialsProvider, clientConfiguration); this.executorService = executorService; } public static AmazonCloudWatchAsyncClientBuilder asyncBuilder() { return AmazonCloudWatchAsyncClientBuilder.standard(); } /** * Constructs a new asynchronous client to invoke service methods on CloudWatch using the specified parameters. * * @param asyncClientParams * Object providing client parameters. */ AmazonCloudWatchAsyncClient(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 ExecutorService getExecutorService() { return executorService; } @Override public java.util.concurrent.Future<DeleteAlarmsResult> deleteAlarmsAsync(DeleteAlarmsRequest request) { return deleteAlarmsAsync(request, null); } @Override public java.util.concurrent.Future<DeleteAlarmsResult> deleteAlarmsAsync(final DeleteAlarmsRequest request, final com.amazonaws.handlers.AsyncHandler<DeleteAlarmsRequest, DeleteAlarmsResult> asyncHandler) { final DeleteAlarmsRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DeleteAlarmsResult>() { @Override public DeleteAlarmsResult call() throws Exception { DeleteAlarmsResult result = null; try { result = executeDeleteAlarms(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<DeleteAnomalyDetectorResult> deleteAnomalyDetectorAsync( DeleteAnomalyDetectorRequest request) { return deleteAnomalyDetectorAsync(request, null); } @Override public java.util.concurrent.Future<DeleteAnomalyDetectorResult> deleteAnomalyDetectorAsync( final DeleteAnomalyDetectorRequest request, final com.amazonaws.handlers.AsyncHandler<DeleteAnomalyDetectorRequest, DeleteAnomalyDetectorResult> asyncHandler) { final DeleteAnomalyDetectorRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DeleteAnomalyDetectorResult>() { @Override public DeleteAnomalyDetectorResult call() throws Exception { DeleteAnomalyDetectorResult result = null; try { result = executeDeleteAnomalyDetector(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<DeleteDashboardsResult> deleteDashboardsAsync( DeleteDashboardsRequest request) { return deleteDashboardsAsync(request, null); } @Override public java.util.concurrent.Future<DeleteDashboardsResult> deleteDashboardsAsync( final DeleteDashboardsRequest request, final com.amazonaws.handlers.AsyncHandler<DeleteDashboardsRequest, DeleteDashboardsResult> asyncHandler) { final DeleteDashboardsRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DeleteDashboardsResult>() { @Override public DeleteDashboardsResult call() throws Exception { DeleteDashboardsResult result = null; try { result = executeDeleteDashboards(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<DeleteInsightRulesResult> deleteInsightRulesAsync( DeleteInsightRulesRequest request) { return deleteInsightRulesAsync(request, null); } @Override public java.util.concurrent.Future<DeleteInsightRulesResult> deleteInsightRulesAsync( final DeleteInsightRulesRequest request, final com.amazonaws.handlers.AsyncHandler<DeleteInsightRulesRequest, DeleteInsightRulesResult> asyncHandler) { final DeleteInsightRulesRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DeleteInsightRulesResult>() { @Override public DeleteInsightRulesResult call() throws Exception { DeleteInsightRulesResult result = null; try { result = executeDeleteInsightRules(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<DescribeAlarmHistoryResult> describeAlarmHistoryAsync( DescribeAlarmHistoryRequest request) { return describeAlarmHistoryAsync(request, null); } @Override public java.util.concurrent.Future<DescribeAlarmHistoryResult> describeAlarmHistoryAsync( final DescribeAlarmHistoryRequest request, final com.amazonaws.handlers.AsyncHandler<DescribeAlarmHistoryRequest, DescribeAlarmHistoryResult> asyncHandler) { final DescribeAlarmHistoryRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DescribeAlarmHistoryResult>() { @Override public DescribeAlarmHistoryResult call() throws Exception { DescribeAlarmHistoryResult result = null; try { result = executeDescribeAlarmHistory(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } /** * Simplified method form for invoking the DescribeAlarmHistory operation. * * @see #describeAlarmHistoryAsync(DescribeAlarmHistoryRequest) */ @Override public java.util.concurrent.Future<DescribeAlarmHistoryResult> describeAlarmHistoryAsync() { return describeAlarmHistoryAsync(new DescribeAlarmHistoryRequest()); } /** * Simplified method form for invoking the DescribeAlarmHistory operation with an AsyncHandler. * * @see #describeAlarmHistoryAsync(DescribeAlarmHistoryRequest, com.amazonaws.handlers.AsyncHandler) */ @Override public java.util.concurrent.Future<DescribeAlarmHistoryResult> describeAlarmHistoryAsync( com.amazonaws.handlers.AsyncHandler<DescribeAlarmHistoryRequest, DescribeAlarmHistoryResult> asyncHandler) { return describeAlarmHistoryAsync(new DescribeAlarmHistoryRequest(), asyncHandler); } @Override public java.util.concurrent.Future<DescribeAlarmsResult> describeAlarmsAsync(DescribeAlarmsRequest request) { return describeAlarmsAsync(request, null); } @Override public java.util.concurrent.Future<DescribeAlarmsResult> describeAlarmsAsync( final DescribeAlarmsRequest request, final com.amazonaws.handlers.AsyncHandler<DescribeAlarmsRequest, DescribeAlarmsResult> asyncHandler) { final DescribeAlarmsRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DescribeAlarmsResult>() { @Override public DescribeAlarmsResult call() throws Exception { DescribeAlarmsResult result = null; try { result = executeDescribeAlarms(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } /** * Simplified method form for invoking the DescribeAlarms operation. * * @see #describeAlarmsAsync(DescribeAlarmsRequest) */ @Override public java.util.concurrent.Future<DescribeAlarmsResult> describeAlarmsAsync() { return describeAlarmsAsync(new DescribeAlarmsRequest()); } /** * Simplified method form for invoking the DescribeAlarms operation with an AsyncHandler. * * @see #describeAlarmsAsync(DescribeAlarmsRequest, com.amazonaws.handlers.AsyncHandler) */ @Override public java.util.concurrent.Future<DescribeAlarmsResult> describeAlarmsAsync( com.amazonaws.handlers.AsyncHandler<DescribeAlarmsRequest, DescribeAlarmsResult> asyncHandler) { return describeAlarmsAsync(new DescribeAlarmsRequest(), asyncHandler); } @Override public java.util.concurrent.Future<DescribeAlarmsForMetricResult> describeAlarmsForMetricAsync( DescribeAlarmsForMetricRequest request) { return describeAlarmsForMetricAsync(request, null); } @Override public java.util.concurrent.Future<DescribeAlarmsForMetricResult> describeAlarmsForMetricAsync( final DescribeAlarmsForMetricRequest request, final com.amazonaws.handlers.AsyncHandler<DescribeAlarmsForMetricRequest, DescribeAlarmsForMetricResult> asyncHandler) { final DescribeAlarmsForMetricRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DescribeAlarmsForMetricResult>() { @Override public DescribeAlarmsForMetricResult call() throws Exception { DescribeAlarmsForMetricResult result = null; try { result = executeDescribeAlarmsForMetric(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<DescribeAnomalyDetectorsResult> describeAnomalyDetectorsAsync( DescribeAnomalyDetectorsRequest request) { return describeAnomalyDetectorsAsync(request, null); } @Override public java.util.concurrent.Future<DescribeAnomalyDetectorsResult> describeAnomalyDetectorsAsync( final DescribeAnomalyDetectorsRequest request, final com.amazonaws.handlers.AsyncHandler<DescribeAnomalyDetectorsRequest, DescribeAnomalyDetectorsResult> asyncHandler) { final DescribeAnomalyDetectorsRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DescribeAnomalyDetectorsResult>() { @Override public DescribeAnomalyDetectorsResult call() throws Exception { DescribeAnomalyDetectorsResult result = null; try { result = executeDescribeAnomalyDetectors(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<DescribeInsightRulesResult> describeInsightRulesAsync( DescribeInsightRulesRequest request) { return describeInsightRulesAsync(request, null); } @Override public java.util.concurrent.Future<DescribeInsightRulesResult> describeInsightRulesAsync( final DescribeInsightRulesRequest request, final com.amazonaws.handlers.AsyncHandler<DescribeInsightRulesRequest, DescribeInsightRulesResult> asyncHandler) { final DescribeInsightRulesRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DescribeInsightRulesResult>() { @Override public DescribeInsightRulesResult call() throws Exception { DescribeInsightRulesResult result = null; try { result = executeDescribeInsightRules(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<DisableAlarmActionsResult> disableAlarmActionsAsync( DisableAlarmActionsRequest request) { return disableAlarmActionsAsync(request, null); } @Override public java.util.concurrent.Future<DisableAlarmActionsResult> disableAlarmActionsAsync( final DisableAlarmActionsRequest request, final com.amazonaws.handlers.AsyncHandler<DisableAlarmActionsRequest, DisableAlarmActionsResult> asyncHandler) { final DisableAlarmActionsRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DisableAlarmActionsResult>() { @Override public DisableAlarmActionsResult call() throws Exception { DisableAlarmActionsResult result = null; try { result = executeDisableAlarmActions(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<DisableInsightRulesResult> disableInsightRulesAsync( DisableInsightRulesRequest request) { return disableInsightRulesAsync(request, null); } @Override public java.util.concurrent.Future<DisableInsightRulesResult> disableInsightRulesAsync( final DisableInsightRulesRequest request, final com.amazonaws.handlers.AsyncHandler<DisableInsightRulesRequest, DisableInsightRulesResult> asyncHandler) { final DisableInsightRulesRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<DisableInsightRulesResult>() { @Override public DisableInsightRulesResult call() throws Exception { DisableInsightRulesResult result = null; try { result = executeDisableInsightRules(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<EnableAlarmActionsResult> enableAlarmActionsAsync( EnableAlarmActionsRequest request) { return enableAlarmActionsAsync(request, null); } @Override public java.util.concurrent.Future<EnableAlarmActionsResult> enableAlarmActionsAsync( final EnableAlarmActionsRequest request, final com.amazonaws.handlers.AsyncHandler<EnableAlarmActionsRequest, EnableAlarmActionsResult> asyncHandler) { final EnableAlarmActionsRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<EnableAlarmActionsResult>() { @Override public EnableAlarmActionsResult call() throws Exception { EnableAlarmActionsResult result = null; try { result = executeEnableAlarmActions(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<EnableInsightRulesResult> enableInsightRulesAsync( EnableInsightRulesRequest request) { return enableInsightRulesAsync(request, null); } @Override public java.util.concurrent.Future<EnableInsightRulesResult> enableInsightRulesAsync( final EnableInsightRulesRequest request, final com.amazonaws.handlers.AsyncHandler<EnableInsightRulesRequest, EnableInsightRulesResult> asyncHandler) { final EnableInsightRulesRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<EnableInsightRulesResult>() { @Override public EnableInsightRulesResult call() throws Exception { EnableInsightRulesResult result = null; try { result = executeEnableInsightRules(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<GetDashboardResult> getDashboardAsync(GetDashboardRequest request) { return getDashboardAsync(request, null); } @Override public java.util.concurrent.Future<GetDashboardResult> getDashboardAsync(final GetDashboardRequest request, final com.amazonaws.handlers.AsyncHandler<GetDashboardRequest, GetDashboardResult> asyncHandler) { final GetDashboardRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<GetDashboardResult>() { @Override public GetDashboardResult call() throws Exception { GetDashboardResult result = null; try { result = executeGetDashboard(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<GetInsightRuleReportResult> getInsightRuleReportAsync( GetInsightRuleReportRequest request) { return getInsightRuleReportAsync(request, null); } @Override public java.util.concurrent.Future<GetInsightRuleReportResult> getInsightRuleReportAsync( final GetInsightRuleReportRequest request, final com.amazonaws.handlers.AsyncHandler<GetInsightRuleReportRequest, GetInsightRuleReportResult> asyncHandler) { final GetInsightRuleReportRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<GetInsightRuleReportResult>() { @Override public GetInsightRuleReportResult call() throws Exception { GetInsightRuleReportResult result = null; try { result = executeGetInsightRuleReport(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<GetMetricDataResult> getMetricDataAsync(GetMetricDataRequest request) { return getMetricDataAsync(request, null); } @Override public java.util.concurrent.Future<GetMetricDataResult> getMetricDataAsync(final GetMetricDataRequest request, final com.amazonaws.handlers.AsyncHandler<GetMetricDataRequest, GetMetricDataResult> asyncHandler) { final GetMetricDataRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<GetMetricDataResult>() { @Override public GetMetricDataResult call() throws Exception { GetMetricDataResult result = null; try { result = executeGetMetricData(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<GetMetricStatisticsResult> getMetricStatisticsAsync( GetMetricStatisticsRequest request) { return getMetricStatisticsAsync(request, null); } @Override public java.util.concurrent.Future<GetMetricStatisticsResult> getMetricStatisticsAsync( final GetMetricStatisticsRequest request, final com.amazonaws.handlers.AsyncHandler<GetMetricStatisticsRequest, GetMetricStatisticsResult> asyncHandler) { final GetMetricStatisticsRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<GetMetricStatisticsResult>() { @Override public GetMetricStatisticsResult call() throws Exception { GetMetricStatisticsResult result = null; try { result = executeGetMetricStatistics(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<GetMetricWidgetImageResult> getMetricWidgetImageAsync( GetMetricWidgetImageRequest request) { return getMetricWidgetImageAsync(request, null); } @Override public java.util.concurrent.Future<GetMetricWidgetImageResult> getMetricWidgetImageAsync( final GetMetricWidgetImageRequest request, final com.amazonaws.handlers.AsyncHandler<GetMetricWidgetImageRequest, GetMetricWidgetImageResult> asyncHandler) { final GetMetricWidgetImageRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<GetMetricWidgetImageResult>() { @Override public GetMetricWidgetImageResult call() throws Exception { GetMetricWidgetImageResult result = null; try { result = executeGetMetricWidgetImage(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<ListDashboardsResult> listDashboardsAsync(ListDashboardsRequest request) { return listDashboardsAsync(request, null); } @Override public java.util.concurrent.Future<ListDashboardsResult> listDashboardsAsync( final ListDashboardsRequest request, final com.amazonaws.handlers.AsyncHandler<ListDashboardsRequest, ListDashboardsResult> asyncHandler) { final ListDashboardsRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<ListDashboardsResult>() { @Override public ListDashboardsResult call() throws Exception { ListDashboardsResult result = null; try { result = executeListDashboards(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<ListMetricsResult> listMetricsAsync(ListMetricsRequest request) { return listMetricsAsync(request, null); } @Override public java.util.concurrent.Future<ListMetricsResult> listMetricsAsync(final ListMetricsRequest request, final com.amazonaws.handlers.AsyncHandler<ListMetricsRequest, ListMetricsResult> asyncHandler) { final ListMetricsRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<ListMetricsResult>() { @Override public ListMetricsResult call() throws Exception { ListMetricsResult result = null; try { result = executeListMetrics(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, result); } return result; } }); } /** * Simplified method form for invoking the ListMetrics operation. * * @see #listMetricsAsync(ListMetricsRequest) */ @Override public java.util.concurrent.Future<ListMetricsResult> listMetricsAsync() { return listMetricsAsync(new ListMetricsRequest()); } /** * Simplified method form for invoking the ListMetrics operation with an AsyncHandler. * * @see #listMetricsAsync(ListMetricsRequest, com.amazonaws.handlers.AsyncHandler) */ @Override public java.util.concurrent.Future<ListMetricsResult> listMetricsAsync( com.amazonaws.handlers.AsyncHandler<ListMetricsRequest, ListMetricsResult> asyncHandler) { return listMetricsAsync(new ListMetricsRequest(), asyncHandler); } @Override public java.util.concurrent.Future<ListTagsForResourceResult> listTagsForResourceAsync( ListTagsForResourceRequest request) { return listTagsForResourceAsync(request, null); } @Override public java.util.concurrent.Future<ListTagsForResourceResult> listTagsForResourceAsync( final ListTagsForResourceRequest request, final com.amazonaws.handlers.AsyncHandler<ListTagsForResourceRequest, ListTagsForResourceResult> asyncHandler) { final ListTagsForResourceRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<ListTagsForResourceResult>() { @Override public ListTagsForResourceResult call() throws Exception { ListTagsForResourceResult result = null; try { result = executeListTagsForResource(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<PutAnomalyDetectorResult> putAnomalyDetectorAsync( PutAnomalyDetectorRequest request) { return putAnomalyDetectorAsync(request, null); } @Override public java.util.concurrent.Future<PutAnomalyDetectorResult> putAnomalyDetectorAsync( final PutAnomalyDetectorRequest request, final com.amazonaws.handlers.AsyncHandler<PutAnomalyDetectorRequest, PutAnomalyDetectorResult> asyncHandler) { final PutAnomalyDetectorRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<PutAnomalyDetectorResult>() { @Override public PutAnomalyDetectorResult call() throws Exception { PutAnomalyDetectorResult result = null; try { result = executePutAnomalyDetector(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<PutDashboardResult> putDashboardAsync(PutDashboardRequest request) { return putDashboardAsync(request, null); } @Override public java.util.concurrent.Future<PutDashboardResult> putDashboardAsync(final PutDashboardRequest request, final com.amazonaws.handlers.AsyncHandler<PutDashboardRequest, PutDashboardResult> asyncHandler) { final PutDashboardRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<PutDashboardResult>() { @Override public PutDashboardResult call() throws Exception { PutDashboardResult result = null; try { result = executePutDashboard(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<PutInsightRuleResult> putInsightRuleAsync(PutInsightRuleRequest request) { return putInsightRuleAsync(request, null); } @Override public java.util.concurrent.Future<PutInsightRuleResult> putInsightRuleAsync( final PutInsightRuleRequest request, final com.amazonaws.handlers.AsyncHandler<PutInsightRuleRequest, PutInsightRuleResult> asyncHandler) { final PutInsightRuleRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<PutInsightRuleResult>() { @Override public PutInsightRuleResult call() throws Exception { PutInsightRuleResult result = null; try { result = executePutInsightRule(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<PutMetricAlarmResult> putMetricAlarmAsync(PutMetricAlarmRequest request) { return putMetricAlarmAsync(request, null); } @Override public java.util.concurrent.Future<PutMetricAlarmResult> putMetricAlarmAsync( final PutMetricAlarmRequest request, final com.amazonaws.handlers.AsyncHandler<PutMetricAlarmRequest, PutMetricAlarmResult> asyncHandler) { final PutMetricAlarmRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<PutMetricAlarmResult>() { @Override public PutMetricAlarmResult call() throws Exception { PutMetricAlarmResult result = null; try { result = executePutMetricAlarm(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<PutMetricDataResult> putMetricDataAsync(PutMetricDataRequest request) { return putMetricDataAsync(request, null); } @Override public java.util.concurrent.Future<PutMetricDataResult> putMetricDataAsync(final PutMetricDataRequest request, final com.amazonaws.handlers.AsyncHandler<PutMetricDataRequest, PutMetricDataResult> asyncHandler) { final PutMetricDataRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<PutMetricDataResult>() { @Override public PutMetricDataResult call() throws Exception { PutMetricDataResult result = null; try { result = executePutMetricData(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<SetAlarmStateResult> setAlarmStateAsync(SetAlarmStateRequest request) { return setAlarmStateAsync(request, null); } @Override public java.util.concurrent.Future<SetAlarmStateResult> setAlarmStateAsync(final SetAlarmStateRequest request, final com.amazonaws.handlers.AsyncHandler<SetAlarmStateRequest, SetAlarmStateResult> asyncHandler) { final SetAlarmStateRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<SetAlarmStateResult>() { @Override public SetAlarmStateResult call() throws Exception { SetAlarmStateResult result = null; try { result = executeSetAlarmState(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<TagResourceResult> tagResourceAsync(TagResourceRequest request) { return tagResourceAsync(request, null); } @Override public java.util.concurrent.Future<TagResourceResult> tagResourceAsync(final TagResourceRequest request, final com.amazonaws.handlers.AsyncHandler<TagResourceRequest, TagResourceResult> asyncHandler) { final TagResourceRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<TagResourceResult>() { @Override public TagResourceResult call() throws Exception { TagResourceResult result = null; try { result = executeTagResource(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<UntagResourceResult> untagResourceAsync(UntagResourceRequest request) { return untagResourceAsync(request, null); } @Override public java.util.concurrent.Future<UntagResourceResult> untagResourceAsync(final UntagResourceRequest request, final com.amazonaws.handlers.AsyncHandler<UntagResourceRequest, UntagResourceResult> asyncHandler) { final UntagResourceRequest finalRequest = beforeClientExecution(request); return executorService.submit(new java.util.concurrent.Callable<UntagResourceResult>() { @Override public UntagResourceResult call() throws Exception { UntagResourceResult result = null; try { result = executeUntagResource(finalRequest); } catch (Exception ex) { if (asyncHandler != null) { asyncHandler.onError(ex); } throw ex; } if (asyncHandler != null) { asyncHandler.onSuccess(finalRequest, 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(); } }