Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * Copyright 2010-2015 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.ecs;
  
  
  
Asynchronous client for accessing AmazonECS. All asynchronous calls made using this client are non-blocking. Callers could either process the result and handle the exceptions in the worker thread by providing a callback handler when making the call, or use the returned Future object to check the result of the call in the calling thread.

Amazon EC2 Container Service (Amazon ECS) is a highly scalable, fast, container management service that makes it easy to run, stop, and manage Docker containers on a cluster of Amazon EC2 instances. Amazon ECS lets you launch and stop container-enabled applications with simple API calls, allows you to get the state of your cluster from a centralized service, and gives you access to many familiar Amazon EC2 features like security groups, Amazon EBS volumes, and IAM roles.

You can use Amazon ECS to schedule the placement of containers across your cluster based on your resource needs, isolation policies, and availability requirements. Amazon EC2 Container Service eliminates the need for you to operate your own cluster management and configuration management systems or worry about scaling your management infrastructure.

  
  public class AmazonECSAsyncClient extends AmazonECSClient
          implements AmazonECSAsync {

    
Executor service for executing asynchronous requests.
  
      private ExecutorService executorService;
  
      private static final int DEFAULT_THREAD_POOL_SIZE = 50;

    
Constructs a new asynchronous client to invoke service methods on AmazonECS. 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
  • Instance profile credentials delivered through the Amazon EC2 metadata service

All service calls made using this new client object are blocking, and will not return until the service call completes.

  
      public AmazonECSAsyncClient() {
          this(new DefaultAWSCredentialsProviderChain());
      }

    
Constructs a new asynchronous client to invoke service methods on AmazonECS. 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
  • Instance profile credentials delivered through the Amazon EC2 metadata service

All service calls made using this new client object are blocking, and will not return until the service call completes.

Parameters:
clientConfiguration The client configuration options controlling how this client connects to AmazonECS (ex: proxy settings, retry counts, etc.).
See also:
com.amazonaws.auth.DefaultAWSCredentialsProviderChain
 
     public AmazonECSAsyncClient(ClientConfiguration clientConfiguration) {
         this(new DefaultAWSCredentialsProviderChain(), clientConfiguration, Executors.newFixedThreadPool(clientConfiguration.getMaxConnections()));
     }

    
Constructs a new asynchronous client to invoke service methods on AmazonECS using the specified AWS account credentials. Default client settings will be used, and a fixed size thread pool will be created for executing the asynchronous tasks.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentials The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
 
     public AmazonECSAsyncClient(AWSCredentials awsCredentials) {
         this(awsCredentials, Executors.newFixedThreadPool());
     }

    
Constructs a new asynchronous client to invoke service methods on AmazonECS using the specified AWS account credentials and executor service. Default client settings will be used.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentials The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
executorService The executor service by which all asynchronous requests will be executed.
 
     public AmazonECSAsyncClient(AWSCredentials awsCredentialsExecutorService executorService) {
         super(awsCredentials);
         this. = executorService;
     }

    
Constructs a new asynchronous client to invoke service methods on AmazonECS using the specified AWS account credentials, executor service, and client configuration options.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentials The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
clientConfiguration Client configuration options (ex: max retry limit, proxy settings, etc).
executorService The executor service by which all asynchronous requests will be executed.
 
     public AmazonECSAsyncClient(AWSCredentials awsCredentials,
                 ClientConfiguration clientConfigurationExecutorService executorService) {
         super(awsCredentialsclientConfiguration);
         this. = executorService;
     }

    
Constructs a new asynchronous client to invoke service methods on AmazonECS using the specified AWS account credentials provider. Default client settings will be used, and a fixed size thread pool will be created for executing the asynchronous tasks.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentialsProvider The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
 
     public AmazonECSAsyncClient(AWSCredentialsProvider awsCredentialsProvider) {
         this(awsCredentialsProvider, Executors.newFixedThreadPool());
     }

    
Constructs a new asynchronous client to invoke service methods on AmazonECS using the specified AWS account credentials provider and executor service. Default client settings will be used.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentialsProvider The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
executorService The executor service by which all asynchronous requests will be executed.
 
     public AmazonECSAsyncClient(AWSCredentialsProvider awsCredentialsProviderExecutorService executorService) {
         this(awsCredentialsProvidernew ClientConfiguration(), executorService);
     }

    
Constructs a new asynchronous client to invoke service methods on AmazonECS using the specified AWS account credentials provider and client configuration options.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentialsProvider The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
clientConfiguration Client configuration options (ex: max retry limit, proxy settings, etc).
 
     public AmazonECSAsyncClient(AWSCredentialsProvider awsCredentialsProvider,
                 ClientConfiguration clientConfiguration) {
         this(awsCredentialsProviderclientConfiguration, Executors.newFixedThreadPool(clientConfiguration.getMaxConnections()));
     }

    
Constructs a new asynchronous client to invoke service methods on AmazonECS using the specified AWS account credentials provider, executor service, and client configuration options.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentialsProvider The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
clientConfiguration Client configuration options (ex: max retry limit, proxy settings, etc).
executorService The executor service by which all asynchronous requests will be executed.
 
     public AmazonECSAsyncClient(AWSCredentialsProvider awsCredentialsProvider,
                 ClientConfiguration clientConfigurationExecutorService executorService) {
         super(awsCredentialsProviderclientConfiguration);
         this. = executorService;
     }

    
Returns the executor service used by this async client to execute requests.

Returns:
The executor service used by this async client to execute requests.
 
     public ExecutorService getExecutorService() {
         return ;
     }

    
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 getExecutorService().shutdown() followed by getExecutorService().awaitTermination() prior to calling this method.
 
     @Override
     public void shutdown() {
         super.shutdown();
         .shutdownNow();
     }
            
    

Deletes the specified cluster. You must deregister all container instances from this cluster before you may delete it. You can list the container instances in a cluster with ListContainerInstances and deregister them with DeregisterContainerInstance.

Parameters:
deleteClusterRequest Container for the necessary parameters to execute the DeleteCluster operation on AmazonECS.
Returns:
A Java Future object containing the response from the DeleteCluster service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
     public Future<DeleteClusterResultdeleteClusterAsync(final DeleteClusterRequest deleteClusterRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<DeleteClusterResult>() {
             public DeleteClusterResult call() throws Exception {
                 return deleteCluster(deleteClusterRequest);
         }
     });
     }

    

