com.amazonaws.services.simplesystemsmanagement.AWSSimpleSystemsManagementAsyncClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-osgi Show documentation
/*
* Copyright 2011-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not
* use this file except in compliance with the License. A copy of the License is
* located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on
* an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.amazonaws.services.simplesystemsmanagement;
import com.amazonaws.services.simplesystemsmanagement.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
/**
* Interface for accessing Amazon SSM 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.
*
*
* This is the Amazon EC2 Simple Systems Manager (SSM) API Reference. SSM
* enables you to remotely manage the configuration of your Amazon EC2
* instances, virtual machines (VMs), or servers in your on-premises environment
* or in an environment provided by other cloud providers using scripts,
* commands, or the Amazon EC2 console. SSM includes an on-demand solution
* called Amazon EC2 Run Command and a lightweight instance configuration
* solution called SSM Config.
*
*
* This references is intended to be used with the EC2 Run Command User Guide
* for Linux or Windows.
*
*
*
* You must register your on-premises servers and VMs through an activation
* process before you can configure them using Run Command. Registered servers
* and VMs are called managed instances. For more information, see Setting Up Run Command On Managed Instances (On-Premises Servers and VMs) on
* Linux or Setting Up Run Command On Managed Instances (On-Premises Servers and VMs) on
* Windows.
*
*
*
* Run Command
*
*
* Run Command provides an on-demand experience for executing commands. You can
* use pre-defined SSM documents to perform the actions listed later in this
* section, or you can create your own documents. With these documents, you can
* remotely configure your instances by sending commands using the
* Commands page in the Amazon EC2 console, AWS Tools for Windows PowerShell, the AWS
* CLI, or AWS SDKs.
*
*
* Run Command reports the status of the command execution for each instance
* targeted by a command. You can also audit the command execution to understand
* who executed commands, when, and what changes were made. By switching between
* different SSM documents, you can quickly configure your instances with
* different types of commands. To get started with Run Command, verify that
* your environment meets the prerequisites for remotely running commands on EC2
* instances (Linux or Windows).
*
*
*
* SSM Config
*
*
* SSM Config is a lightweight instance configuration solution. SSM Config is
* currently only available for Windows instances. With SSM Config, you can
* specify a setup configuration for your instances. SSM Config is similar to
* EC2 User Data, which is another way of running one-time scripts or applying
* settings during instance launch. SSM Config is an extension of this
* capability. Using SSM documents, you can specify which actions the system
* should perform on your instances, including which applications to install,
* which AWS Directory Service directory to join, which Microsoft PowerShell
* modules to install, etc. If an instance is missing one or more of these
* configurations, the system makes those changes. By default, the system checks
* every five minutes to see if there is a new configuration to apply as defined
* in a new SSM document. If so, the system updates the instances accordingly.
* In this way, you can remotely maintain a consistent configuration baseline on
* your instances. SSM Config is available using the AWS CLI or the AWS Tools
* for Windows PowerShell. For more information, see Managing Windows Instance Configuration.
*
*
* SSM Config and Run Command include the following pre-defined documents.
*
*
* Linux
*
*
* -
*
* AWS-RunShellScript to run shell scripts
*
*
* -
*
* AWS-UpdateSSMAgent to update the Amazon SSM agent
*
*
*
*
*
* Windows
*
*
* -
*
* AWS-JoinDirectoryServiceDomain to join an AWS Directory
*
*
* -
*
* AWS-RunPowerShellScript to run PowerShell commands or scripts
*
*
* -
*
* AWS-UpdateEC2Config to update the EC2Config service
*
*
* -
*
* AWS-ConfigureWindowsUpdate to configure Windows Update settings
*
*
* -
*
* AWS-InstallApplication to install, repair, or uninstall software using
* an MSI package
*
*
* -
*
* AWS-InstallPowerShellModule to install PowerShell modules
*
*
* -
*
* AWS-ConfigureCloudWatch to configure Amazon CloudWatch Logs to monitor
* applications and systems
*
*
* -
*
* AWS-ListWindowsInventory to collect information about an EC2 instance
* running in Windows.
*
*
* -
*
* AWS-FindWindowsUpdates to scan an instance and determines which
* updates are missing.
*
*
* -
*
* AWS-InstallMissingWindowsUpdates to install missing updates on your
* EC2 instance.
*
*
* -
*
* AWS-InstallSpecificWindowsUpdates to install one or more specific
* updates.
*
*
*
*
*
* The commands or scripts specified in SSM documents run with administrative
* privilege on your instances because the Amazon SSM agent runs as root on
* Linux and the EC2Config service runs in the Local System account on Windows.
* If a user has permission to execute any of the pre-defined SSM documents (any
* document that begins with AWS-*) then that user also has administrator access
* to the instance. Delegate access to Run Command and SSM Config judiciously.
* This becomes extremely important if you create your own SSM documents. Amazon
* Web Services does not provide guidance about how to create secure SSM
* documents. You create SSM documents and delegate access to Run Command at
* your own risk. As a security best practice, we recommend that you assign
* access to "AWS-*" documents, especially the AWS-RunShellScript document on
* Linux and the AWS-RunPowerShellScript document on Windows, to trusted
* administrators only. You can create SSM documents for specific tasks and
* delegate access to non-administrators.
*
*
*
* For information about creating and sharing SSM documents, see the following
* topics in the SSM User Guide:
*
*
* -
*
* Creating SSM Documents and Sharing SSM Documents (Linux)
*
*
* -
*
* Creating SSM Documents and Sharing SSM Documents (Windows)
*
*
*
*/
@ThreadSafe
public class AWSSimpleSystemsManagementAsyncClient extends
AWSSimpleSystemsManagementClient implements
AWSSimpleSystemsManagementAsync {
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 Amazon
* SSM. A credentials provider chain will be used that searches for
* credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Credential profiles file at the default location (~/.aws/credentials)
* shared by all AWS SDKs and the AWS CLI
* - Instance profile credentials delivered through the Amazon EC2
* metadata service
*
*
* Asynchronous methods are delegated to a fixed-size thread pool containing
* 50 threads (to match the default maximum number of concurrent connections
* to the service).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSSimpleSystemsManagementAsyncClient() {
this(new com.amazonaws.auth.DefaultAWSCredentialsProviderChain());
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon
* SSM. 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 Amazon SSM (ex: proxy settings, retry counts, etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSSimpleSystemsManagementAsyncClient(
com.amazonaws.ClientConfiguration clientConfiguration) {
this(new com.amazonaws.auth.DefaultAWSCredentialsProviderChain(),
clientConfiguration, java.util.concurrent.Executors
.newFixedThreadPool(clientConfiguration
.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon
* SSM using the specified AWS account credentials.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing
* 50 threads (to match the default maximum number of concurrent connections
* to the service).
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when
* authenticating with AWS services.
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSSimpleSystemsManagementAsyncClient(
com.amazonaws.auth.AWSCredentials awsCredentials) {
this(awsCredentials, java.util.concurrent.Executors
.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon
* SSM using the specified AWS account credentials and executor service.
* Default client settings will be used.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when
* authenticating with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will be
* executed.
*/
public AWSSimpleSystemsManagementAsyncClient(
com.amazonaws.auth.AWSCredentials awsCredentials,
java.util.concurrent.ExecutorService executorService) {
this(awsCredentials, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon
* SSM using the specified AWS account credentials, executor service, and
* client configuration options.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when
* authenticating with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings,
* etc).
* @param executorService
* The executor service by which all asynchronous requests will be
* executed.
*/
public AWSSimpleSystemsManagementAsyncClient(
com.amazonaws.auth.AWSCredentials awsCredentials,
com.amazonaws.ClientConfiguration clientConfiguration,
java.util.concurrent.ExecutorService executorService) {
super(awsCredentials, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon
* SSM using the specified AWS account credentials provider. Default client
* settings will be used.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing
* 50 threads (to match the default maximum number of concurrent connections
* to the service).
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSSimpleSystemsManagementAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, java.util.concurrent.Executors
.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon
* SSM using the provided AWS account credentials provider and client
* configuration options.
*
* Asynchronous methods are delegated to a fixed-size thread pool containing
* a number of threads equal to the maximum number of concurrent connections
* configured via {@code ClientConfiguration.getMaxConnections()}.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings,
* etc).
*
* @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
* @see java.util.concurrent.Executors#newFixedThreadPool(int)
*/
public AWSSimpleSystemsManagementAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
com.amazonaws.ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration,
java.util.concurrent.Executors
.newFixedThreadPool(clientConfiguration
.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon
* SSM using the specified AWS account credentials provider and executor
* service. Default client settings will be used.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will be
* executed.
*/
public AWSSimpleSystemsManagementAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
java.util.concurrent.ExecutorService executorService) {
this(awsCredentialsProvider, configFactory.getConfig(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon
* SSM using the specified AWS account credentials provider, executor
* service, and client configuration options.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy settings,
* etc).
* @param executorService
* The executor service by which all asynchronous requests will be
* executed.
*/
public AWSSimpleSystemsManagementAsyncClient(
com.amazonaws.auth.AWSCredentialsProvider awsCredentialsProvider,
com.amazonaws.ClientConfiguration clientConfiguration,
java.util.concurrent.ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon
* SSM using the specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AWSSimpleSystemsManagementAsyncClient(AwsAsyncClientParams asyncClientParams) {
super(asyncClientParams);
this.executorService = asyncClientParams.getExecutor();
}
/**
* Returns the executor service used by this client to execute async
* requests.
*
* @return The executor service used by this client to execute async
* requests.
*/
public java.util.concurrent.ExecutorService getExecutorService() {
return executorService;
}
@Override
public java.util.concurrent.Future addTagsToResourceAsync(
AddTagsToResourceRequest request) {
return addTagsToResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future addTagsToResourceAsync(
final AddTagsToResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public AddTagsToResourceResult call() throws Exception {
AddTagsToResourceResult result;
try {
result = addTagsToResource(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future cancelCommandAsync(
CancelCommandRequest request) {
return cancelCommandAsync(request, null);
}
@Override
public java.util.concurrent.Future cancelCommandAsync(
final CancelCommandRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CancelCommandResult call() throws Exception {
CancelCommandResult result;
try {
result = cancelCommand(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createActivationAsync(
CreateActivationRequest request) {
return createActivationAsync(request, null);
}
@Override
public java.util.concurrent.Future createActivationAsync(
final CreateActivationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateActivationResult call() throws Exception {
CreateActivationResult result;
try {
result = createActivation(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createAssociationAsync(
CreateAssociationRequest request) {
return createAssociationAsync(request, null);
}
@Override
public java.util.concurrent.Future createAssociationAsync(
final CreateAssociationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateAssociationResult call() throws Exception {
CreateAssociationResult result;
try {
result = createAssociation(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createAssociationBatchAsync(
CreateAssociationBatchRequest request) {
return createAssociationBatchAsync(request, null);
}
@Override
public java.util.concurrent.Future createAssociationBatchAsync(
final CreateAssociationBatchRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateAssociationBatchResult call() throws Exception {
CreateAssociationBatchResult result;
try {
result = createAssociationBatch(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createDocumentAsync(
CreateDocumentRequest request) {
return createDocumentAsync(request, null);
}
@Override
public java.util.concurrent.Future createDocumentAsync(
final CreateDocumentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public CreateDocumentResult call() throws Exception {
CreateDocumentResult result;
try {
result = createDocument(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteActivationAsync(
DeleteActivationRequest request) {
return deleteActivationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteActivationAsync(
final DeleteActivationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteActivationResult call() throws Exception {
DeleteActivationResult result;
try {
result = deleteActivation(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteAssociationAsync(
DeleteAssociationRequest request) {
return deleteAssociationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteAssociationAsync(
final DeleteAssociationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAssociationResult call() throws Exception {
DeleteAssociationResult result;
try {
result = deleteAssociation(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteDocumentAsync(
DeleteDocumentRequest request) {
return deleteDocumentAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteDocumentAsync(
final DeleteDocumentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeleteDocumentResult call() throws Exception {
DeleteDocumentResult result;
try {
result = deleteDocument(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deregisterManagedInstanceAsync(
DeregisterManagedInstanceRequest request) {
return deregisterManagedInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future deregisterManagedInstanceAsync(
final DeregisterManagedInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DeregisterManagedInstanceResult call()
throws Exception {
DeregisterManagedInstanceResult result;
try {
result = deregisterManagedInstance(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeActivationsAsync(
DescribeActivationsRequest request) {
return describeActivationsAsync(request, null);
}
@Override
public java.util.concurrent.Future describeActivationsAsync(
final DescribeActivationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeActivationsResult call() throws Exception {
DescribeActivationsResult result;
try {
result = describeActivations(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeAssociationAsync(
DescribeAssociationRequest request) {
return describeAssociationAsync(request, null);
}
@Override
public java.util.concurrent.Future describeAssociationAsync(
final DescribeAssociationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeAssociationResult call() throws Exception {
DescribeAssociationResult result;
try {
result = describeAssociation(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeDocumentAsync(
DescribeDocumentRequest request) {
return describeDocumentAsync(request, null);
}
@Override
public java.util.concurrent.Future describeDocumentAsync(
final DescribeDocumentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeDocumentResult call() throws Exception {
DescribeDocumentResult result;
try {
result = describeDocument(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeDocumentPermissionAsync(
DescribeDocumentPermissionRequest request) {
return describeDocumentPermissionAsync(request, null);
}
@Override
public java.util.concurrent.Future describeDocumentPermissionAsync(
final DescribeDocumentPermissionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeDocumentPermissionResult call()
throws Exception {
DescribeDocumentPermissionResult result;
try {
result = describeDocumentPermission(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future describeInstanceInformationAsync(
DescribeInstanceInformationRequest request) {
return describeInstanceInformationAsync(request, null);
}
@Override
public java.util.concurrent.Future describeInstanceInformationAsync(
final DescribeInstanceInformationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public DescribeInstanceInformationResult call()
throws Exception {
DescribeInstanceInformationResult result;
try {
result = describeInstanceInformation(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getDocumentAsync(
GetDocumentRequest request) {
return getDocumentAsync(request, null);
}
@Override
public java.util.concurrent.Future getDocumentAsync(
final GetDocumentRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public GetDocumentResult call() throws Exception {
GetDocumentResult result;
try {
result = getDocument(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listAssociationsAsync(
ListAssociationsRequest request) {
return listAssociationsAsync(request, null);
}
@Override
public java.util.concurrent.Future listAssociationsAsync(
final ListAssociationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ListAssociationsResult call() throws Exception {
ListAssociationsResult result;
try {
result = listAssociations(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listCommandInvocationsAsync(
ListCommandInvocationsRequest request) {
return listCommandInvocationsAsync(request, null);
}
@Override
public java.util.concurrent.Future listCommandInvocationsAsync(
final ListCommandInvocationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ListCommandInvocationsResult call() throws Exception {
ListCommandInvocationsResult result;
try {
result = listCommandInvocations(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listCommandsAsync(
ListCommandsRequest request) {
return listCommandsAsync(request, null);
}
@Override
public java.util.concurrent.Future listCommandsAsync(
final ListCommandsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ListCommandsResult call() throws Exception {
ListCommandsResult result;
try {
result = listCommands(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listDocumentsAsync(
ListDocumentsRequest request) {
return listDocumentsAsync(request, null);
}
@Override
public java.util.concurrent.Future listDocumentsAsync(
final ListDocumentsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ListDocumentsResult call() throws Exception {
ListDocumentsResult result;
try {
result = listDocuments(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Simplified method form for invoking the ListDocuments operation.
*
* @see #listDocumentsAsync(ListDocumentsRequest)
*/
@Override
public java.util.concurrent.Future listDocumentsAsync() {
return listDocumentsAsync(new ListDocumentsRequest());
}
/**
* Simplified method form for invoking the ListDocuments operation with an
* AsyncHandler.
*
* @see #listDocumentsAsync(ListDocumentsRequest,
* com.amazonaws.handlers.AsyncHandler)
*/
public java.util.concurrent.Future listDocumentsAsync(
com.amazonaws.handlers.AsyncHandler asyncHandler) {
return listDocumentsAsync(new ListDocumentsRequest(), asyncHandler);
}
@Override
public java.util.concurrent.Future listTagsForResourceAsync(
ListTagsForResourceRequest request) {
return listTagsForResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future listTagsForResourceAsync(
final ListTagsForResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ListTagsForResourceResult call() throws Exception {
ListTagsForResourceResult result;
try {
result = listTagsForResource(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future modifyDocumentPermissionAsync(
ModifyDocumentPermissionRequest request) {
return modifyDocumentPermissionAsync(request, null);
}
@Override
public java.util.concurrent.Future modifyDocumentPermissionAsync(
final ModifyDocumentPermissionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public ModifyDocumentPermissionResult call()
throws Exception {
ModifyDocumentPermissionResult result;
try {
result = modifyDocumentPermission(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future removeTagsFromResourceAsync(
RemoveTagsFromResourceRequest request) {
return removeTagsFromResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future removeTagsFromResourceAsync(
final RemoveTagsFromResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public RemoveTagsFromResourceResult call() throws Exception {
RemoveTagsFromResourceResult result;
try {
result = removeTagsFromResource(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future sendCommandAsync(
SendCommandRequest request) {
return sendCommandAsync(request, null);
}
@Override
public java.util.concurrent.Future sendCommandAsync(
final SendCommandRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public SendCommandResult call() throws Exception {
SendCommandResult result;
try {
result = sendCommand(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateAssociationStatusAsync(
UpdateAssociationStatusRequest request) {
return updateAssociationStatusAsync(request, null);
}
@Override
public java.util.concurrent.Future updateAssociationStatusAsync(
final UpdateAssociationStatusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public UpdateAssociationStatusResult call()
throws Exception {
UpdateAssociationStatusResult result;
try {
result = updateAssociationStatus(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateManagedInstanceRoleAsync(
UpdateManagedInstanceRoleRequest request) {
return updateManagedInstanceRoleAsync(request, null);
}
@Override
public java.util.concurrent.Future updateManagedInstanceRoleAsync(
final UpdateManagedInstanceRoleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
return executorService
.submit(new java.util.concurrent.Callable() {
@Override
public UpdateManagedInstanceRoleResult call()
throws Exception {
UpdateManagedInstanceRoleResult result;
try {
result = updateManagedInstanceRole(request);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(request, result);
}
return result;
}
});
}
/**
* Shuts down the client, releasing all managed resources. This includes
* forcibly terminating all pending asynchronous service calls. Clients who
* wish to give pending asynchronous service calls time to complete should
* call {@code getExecutorService().shutdown()} followed by
* {@code getExecutorService().awaitTermination()} prior to calling this
* method.
*/
@Override
public void shutdown() {
super.shutdown();
executorService.shutdownNow();
}
}