Deletes the specified cluster. You must deregister all container instances from this cluster before you may delete it. You can list the container instances in a cluster with ListContainerInstances and deregister them with DeregisterContainerInstance.

Parameters:
deleteClusterRequest Container for the necessary parameters to execute the DeleteCluster operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DeleteCluster service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
             final DeleteClusterRequest deleteClusterRequest,
             final AsyncHandler<DeleteClusterRequestDeleteClusterResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<DeleteClusterResult>() {
             public DeleteClusterResult call() throws Exception {
               DeleteClusterResult result;
                 try {
                 result = deleteCluster(deleteClusterRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(deleteClusterRequestresult);
                  return result;
         }
     });
     }
    
    

Deletes a specified service within a cluster.

Parameters:
deleteServiceRequest Container for the necessary parameters to execute the DeleteService operation on AmazonECS.
Returns:
A Java Future object containing the response from the DeleteService service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
     public Future<DeleteServiceResultdeleteServiceAsync(final DeleteServiceRequest deleteServiceRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<DeleteServiceResult>() {
             public DeleteServiceResult call() throws Exception {
                 return deleteService(deleteServiceRequest);
         }
     });
     }

    

Deletes a specified service within a cluster.

Parameters:
deleteServiceRequest Container for the necessary parameters to execute the DeleteService operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DeleteService service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
             final DeleteServiceRequest deleteServiceRequest,
             final AsyncHandler<DeleteServiceRequestDeleteServiceResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<DeleteServiceResult>() {
             public DeleteServiceResult call() throws Exception {
               DeleteServiceResult result;
                 try {
                 result = deleteService(deleteServiceRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(deleteServiceRequestresult);
                  return result;
         }
     });
     }
    
    

NOTE: This action is only used by the Amazon EC2 Container Service agent, and it is not intended for use outside of the agent.

Sent to acknowledge that a container changed states.

Parameters:
submitContainerStateChangeRequest Container for the necessary parameters to execute the SubmitContainerStateChange operation on AmazonECS.
Returns:
A Java Future object containing the response from the SubmitContainerStateChange service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
             throws AmazonServiceExceptionAmazonClientException {
             public SubmitContainerStateChangeResult call() throws Exception {
                 return submitContainerStateChange(submitContainerStateChangeRequest);
         }
     });
     }

    

NOTE: This action is only used by the Amazon EC2 Container Service agent, and it is not intended for use outside of the agent.

Sent to acknowledge that a container changed states.

Parameters:
submitContainerStateChangeRequest Container for the necessary parameters to execute the SubmitContainerStateChange operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the SubmitContainerStateChange service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
             final SubmitContainerStateChangeRequest submitContainerStateChangeRequest,
                     throws AmazonServiceExceptionAmazonClientException {
             public SubmitContainerStateChangeResult call() throws Exception {
               SubmitContainerStateChangeResult result;
                 try {
                 result = submitContainerStateChange(submitContainerStateChangeRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(submitContainerStateChangeRequestresult);
                  return result;
         }
     });
     }
    
    

Returns a list of task definitions that are registered to your account. You can filter the results by family name with the familyPrefix parameter.

Parameters:
listTaskDefinitionsRequest Container for the necessary parameters to execute the ListTaskDefinitions operation on AmazonECS.
Returns:
A Java Future object containing the response from the ListTaskDefinitions service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
     public Future<ListTaskDefinitionsResultlistTaskDefinitionsAsync(final ListTaskDefinitionsRequest listTaskDefinitionsRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<ListTaskDefinitionsResult>() {
             public ListTaskDefinitionsResult call() throws Exception {
                 return listTaskDefinitions(listTaskDefinitionsRequest);
         }
     });
     }

    

Returns a list of task definitions that are registered to your account. You can filter the results by family name with the familyPrefix parameter.

Parameters:
listTaskDefinitionsRequest Container for the necessary parameters to execute the ListTaskDefinitions operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the ListTaskDefinitions service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
             final ListTaskDefinitionsRequest listTaskDefinitionsRequest,
             final AsyncHandler<ListTaskDefinitionsRequestListTaskDefinitionsResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<ListTaskDefinitionsResult>() {
             public ListTaskDefinitionsResult call() throws Exception {
               ListTaskDefinitionsResult result;
                 try {
                 result = listTaskDefinitions(listTaskDefinitionsRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(listTaskDefinitionsRequestresult);
                  return result;
         }
     });
     }
    
    

Start a task using random placement and the default Amazon ECS scheduler. If you want to use your own scheduler or place a task on a specific container instance, use StartTask instead.

IMPORTANT: The count parameter is limited to 10 tasks per call.

Parameters:
runTaskRequest Container for the necessary parameters to execute the RunTask operation on AmazonECS.
Returns:
A Java Future object containing the response from the RunTask service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
     public Future<RunTaskResultrunTaskAsync(final RunTaskRequest runTaskRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<RunTaskResult>() {
             public RunTaskResult call() throws Exception {
                 return runTask(runTaskRequest);
         }
     });
     }

    

Start a task using random placement and the default Amazon ECS scheduler. If you want to use your own scheduler or place a task on a specific container instance, use StartTask instead.

IMPORTANT: The count parameter is limited to 10 tasks per call.

Parameters:
runTaskRequest Container for the necessary parameters to execute the RunTask operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the RunTask service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
     public Future<RunTaskResultrunTaskAsync(
             final RunTaskRequest runTaskRequest,
             final AsyncHandler<RunTaskRequestRunTaskResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<RunTaskResult>() {
             public RunTaskResult call() throws Exception {
               RunTaskResult result;
                 try {
                 result = runTask(runTaskRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(runTaskRequestresult);
                  return result;
         }
     });
     }
    
    

Returns a list of existing clusters.

Parameters:
listClustersRequest Container for the necessary parameters to execute the ListClusters operation on AmazonECS.
Returns:
A Java Future object containing the response from the ListClusters service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
     public Future<ListClustersResultlistClustersAsync(final ListClustersRequest listClustersRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<ListClustersResult>() {
             public ListClustersResult call() throws Exception {
                 return listClusters(listClustersRequest);
         }
     });
     }

    

Returns a list of existing clusters.

Parameters:
listClustersRequest Container for the necessary parameters to execute the ListClusters operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the ListClusters service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
             final ListClustersRequest listClustersRequest,
             final AsyncHandler<ListClustersRequestListClustersResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<ListClustersResult>() {
             public ListClustersResult call() throws Exception {
               ListClustersResult result;
                 try {
                 result = listClusters(listClustersRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(listClustersRequestresult);
                  return result;
         }
     });
     }
    
    

Creates a new Amazon ECS cluster. By default, your account will receive a default cluster when you launch your first container instance. However, you can create your own cluster with a unique name with the CreateCluster action.

Parameters:
createClusterRequest Container for the necessary parameters to execute the CreateCluster operation on AmazonECS.
Returns:
A Java Future object containing the response from the CreateCluster service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
     public Future<CreateClusterResultcreateClusterAsync(final CreateClusterRequest createClusterRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<CreateClusterResult>() {
             public CreateClusterResult call() throws Exception {
                 return createCluster(createClusterRequest);
         }
     });
     }

    

Creates a new Amazon ECS cluster. By default, your account will receive a default cluster when you launch your first container instance. However, you can create your own cluster with a unique name with the CreateCluster action.

Parameters:
createClusterRequest Container for the necessary parameters to execute the CreateCluster operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the CreateCluster service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
             final CreateClusterRequest createClusterRequest,
             final AsyncHandler<CreateClusterRequestCreateClusterResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<CreateClusterResult>() {
             public CreateClusterResult call() throws Exception {
               CreateClusterResult result;
                 try {
                 result = createCluster(createClusterRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(createClusterRequestresult);
                  return result;
         }
     });
     }
    
    

Describes one or more of your clusters.

Parameters:
describeClustersRequest Container for the necessary parameters to execute the DescribeClusters operation on AmazonECS.
Returns:
A Java Future object containing the response from the DescribeClusters service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
     public Future<DescribeClustersResultdescribeClustersAsync(final DescribeClustersRequest describeClustersRequest
             throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<DescribeClustersResult>() {
             public DescribeClustersResult call() throws Exception {
                 return describeClusters(describeClustersRequest);
         }
     });
     }

    

Describes one or more of your clusters.

Parameters:
describeClustersRequest Container for the necessary parameters to execute the DescribeClusters operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DescribeClusters service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
             final DescribeClustersRequest describeClustersRequest,
             final AsyncHandler<DescribeClustersRequestDescribeClustersResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<DescribeClustersResult>() {
             public DescribeClustersResult call() throws Exception {
               DescribeClustersResult result;
                 try {
                 result = describeClusters(describeClustersRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(describeClustersRequestresult);
                  return result;
         }
     });
     }
    
    

Deregisters an Amazon ECS container instance from the specified cluster. This instance will no longer be available to run tasks.

Parameters:
deregisterContainerInstanceRequest Container for the necessary parameters to execute the DeregisterContainerInstance operation on AmazonECS.
Returns:
A Java Future object containing the response from the DeregisterContainerInstance service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
             throws AmazonServiceExceptionAmazonClientException {
             public DeregisterContainerInstanceResult call() throws Exception {
                 return deregisterContainerInstance(deregisterContainerInstanceRequest);
         }
     });
     }

    

Deregisters an Amazon ECS container instance from the specified cluster. This instance will no longer be available to run tasks.

Parameters:
deregisterContainerInstanceRequest Container for the necessary parameters to execute the DeregisterContainerInstance operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DeregisterContainerInstance service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
             final DeregisterContainerInstanceRequest deregisterContainerInstanceRequest,
                     throws AmazonServiceExceptionAmazonClientException {
             public DeregisterContainerInstanceResult call() throws Exception {
               DeregisterContainerInstanceResult result;
                 try {
                 result = deregisterContainerInstance(deregisterContainerInstanceRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(deregisterContainerInstanceRequestresult);
                  return result;
         }
     });
     }
    
    

Returns a list of container instances in a specified cluster.

Parameters:
listContainerInstancesRequest Container for the necessary parameters to execute the ListContainerInstances operation on AmazonECS.
Returns:
A Java Future object containing the response from the ListContainerInstances service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
 
            throws AmazonServiceExceptionAmazonClientException {
            public ListContainerInstancesResult call() throws Exception {
                return listContainerInstances(listContainerInstancesRequest);
        }
    });
    }

    

Returns a list of container instances in a specified cluster.

Parameters:
listContainerInstancesRequest Container for the necessary parameters to execute the ListContainerInstances operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the ListContainerInstances service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final ListContainerInstancesRequest listContainerInstancesRequest,
            final AsyncHandler<ListContainerInstancesRequestListContainerInstancesResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
            public ListContainerInstancesResult call() throws Exception {
              ListContainerInstancesResult result;
                try {
                result = listContainerInstances(listContainerInstancesRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(listContainerInstancesRequestresult);
                 return result;
        }
    });
    }
    
    

NOT YET IMPLEMENTED.

Deregisters the specified task definition. You will no longer be able to run tasks from this definition after deregistration.

Parameters:
deregisterTaskDefinitionRequest Container for the necessary parameters to execute the DeregisterTaskDefinition operation on AmazonECS.
Returns:
A Java Future object containing the response from the DeregisterTaskDefinition service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            throws AmazonServiceExceptionAmazonClientException {
            public DeregisterTaskDefinitionResult call() throws Exception {
                return deregisterTaskDefinition(deregisterTaskDefinitionRequest);
        }
    });
    }

    

NOT YET IMPLEMENTED.

Deregisters the specified task definition. You will no longer be able to run tasks from this definition after deregistration.

Parameters:
deregisterTaskDefinitionRequest Container for the necessary parameters to execute the DeregisterTaskDefinition operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DeregisterTaskDefinition service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final DeregisterTaskDefinitionRequest deregisterTaskDefinitionRequest,
                    throws AmazonServiceExceptionAmazonClientException {
            public DeregisterTaskDefinitionResult call() throws Exception {
              DeregisterTaskDefinitionResult result;
                try {
                result = deregisterTaskDefinition(deregisterTaskDefinitionRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(deregisterTaskDefinitionRequestresult);
                 return result;
        }
    });
    }
    
    

Describes a task definition. You can specify a family and revision to find information on a specific task definition, or you can simply specify the family to find the latest revision in that family.

Parameters:
describeTaskDefinitionRequest Container for the necessary parameters to execute the DescribeTaskDefinition operation on AmazonECS.
Returns:
A Java Future object containing the response from the DescribeTaskDefinition service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            throws AmazonServiceExceptionAmazonClientException {
            public DescribeTaskDefinitionResult call() throws Exception {
                return describeTaskDefinition(describeTaskDefinitionRequest);
        }
    });
    }

    

Describes a task definition. You can specify a family and revision to find information on a specific task definition, or you can simply specify the family to find the latest revision in that family.

Parameters:
describeTaskDefinitionRequest Container for the necessary parameters to execute the DescribeTaskDefinition operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DescribeTaskDefinition service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final DescribeTaskDefinitionRequest describeTaskDefinitionRequest,
            final AsyncHandler<DescribeTaskDefinitionRequestDescribeTaskDefinitionResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
            public DescribeTaskDefinitionResult call() throws Exception {
              DescribeTaskDefinitionResult result;
                try {
                result = describeTaskDefinition(describeTaskDefinitionRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(describeTaskDefinitionRequestresult);
                 return result;
        }
    });
    }
    
    

Registers a new task definition from the supplied family and containerDefinitions . Optionally, you can add data volumes to your containers with the volumes parameter. For more information on task definition parameters and defaults, see Amazon ECS Task Definitions in the Amazon EC2 Container Service Developer Guide .

Parameters:
registerTaskDefinitionRequest Container for the necessary parameters to execute the RegisterTaskDefinition operation on AmazonECS.
Returns:
A Java Future object containing the response from the RegisterTaskDefinition service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            throws AmazonServiceExceptionAmazonClientException {
            public RegisterTaskDefinitionResult call() throws Exception {
                return registerTaskDefinition(registerTaskDefinitionRequest);
        }
    });
    }

    

Registers a new task definition from the supplied family and containerDefinitions . Optionally, you can add data volumes to your containers with the volumes parameter. For more information on task definition parameters and defaults, see Amazon ECS Task Definitions in the Amazon EC2 Container Service Developer Guide .

Parameters:
registerTaskDefinitionRequest Container for the necessary parameters to execute the RegisterTaskDefinition operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the RegisterTaskDefinition service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final RegisterTaskDefinitionRequest registerTaskDefinitionRequest,
            final AsyncHandler<RegisterTaskDefinitionRequestRegisterTaskDefinitionResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
            public RegisterTaskDefinitionResult call() throws Exception {
              RegisterTaskDefinitionResult result;
                try {
                result = registerTaskDefinition(registerTaskDefinitionRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(registerTaskDefinitionRequestresult);
                 return result;
        }
    });
    }
    
    

NOTE: This action is only used by the Amazon EC2 Container Service agent, and it is not intended for use outside of the agent.

Sent to acknowledge that a task changed states.

Parameters:
submitTaskStateChangeRequest Container for the necessary parameters to execute the SubmitTaskStateChange operation on AmazonECS.
Returns:
A Java Future object containing the response from the SubmitTaskStateChange service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
    public Future<SubmitTaskStateChangeResultsubmitTaskStateChangeAsync(final SubmitTaskStateChangeRequest submitTaskStateChangeRequest
            throws AmazonServiceExceptionAmazonClientException {
            public SubmitTaskStateChangeResult call() throws Exception {
                return submitTaskStateChange(submitTaskStateChangeRequest);
        }
    });
    }

    

NOTE: This action is only used by the Amazon EC2 Container Service agent, and it is not intended for use outside of the agent.

Sent to acknowledge that a task changed states.

Parameters:
submitTaskStateChangeRequest Container for the necessary parameters to execute the SubmitTaskStateChange operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the SubmitTaskStateChange service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final SubmitTaskStateChangeRequest submitTaskStateChangeRequest,
            final AsyncHandler<SubmitTaskStateChangeRequestSubmitTaskStateChangeResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
            public SubmitTaskStateChangeResult call() throws Exception {
              SubmitTaskStateChangeResult result;
                try {
                result = submitTaskStateChange(submitTaskStateChangeRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(submitTaskStateChangeRequestresult);
                 return result;
        }
    });
    }
    
    

Describes Amazon EC2 Container Service container instances. Returns metadata about registered and remaining resources on each container instance requested.

Parameters:
describeContainerInstancesRequest Container for the necessary parameters to execute the DescribeContainerInstances operation on AmazonECS.
Returns:
A Java Future object containing the response from the DescribeContainerInstances service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            throws AmazonServiceExceptionAmazonClientException {
            public DescribeContainerInstancesResult call() throws Exception {
                return describeContainerInstances(describeContainerInstancesRequest);
        }
    });
    }

    

Describes Amazon EC2 Container Service container instances. Returns metadata about registered and remaining resources on each container instance requested.

Parameters:
describeContainerInstancesRequest Container for the necessary parameters to execute the DescribeContainerInstances operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DescribeContainerInstances service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final DescribeContainerInstancesRequest describeContainerInstancesRequest,
                    throws AmazonServiceExceptionAmazonClientException {
            public DescribeContainerInstancesResult call() throws Exception {
              DescribeContainerInstancesResult result;
                try {
                result = describeContainerInstances(describeContainerInstancesRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(describeContainerInstancesRequestresult);
                 return result;
        }
    });
    }
    
    

NOTE: This action is only used by the Amazon EC2 Container Service agent, and it is not intended for use outside of the agent.

Registers an Amazon EC2 instance into the specified cluster. This instance will become available to place containers on.

Parameters:
registerContainerInstanceRequest Container for the necessary parameters to execute the RegisterContainerInstance operation on AmazonECS.
Returns:
A Java Future object containing the response from the RegisterContainerInstance service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            throws AmazonServiceExceptionAmazonClientException {
            public RegisterContainerInstanceResult call() throws Exception {
                return registerContainerInstance(registerContainerInstanceRequest);
        }
    });
    }

    

NOTE: This action is only used by the Amazon EC2 Container Service agent, and it is not intended for use outside of the agent.

Registers an Amazon EC2 instance into the specified cluster. This instance will become available to place containers on.

Parameters:
registerContainerInstanceRequest Container for the necessary parameters to execute the RegisterContainerInstance operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the RegisterContainerInstance service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final RegisterContainerInstanceRequest registerContainerInstanceRequest,
                    throws AmazonServiceExceptionAmazonClientException {
            public RegisterContainerInstanceResult call() throws Exception {
              RegisterContainerInstanceResult result;
                try {
                result = registerContainerInstance(registerContainerInstanceRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(registerContainerInstanceRequestresult);
                 return result;
        }
    });
    }
    
    

Describes the specified services running in your cluster.

Parameters:
describeServicesRequest Container for the necessary parameters to execute the DescribeServices operation on AmazonECS.
Returns:
A Java Future object containing the response from the DescribeServices service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
    public Future<DescribeServicesResultdescribeServicesAsync(final DescribeServicesRequest describeServicesRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<DescribeServicesResult>() {
            public DescribeServicesResult call() throws Exception {
                return describeServices(describeServicesRequest);
        }
    });
    }

    

Describes the specified services running in your cluster.

Parameters:
describeServicesRequest Container for the necessary parameters to execute the DescribeServices operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DescribeServices service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final DescribeServicesRequest describeServicesRequest,
            final AsyncHandler<DescribeServicesRequestDescribeServicesResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<DescribeServicesResult>() {
            public DescribeServicesResult call() throws Exception {
              DescribeServicesResult result;
                try {
                result = describeServices(describeServicesRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(describeServicesRequestresult);
                 return result;
        }
    });
    }
    
    

Runs and maintains a desired number of tasks from a specified task definition. If the number of tasks running in a service drops below desiredCount , Amazon ECS will spawn another instantiation of the task in the specified cluster.

Parameters:
createServiceRequest Container for the necessary parameters to execute the CreateService operation on AmazonECS.
Returns:
A Java Future object containing the response from the CreateService service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
    public Future<CreateServiceResultcreateServiceAsync(final CreateServiceRequest createServiceRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<CreateServiceResult>() {
            public CreateServiceResult call() throws Exception {
                return createService(createServiceRequest);
        }
    });
    }

    

Runs and maintains a desired number of tasks from a specified task definition. If the number of tasks running in a service drops below desiredCount , Amazon ECS will spawn another instantiation of the task in the specified cluster.

Parameters:
createServiceRequest Container for the necessary parameters to execute the CreateService operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the CreateService service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final CreateServiceRequest createServiceRequest,
            final AsyncHandler<CreateServiceRequestCreateServiceResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<CreateServiceResult>() {
            public CreateServiceResult call() throws Exception {
              CreateServiceResult result;
                try {
                result = createService(createServiceRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(createServiceRequestresult);
                 return result;
        }
    });
    }
    
    

Lists the services that are running in a specified cluster.

Parameters:
listServicesRequest Container for the necessary parameters to execute the ListServices operation on AmazonECS.
Returns:
A Java Future object containing the response from the ListServices service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
    public Future<ListServicesResultlistServicesAsync(final ListServicesRequest listServicesRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<ListServicesResult>() {
            public ListServicesResult call() throws Exception {
                return listServices(listServicesRequest);
        }
    });
    }

    

Lists the services that are running in a specified cluster.

Parameters:
listServicesRequest Container for the necessary parameters to execute the ListServices operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the ListServices service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final ListServicesRequest listServicesRequest,
            final AsyncHandler<ListServicesRequestListServicesResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<ListServicesResult>() {
            public ListServicesResult call() throws Exception {
              ListServicesResult result;
                try {
                result = listServices(listServicesRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(listServicesRequestresult);
                 return result;
        }
    });
    }
    
    

Modify the desired count or task definition used in a service.

You can add to or subtract from the number of instantiations of a task definition in a service by specifying the cluster that the service is running in and a new desiredCount parameter.

You can use UpdateService to modify your task definition and deploy a new version of your service, one task at a time. If you modify the task definition with UpdateService , Amazon ECS spawns a task with the new version of the task definition and then stops an old task after the new version is running. Because UpdateService starts a new version of the task before stopping an old version, your cluster must have capacity to support one more instantiation of the task when UpdateService is run. If your cluster cannot support another instantiation of the task used in your service, you can reduce the desired count of your service by one before modifying the task definition.

Parameters:
updateServiceRequest Container for the necessary parameters to execute the UpdateService operation on AmazonECS.
Returns:
A Java Future object containing the response from the UpdateService service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
    public Future<UpdateServiceResultupdateServiceAsync(final UpdateServiceRequest updateServiceRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<UpdateServiceResult>() {
            public UpdateServiceResult call() throws Exception {
                return updateService(updateServiceRequest);
        }
    });
    }

    

Modify the desired count or task definition used in a service.

You can add to or subtract from the number of instantiations of a task definition in a service by specifying the cluster that the service is running in and a new desiredCount parameter.

You can use UpdateService to modify your task definition and deploy a new version of your service, one task at a time. If you modify the task definition with UpdateService , Amazon ECS spawns a task with the new version of the task definition and then stops an old task after the new version is running. Because UpdateService starts a new version of the task before stopping an old version, your cluster must have capacity to support one more instantiation of the task when UpdateService is run. If your cluster cannot support another instantiation of the task used in your service, you can reduce the desired count of your service by one before modifying the task definition.

Parameters:
updateServiceRequest Container for the necessary parameters to execute the UpdateService operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the UpdateService service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final UpdateServiceRequest updateServiceRequest,
            final AsyncHandler<UpdateServiceRequestUpdateServiceResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<UpdateServiceResult>() {
            public UpdateServiceResult call() throws Exception {
              UpdateServiceResult result;
                try {
                result = updateService(updateServiceRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(updateServiceRequestresult);
                 return result;
        }
    });
    }
    
    

Returns a list of task definition families that are registered to your account. You can filter the results with the familyPrefix parameter.

Parameters:
listTaskDefinitionFamiliesRequest Container for the necessary parameters to execute the ListTaskDefinitionFamilies operation on AmazonECS.
Returns:
A Java Future object containing the response from the ListTaskDefinitionFamilies service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            throws AmazonServiceExceptionAmazonClientException {
            public ListTaskDefinitionFamiliesResult call() throws Exception {
                return listTaskDefinitionFamilies(listTaskDefinitionFamiliesRequest);
        }
    });
    }

    

Returns a list of task definition families that are registered to your account. You can filter the results with the familyPrefix parameter.

Parameters:
listTaskDefinitionFamiliesRequest Container for the necessary parameters to execute the ListTaskDefinitionFamilies operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the ListTaskDefinitionFamilies service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final ListTaskDefinitionFamiliesRequest listTaskDefinitionFamiliesRequest,
                    throws AmazonServiceExceptionAmazonClientException {
            public ListTaskDefinitionFamiliesResult call() throws Exception {
              ListTaskDefinitionFamiliesResult result;
                try {
                result = listTaskDefinitionFamilies(listTaskDefinitionFamiliesRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(listTaskDefinitionFamiliesRequestresult);
                 return result;
        }
    });
    }
    
    

Describes a specified task or tasks.

Parameters:
describeTasksRequest Container for the necessary parameters to execute the DescribeTasks operation on AmazonECS.
Returns:
A Java Future object containing the response from the DescribeTasks service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
    public Future<DescribeTasksResultdescribeTasksAsync(final DescribeTasksRequest describeTasksRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<DescribeTasksResult>() {
            public DescribeTasksResult call() throws Exception {
                return describeTasks(describeTasksRequest);
        }
    });
    }

    

Describes a specified task or tasks.

Parameters:
describeTasksRequest Container for the necessary parameters to execute the DescribeTasks operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DescribeTasks service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final DescribeTasksRequest describeTasksRequest,
            final AsyncHandler<DescribeTasksRequestDescribeTasksResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<DescribeTasksResult>() {
            public DescribeTasksResult call() throws Exception {
              DescribeTasksResult result;
                try {
                result = describeTasks(describeTasksRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(describeTasksRequestresult);
                 return result;
        }
    });
    }
    
    

NOTE: This action is only used by the Amazon EC2 Container Service agent, and it is not intended for use outside of the agent.

Returns an endpoint for the Amazon EC2 Container Service agent to poll for updates.

Parameters:
discoverPollEndpointRequest Container for the necessary parameters to execute the DiscoverPollEndpoint operation on AmazonECS.
Returns:
A Java Future object containing the response from the DiscoverPollEndpoint service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
    public Future<DiscoverPollEndpointResultdiscoverPollEndpointAsync(final DiscoverPollEndpointRequest discoverPollEndpointRequest
            throws AmazonServiceExceptionAmazonClientException {
            public DiscoverPollEndpointResult call() throws Exception {
                return discoverPollEndpoint(discoverPollEndpointRequest);
        }
    });
    }

    

NOTE: This action is only used by the Amazon EC2 Container Service agent, and it is not intended for use outside of the agent.

Returns an endpoint for the Amazon EC2 Container Service agent to poll for updates.

Parameters:
discoverPollEndpointRequest Container for the necessary parameters to execute the DiscoverPollEndpoint operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DiscoverPollEndpoint service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final DiscoverPollEndpointRequest discoverPollEndpointRequest,
            final AsyncHandler<DiscoverPollEndpointRequestDiscoverPollEndpointResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
            public DiscoverPollEndpointResult call() throws Exception {
              DiscoverPollEndpointResult result;
                try {
                result = discoverPollEndpoint(discoverPollEndpointRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(discoverPollEndpointRequestresult);
                 return result;
        }
    });
    }
    
    

Starts a new task from the specified task definition on the specified container instance or instances. If you want to use the default Amazon ECS scheduler to place your task, use RunTask instead.

IMPORTANT: The list of container instances to start tasks on is limited to 10.

Parameters:
startTaskRequest Container for the necessary parameters to execute the StartTask operation on AmazonECS.
Returns:
A Java Future object containing the response from the StartTask service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
    public Future<StartTaskResultstartTaskAsync(final StartTaskRequest startTaskRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<StartTaskResult>() {
            public StartTaskResult call() throws Exception {
                return startTask(startTaskRequest);
        }
    });
    }

    

Starts a new task from the specified task definition on the specified container instance or instances. If you want to use the default Amazon ECS scheduler to place your task, use RunTask instead.

IMPORTANT: The list of container instances to start tasks on is limited to 10.

Parameters:
startTaskRequest Container for the necessary parameters to execute the StartTask operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the StartTask service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final StartTaskRequest startTaskRequest,
            final AsyncHandler<StartTaskRequestStartTaskResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<StartTaskResult>() {
            public StartTaskResult call() throws Exception {
              StartTaskResult result;
                try {
                result = startTask(startTaskRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(startTaskRequestresult);
                 return result;
        }
    });
    }
    
    

Returns a list of tasks for a specified cluster. You can filter the results by family name or by a particular container instance with the family and containerInstance parameters.

Parameters:
listTasksRequest Container for the necessary parameters to execute the ListTasks operation on AmazonECS.
Returns:
A Java Future object containing the response from the ListTasks service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
    public Future<ListTasksResultlistTasksAsync(final ListTasksRequest listTasksRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<ListTasksResult>() {
            public ListTasksResult call() throws Exception {
                return listTasks(listTasksRequest);
        }
    });
    }

    

Returns a list of tasks for a specified cluster. You can filter the results by family name or by a particular container instance with the family and containerInstance parameters.

Parameters:
listTasksRequest Container for the necessary parameters to execute the ListTasks operation on AmazonECS.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the ListTasks service method, as returned by AmazonECS.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonECS indicating either a problem with the data in the request, or a server side issue.
            final ListTasksRequest listTasksRequest,
            final AsyncHandler<ListTasksRequestListTasksResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<ListTasksResult>() {
            public ListTasksResult call() throws Exception {
              ListTasksResult result;
                try {
                result = listTasks(listTasksRequest);