/*
* Copyright 2012-2017 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;
import org.w3c.dom.*;
import java.net.*;
import java.util.*;
import javax.annotation.Generated;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.annotation.SdkInternalApi;
import com.amazonaws.auth.*;
import com.amazonaws.handlers.*;
import com.amazonaws.http.*;
import com.amazonaws.internal.*;
import com.amazonaws.internal.auth.*;
import com.amazonaws.metrics.*;
import com.amazonaws.regions.*;
import com.amazonaws.transform.*;
import com.amazonaws.util.*;
import com.amazonaws.protocol.json.*;
import com.amazonaws.util.AWSRequestMetrics.Field;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.client.AwsSyncClientParams;
import com.amazonaws.services.ecs.AmazonECSClientBuilder;
import com.amazonaws.services.ecs.waiters.AmazonECSWaiters;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.ecs.model.*;
import com.amazonaws.services.ecs.model.transform.*;
/**
* Client for accessing Amazon ECS. All service calls made using this client are blocking, and will not return until the
* service call completes.
* <p>
* <p>
* 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 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.
* </p>
* <p>
* 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.
* </p>
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonECSClient extends AmazonWebServiceClient implements AmazonECS {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AmazonECS.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "ecs";
private volatile AmazonECSWaiters waiters;
/** Client configuration factory providing ClientConfigurations tailored to this client */
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
private final com.amazonaws.protocol.json.SdkJsonProtocolFactory protocolFactory = new com.amazonaws.protocol.json.SdkJsonProtocolFactory(
new JsonClientMetadata()
.withProtocolVersion("1.1")
.withSupportsCbor(false)
.withSupportsIon(false)
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidParameterException").withModeledClass(
com.amazonaws.services.ecs.model.InvalidParameterException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("NoUpdateAvailableException").withModeledClass(
com.amazonaws.services.ecs.model.NoUpdateAvailableException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ClusterContainsServicesException").withModeledClass(
com.amazonaws.services.ecs.model.ClusterContainsServicesException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("MissingVersionException").withModeledClass(
com.amazonaws.services.ecs.model.MissingVersionException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ClusterContainsContainerInstancesException").withModeledClass(
com.amazonaws.services.ecs.model.ClusterContainsContainerInstancesException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ServiceNotFoundException").withModeledClass(
com.amazonaws.services.ecs.model.ServiceNotFoundException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("AttributeLimitExceededException").withModeledClass(
com.amazonaws.services.ecs.model.AttributeLimitExceededException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ServiceNotActiveException").withModeledClass(
com.amazonaws.services.ecs.model.ServiceNotActiveException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ClusterNotFoundException").withModeledClass(
com.amazonaws.services.ecs.model.ClusterNotFoundException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ServerException").withModeledClass(
com.amazonaws.services.ecs.model.ServerException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("TargetNotFoundException").withModeledClass(
com.amazonaws.services.ecs.model.TargetNotFoundException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ClientException").withModeledClass(
com.amazonaws.services.ecs.model.ClientException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("UpdateInProgressException").withModeledClass(
com.amazonaws.services.ecs.model.UpdateInProgressException.class))
.withBaseServiceExceptionClass(com.amazonaws.services.ecs.model.AmazonECSException.class));
/**
* Constructs a new client to invoke service methods on Amazon ECS. A credentials provider chain will be used that
* searches for credentials in this order:
* <ul>
* <li>Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY</li>
* <li>Java System Properties - aws.accessKeyId and aws.secretKey</li>
* <li>Instance profile credentials delivered through the Amazon EC2 metadata service</li>
* </ul>
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @see DefaultAWSCredentialsProviderChain
* @deprecated use {@link AmazonECSClientBuilder#defaultClient()}
*/
@Deprecated
public AmazonECSClient() {
this(DefaultAWSCredentialsProviderChain.getInstance(), configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon ECS. A credentials provider chain will be used that
* searches for credentials in this order:
* <ul>
* <li>Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY</li>
* <li>Java System Properties - aws.accessKeyId and aws.secretKey</li>
* <li>Instance profile credentials delivered through the Amazon EC2 metadata service</li>
* </ul>
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon ECS (ex: proxy settings,
* retry counts, etc.).
*
* @see DefaultAWSCredentialsProviderChain
* @deprecated use {@link AmazonECSClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonECSClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on Amazon ECS using the specified AWS account credentials.
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @deprecated use {@link AmazonECSClientBuilder#withCredentials(AWSCredentialsProvider)} for example:
* {@code AmazonECSClientBuilder.standard().withCredentials(new AWSStaticCredentialsProvider(awsCredentials)).build();}
*/
@Deprecated
public AmazonECSClient(AWSCredentials awsCredentials) {
this(awsCredentials, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon ECS using the specified AWS account credentials and
* client configuration options.
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon ECS (ex: proxy settings,
* retry counts, etc.).
* @deprecated use {@link AmazonECSClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonECSClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonECSClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentialsProvider = new StaticCredentialsProvider(awsCredentials);
init();
}
/**
* Constructs a new client to invoke service methods on Amazon ECS using the specified AWS account credentials
* provider.
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @deprecated use {@link AmazonECSClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AmazonECSClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon ECS using the specified AWS account credentials
* provider and client configuration options.
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon ECS (ex: proxy settings,
* retry counts, etc.).
* @deprecated use {@link AmazonECSClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonECSClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonECSClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, null);
}
/**
* Constructs a new client to invoke service methods on Amazon ECS using the specified AWS account credentials
* provider, client configuration options, and request metric collector.
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to Amazon ECS (ex: proxy settings,
* retry counts, etc.).
* @param requestMetricCollector
* optional request metric collector
* @deprecated use {@link AmazonECSClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonECSClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AmazonECSClientBuilder#withMetricsCollector(RequestMetricCollector)}
*/
@Deprecated
public AmazonECSClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration, RequestMetricCollector requestMetricCollector) {
super(clientConfiguration, requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
init();
}
public static AmazonECSClientBuilder builder() {
return AmazonECSClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on Amazon ECS using the specified parameters.
*
* <p>
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonECSClient(AwsSyncClientParams clientParams) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
init();
}
private void init() {
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
setEndpoint("https://ecs.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/ecs/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/ecs/request.handler2s"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
* <p>
* Creates a new Amazon ECS cluster. By default, your account receives a <code>default</code> cluster when you
* launch your first container instance. However, you can create your own cluster with a unique name with the
* <code>CreateCluster</code> action.
* </p>
*
* @param createClusterRequest
* @return Result of the CreateCluster operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonECS.CreateCluster
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/CreateCluster" target="_top">AWS API
* Documentation</a>
*/
@Override
public CreateClusterResult createCluster(CreateClusterRequest request) {
request = beforeClientExecution(request);
return executeCreateCluster(request);
}
@SdkInternalApi
final CreateClusterResult executeCreateCluster(CreateClusterRequest createClusterRequest) {
ExecutionContext executionContext = createExecutionContext(createClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<CreateClusterRequest> request = null;
Response<CreateClusterResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateClusterRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<CreateClusterResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateClusterResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public CreateClusterResult createCluster() {
return createCluster(new CreateClusterRequest());
}
/**
* <p>
* Runs and maintains a desired number of tasks from a specified task definition. If the number of tasks running in
* a service drops below <code>desiredCount</code>, Amazon ECS spawns another copy of the task in the specified
* cluster. To update an existing service, see <a>UpdateService</a>.
* </p>
* <p>
* In addition to maintaining the desired count of tasks in your service, you can optionally run your service behind
* a load balancer. The load balancer distributes traffic across the tasks that are associated with the service. For
* more information, see <a
* href="http://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html">Service Load
* Balancing</a> in the <i>Amazon EC2 Container Service Developer Guide</i>.
* </p>
* <p>
* You can optionally specify a deployment configuration for your service. During a deployment (which is triggered
* by changing the task definition or the desired count of a service with an <a>UpdateService</a> operation), the
* service scheduler uses the <code>minimumHealthyPercent</code> and <code>maximumPercent</code> parameters to
* determine the deployment strategy.
* </p>
* <p>
* The <code>minimumHealthyPercent</code> represents a lower limit on the number of your service's tasks that must
* remain in the <code>RUNNING</code> state during a deployment, as a percentage of the <code>desiredCount</code>
* (rounded up to the nearest integer). This parameter enables you to deploy without using additional cluster
* capacity. For example, if your service has a <code>desiredCount</code> of four tasks and a
* <code>minimumHealthyPercent</code> of 50%, the scheduler can stop two existing tasks to free up cluster capacity
* before starting two new tasks. Tasks for services that <i>do not</i> use a load balancer are considered healthy
* if they are in the <code>RUNNING</code> state. Tasks for services that <i>do</i> use a load balancer are
* considered healthy if they are in the <code>RUNNING</code> state and the container instance they are hosted on is
* reported as healthy by the load balancer. The default value for <code>minimumHealthyPercent</code> is 50% in the
* console and 100% for the AWS CLI, the AWS SDKs, and the APIs.
* </p>
* <p>
* The <code>maximumPercent</code> parameter represents an upper limit on the number of your service's tasks that
* are allowed in the <code>RUNNING</code> or <code>PENDING</code> state during a deployment, as a percentage of the
* <code>desiredCount</code> (rounded down to the nearest integer). This parameter enables you to define the
* deployment batch size. For example, if your service has a <code>desiredCount</code> of four tasks and a
* <code>maximumPercent</code> value of 200%, the scheduler can start four new tasks before stopping the four older
* tasks (provided that the cluster resources required to do this are available). The default value for
* <code>maximumPercent</code> is 200%.
* </p>
* <p>
* When the service scheduler launches new tasks, it determines task placement in your cluster using the following
* logic:
* </p>
* <ul>
* <li>
* <p>
* Determine which of the container instances in your cluster can support your service's task definition (for
* example, they have the required CPU, memory, ports, and container instance attributes).
* </p>
* </li>
* <li>
* <p>
* By default, the service scheduler attempts to balance tasks across Availability Zones in this manner (although
* you can choose a different placement strategy) with the <code>placementStrategy</code> parameter):
* </p>
* <ul>
* <li>
* <p>
* Sort the valid container instances by the fewest number of running tasks for this service in the same
* Availability Zone as the instance. For example, if zone A has one running service task and zones B and C each
* have zero, valid container instances in either zone B or C are considered optimal for placement.
* </p>
* </li>
* <li>
* <p>
* Place the new service task on a valid container instance in an optimal Availability Zone (based on the previous
* steps), favoring container instances with the fewest number of running tasks for this service.
* </p>
* </li>
* </ul>
* </li>
* </ul>
*
* @param createServiceRequest
* @return Result of the CreateService operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @sample AmazonECS.CreateService
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/CreateService" target="_top">AWS API
* Documentation</a>
*/
@Override
public CreateServiceResult createService(CreateServiceRequest request) {
request = beforeClientExecution(request);
return executeCreateService(request);
}
@SdkInternalApi
final CreateServiceResult executeCreateService(CreateServiceRequest createServiceRequest) {
ExecutionContext executionContext = createExecutionContext(createServiceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<CreateServiceRequest> request = null;
Response<CreateServiceResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateServiceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createServiceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<CreateServiceResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateServiceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Deletes one or more custom attributes from an Amazon ECS resource.
* </p>
*
* @param deleteAttributesRequest
* @return Result of the DeleteAttributes operation returned by the service.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @throws TargetNotFoundException
* The specified target could not be found. You can view your available container instances with
* <a>ListContainerInstances</a>. Amazon ECS container instances are cluster-specific and region-specific.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonECS.DeleteAttributes
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteAttributes" target="_top">AWS API
* Documentation</a>
*/
@Override
public DeleteAttributesResult deleteAttributes(DeleteAttributesRequest request) {
request = beforeClientExecution(request);
return executeDeleteAttributes(request);
}
@SdkInternalApi
final DeleteAttributesResult executeDeleteAttributes(DeleteAttributesRequest deleteAttributesRequest) {
ExecutionContext executionContext = createExecutionContext(deleteAttributesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DeleteAttributesRequest> request = null;
Response<DeleteAttributesResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteAttributesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteAttributesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DeleteAttributesResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteAttributesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* 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 <a>ListContainerInstances</a> and deregister
* them with <a>DeregisterContainerInstance</a>.
* </p>
*
* @param deleteClusterRequest
* @return Result of the DeleteCluster operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @throws ClusterContainsContainerInstancesException
* You cannot delete a cluster that has registered container instances. You must first deregister the
* container instances before you can delete the cluster. For more information, see
* <a>DeregisterContainerInstance</a>.
* @throws ClusterContainsServicesException
* You cannot delete a cluster that contains services. You must first update the service to reduce its
* desired task count to 0 and then delete the service. For more information, see <a>UpdateService</a> and
* <a>DeleteService</a>.
* @sample AmazonECS.DeleteCluster
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteCluster" target="_top">AWS API
* Documentation</a>
*/
@Override
public DeleteClusterResult deleteCluster(DeleteClusterRequest request) {
request = beforeClientExecution(request);
return executeDeleteCluster(request);
}
@SdkInternalApi
final DeleteClusterResult executeDeleteCluster(DeleteClusterRequest deleteClusterRequest) {
ExecutionContext executionContext = createExecutionContext(deleteClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DeleteClusterRequest> request = null;
Response<DeleteClusterResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteClusterRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DeleteClusterResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteClusterResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Deletes a specified service within a cluster. You can delete a service if you have no running tasks in it and the
* desired task count is zero. If the service is actively maintaining tasks, you cannot delete it, and you must
* update the service to a desired task count of zero. For more information, see <a>UpdateService</a>.
* </p>
* <note>
* <p>
* When you delete a service, if there are still running tasks that require cleanup, the service status moves from
* <code>ACTIVE</code> to <code>DRAINING</code>, and the service is no longer visible in the console or in
* <a>ListServices</a> API operations. After the tasks have stopped, then the service status moves from
* <code>DRAINING</code> to <code>INACTIVE</code>. Services in the <code>DRAINING</code> or <code>INACTIVE</code>
* status can still be viewed with <a>DescribeServices</a> API operations; however, in the future,
* <code>INACTIVE</code> services may be cleaned up and purged from Amazon ECS record keeping, and
* <a>DescribeServices</a> API operations on those services will return a <code>ServiceNotFoundException</code>
* error.
* </p>
* </note>
*
* @param deleteServiceRequest
* @return Result of the DeleteService operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @throws ServiceNotFoundException
* The specified service could not be found. You can view your available services with <a>ListServices</a>.
* Amazon ECS services are cluster-specific and region-specific.
* @sample AmazonECS.DeleteService
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeleteService" target="_top">AWS API
* Documentation</a>
*/
@Override
public DeleteServiceResult deleteService(DeleteServiceRequest request) {
request = beforeClientExecution(request);
return executeDeleteService(request);
}
@SdkInternalApi
final DeleteServiceResult executeDeleteService(DeleteServiceRequest deleteServiceRequest) {
ExecutionContext executionContext = createExecutionContext(deleteServiceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DeleteServiceRequest> request = null;
Response<DeleteServiceResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteServiceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteServiceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DeleteServiceResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteServiceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Deregisters an Amazon ECS container instance from the specified cluster. This instance is no longer available to
* run tasks.
* </p>
* <p>
* If you intend to use the container instance for some other purpose after deregistration, you should stop all of
* the tasks running on the container instance before deregistration to avoid any orphaned tasks from consuming
* resources.
* </p>
* <p>
* Deregistering a container instance removes the instance from a cluster, but it does not terminate the EC2
* instance; if you are finished using the instance, be sure to terminate it in the Amazon EC2 console to stop
* billing.
* </p>
* <note>
* <p>
* If you terminate a running container instance, Amazon ECS automatically deregisters the instance from your
* cluster (stopped container instances or instances with disconnected agents are not automatically deregistered
* when terminated).
* </p>
* </note>
*
* @param deregisterContainerInstanceRequest
* @return Result of the DeregisterContainerInstance operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @sample AmazonECS.DeregisterContainerInstance
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeregisterContainerInstance"
* target="_top">AWS API Documentation</a>
*/
@Override
public DeregisterContainerInstanceResult deregisterContainerInstance(DeregisterContainerInstanceRequest request) {
request = beforeClientExecution(request);
return executeDeregisterContainerInstance(request);
}
@SdkInternalApi
final DeregisterContainerInstanceResult executeDeregisterContainerInstance(DeregisterContainerInstanceRequest deregisterContainerInstanceRequest) {
ExecutionContext executionContext = createExecutionContext(deregisterContainerInstanceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DeregisterContainerInstanceRequest> request = null;
Response<DeregisterContainerInstanceResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeregisterContainerInstanceRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deregisterContainerInstanceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DeregisterContainerInstanceResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeregisterContainerInstanceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Deregisters the specified task definition by family and revision. Upon deregistration, the task definition is
* marked as <code>INACTIVE</code>. Existing tasks and services that reference an <code>INACTIVE</code> task
* definition continue to run without disruption. Existing services that reference an <code>INACTIVE</code> task
* definition can still scale up or down by modifying the service's desired count.
* </p>
* <p>
* You cannot use an <code>INACTIVE</code> task definition to run new tasks or create new services, and you cannot
* update an existing service to reference an <code>INACTIVE</code> task definition (although there may be up to a
* 10 minute window following deregistration where these restrictions have not yet taken effect).
* </p>
* <note>
* <p>
* At this time, <code>INACTIVE</code> task definitions remain discoverable in your account indefinitely; however,
* this behavior is subject to change in the future, so you should not rely on <code>INACTIVE</code> task
* definitions persisting beyond the life cycle of any associated tasks and services.
* </p>
* </note>
*
* @param deregisterTaskDefinitionRequest
* @return Result of the DeregisterTaskDefinition operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonECS.DeregisterTaskDefinition
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DeregisterTaskDefinition" target="_top">AWS
* API Documentation</a>
*/
@Override
public DeregisterTaskDefinitionResult deregisterTaskDefinition(DeregisterTaskDefinitionRequest request) {
request = beforeClientExecution(request);
return executeDeregisterTaskDefinition(request);
}
@SdkInternalApi
final DeregisterTaskDefinitionResult executeDeregisterTaskDefinition(DeregisterTaskDefinitionRequest deregisterTaskDefinitionRequest) {
ExecutionContext executionContext = createExecutionContext(deregisterTaskDefinitionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DeregisterTaskDefinitionRequest> request = null;
Response<DeregisterTaskDefinitionResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeregisterTaskDefinitionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deregisterTaskDefinitionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DeregisterTaskDefinitionResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeregisterTaskDefinitionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Describes one or more of your clusters.
* </p>
*
* @param describeClustersRequest
* @return Result of the DescribeClusters operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonECS.DescribeClusters
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeClusters" target="_top">AWS API
* Documentation</a>
*/
@Override
public DescribeClustersResult describeClusters(DescribeClustersRequest request) {
request = beforeClientExecution(request);
return executeDescribeClusters(request);
}
@SdkInternalApi
final DescribeClustersResult executeDescribeClusters(DescribeClustersRequest describeClustersRequest) {
ExecutionContext executionContext = createExecutionContext(describeClustersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DescribeClustersRequest> request = null;
Response<DescribeClustersResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeClustersRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeClustersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DescribeClustersResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeClustersResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeClustersResult describeClusters() {
return describeClusters(new DescribeClustersRequest());
}
/**
* <p>
* Describes Amazon EC2 Container Service container instances. Returns metadata about registered and remaining
* resources on each container instance requested.
* </p>
*
* @param describeContainerInstancesRequest
* @return Result of the DescribeContainerInstances operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @sample AmazonECS.DescribeContainerInstances
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeContainerInstances" target="_top">AWS
* API Documentation</a>
*/
@Override
public DescribeContainerInstancesResult describeContainerInstances(DescribeContainerInstancesRequest request) {
request = beforeClientExecution(request);
return executeDescribeContainerInstances(request);
}
@SdkInternalApi
final DescribeContainerInstancesResult executeDescribeContainerInstances(DescribeContainerInstancesRequest describeContainerInstancesRequest) {
ExecutionContext executionContext = createExecutionContext(describeContainerInstancesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DescribeContainerInstancesRequest> request = null;
Response<DescribeContainerInstancesResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeContainerInstancesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeContainerInstancesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DescribeContainerInstancesResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeContainerInstancesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Describes the specified services running in your cluster.
* </p>
*
* @param describeServicesRequest
* @return Result of the DescribeServices operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @sample AmazonECS.DescribeServices
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeServices" target="_top">AWS API
* Documentation</a>
*/
@Override
public DescribeServicesResult describeServices(DescribeServicesRequest request) {
request = beforeClientExecution(request);
return executeDescribeServices(request);
}
@SdkInternalApi
final DescribeServicesResult executeDescribeServices(DescribeServicesRequest describeServicesRequest) {
ExecutionContext executionContext = createExecutionContext(describeServicesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DescribeServicesRequest> request = null;
Response<DescribeServicesResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeServicesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeServicesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DescribeServicesResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeServicesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Describes a task definition. You can specify a <code>family</code> and <code>revision</code> to find information
* about a specific task definition, or you can simply specify the family to find the latest <code>ACTIVE</code>
* revision in that family.
* </p>
* <note>
* <p>
* You can only describe <code>INACTIVE</code> task definitions while an active task or service references them.
* </p>
* </note>
*
* @param describeTaskDefinitionRequest
* @return Result of the DescribeTaskDefinition operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonECS.DescribeTaskDefinition
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeTaskDefinition" target="_top">AWS API
* Documentation</a>
*/
@Override
public DescribeTaskDefinitionResult describeTaskDefinition(DescribeTaskDefinitionRequest request) {
request = beforeClientExecution(request);
return executeDescribeTaskDefinition(request);
}
@SdkInternalApi
final DescribeTaskDefinitionResult executeDescribeTaskDefinition(DescribeTaskDefinitionRequest describeTaskDefinitionRequest) {
ExecutionContext executionContext = createExecutionContext(describeTaskDefinitionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DescribeTaskDefinitionRequest> request = null;
Response<DescribeTaskDefinitionResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeTaskDefinitionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeTaskDefinitionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DescribeTaskDefinitionResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeTaskDefinitionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Describes a specified task or tasks.
* </p>
*
* @param describeTasksRequest
* @return Result of the DescribeTasks operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @sample AmazonECS.DescribeTasks
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DescribeTasks" target="_top">AWS API
* Documentation</a>
*/
@Override
public DescribeTasksResult describeTasks(DescribeTasksRequest request) {
request = beforeClientExecution(request);
return executeDescribeTasks(request);
}
@SdkInternalApi
final DescribeTasksResult executeDescribeTasks(DescribeTasksRequest describeTasksRequest) {
ExecutionContext executionContext = createExecutionContext(describeTasksRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DescribeTasksRequest> request = null;
Response<DescribeTasksResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeTasksRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeTasksRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DescribeTasksResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeTasksResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <note>
* <p>
* This action is only used by the Amazon EC2 Container Service agent, and it is not intended for use outside of the
* agent.
* </p>
* </note>
* <p>
* Returns an endpoint for the Amazon EC2 Container Service agent to poll for updates.
* </p>
*
* @param discoverPollEndpointRequest
* @return Result of the DiscoverPollEndpoint operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @sample AmazonECS.DiscoverPollEndpoint
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/DiscoverPollEndpoint" target="_top">AWS API
* Documentation</a>
*/
@Override
public DiscoverPollEndpointResult discoverPollEndpoint(DiscoverPollEndpointRequest request) {
request = beforeClientExecution(request);
return executeDiscoverPollEndpoint(request);
}
@SdkInternalApi
final DiscoverPollEndpointResult executeDiscoverPollEndpoint(DiscoverPollEndpointRequest discoverPollEndpointRequest) {
ExecutionContext executionContext = createExecutionContext(discoverPollEndpointRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<DiscoverPollEndpointRequest> request = null;
Response<DiscoverPollEndpointResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DiscoverPollEndpointRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(discoverPollEndpointRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<DiscoverPollEndpointResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DiscoverPollEndpointResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DiscoverPollEndpointResult discoverPollEndpoint() {
return discoverPollEndpoint(new DiscoverPollEndpointRequest());
}
/**
* <p>
* Lists the attributes for Amazon ECS resources within a specified target type and cluster. When you specify a
* target type and cluster, <code>ListAttributes</code> returns a list of attribute objects, one for each attribute
* on each resource. You can filter the list of results to a single attribute name to only return results that have
* that name. You can also filter the results by attribute name and value, for example, to see which container
* instances in a cluster are running a Linux AMI (<code>ecs.os-type=linux</code>).
* </p>
*
* @param listAttributesRequest
* @return Result of the ListAttributes operation returned by the service.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonECS.ListAttributes
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListAttributes" target="_top">AWS API
* Documentation</a>
*/
@Override
public ListAttributesResult listAttributes(ListAttributesRequest request) {
request = beforeClientExecution(request);
return executeListAttributes(request);
}
@SdkInternalApi
final ListAttributesResult executeListAttributes(ListAttributesRequest listAttributesRequest) {
ExecutionContext executionContext = createExecutionContext(listAttributesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<ListAttributesRequest> request = null;
Response<ListAttributesResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListAttributesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listAttributesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<ListAttributesResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListAttributesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Returns a list of existing clusters.
* </p>
*
* @param listClustersRequest
* @return Result of the ListClusters operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonECS.ListClusters
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListClusters" target="_top">AWS API
* Documentation</a>
*/
@Override
public ListClustersResult listClusters(ListClustersRequest request) {
request = beforeClientExecution(request);
return executeListClusters(request);
}
@SdkInternalApi
final ListClustersResult executeListClusters(ListClustersRequest listClustersRequest) {
ExecutionContext executionContext = createExecutionContext(listClustersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<ListClustersRequest> request = null;
Response<ListClustersResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListClustersRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listClustersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<ListClustersResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListClustersResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ListClustersResult listClusters() {
return listClusters(new ListClustersRequest());
}
/**
* <p>
* Returns a list of container instances in a specified cluster. You can filter the results of a
* <code>ListContainerInstances</code> operation with cluster query language statements inside the
* <code>filter</code> parameter. For more information, see <a
* href="http://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html">Cluster Query
* Language</a> in the <i>Amazon EC2 Container Service Developer Guide</i>.
* </p>
*
* @param listContainerInstancesRequest
* @return Result of the ListContainerInstances operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @sample AmazonECS.ListContainerInstances
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListContainerInstances" target="_top">AWS API
* Documentation</a>
*/
@Override
public ListContainerInstancesResult listContainerInstances(ListContainerInstancesRequest request) {
request = beforeClientExecution(request);
return executeListContainerInstances(request);
}
@SdkInternalApi
final ListContainerInstancesResult executeListContainerInstances(ListContainerInstancesRequest listContainerInstancesRequest) {
ExecutionContext executionContext = createExecutionContext(listContainerInstancesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<ListContainerInstancesRequest> request = null;
Response<ListContainerInstancesResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListContainerInstancesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listContainerInstancesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<ListContainerInstancesResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListContainerInstancesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ListContainerInstancesResult listContainerInstances() {
return listContainerInstances(new ListContainerInstancesRequest());
}
/**
* <p>
* Lists the services that are running in a specified cluster.
* </p>
*
* @param listServicesRequest
* @return Result of the ListServices operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @sample AmazonECS.ListServices
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListServices" target="_top">AWS API
* Documentation</a>
*/
@Override
public ListServicesResult listServices(ListServicesRequest request) {
request = beforeClientExecution(request);
return executeListServices(request);
}
@SdkInternalApi
final ListServicesResult executeListServices(ListServicesRequest listServicesRequest) {
ExecutionContext executionContext = createExecutionContext(listServicesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<ListServicesRequest> request = null;
Response<ListServicesResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListServicesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listServicesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<ListServicesResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListServicesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ListServicesResult listServices() {
return listServices(new ListServicesRequest());
}
/**
* <p>
* Returns a list of task definition families that are registered to your account (which may include task definition
* families that no longer have any <code>ACTIVE</code> task definition revisions).
* </p>
* <p>
* You can filter out task definition families that do not contain any <code>ACTIVE</code> task definition revisions
* by setting the <code>status</code> parameter to <code>ACTIVE</code>. You can also filter the results with the
* <code>familyPrefix</code> parameter.
* </p>
*
* @param listTaskDefinitionFamiliesRequest
* @return Result of the ListTaskDefinitionFamilies operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonECS.ListTaskDefinitionFamilies
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListTaskDefinitionFamilies" target="_top">AWS
* API Documentation</a>
*/
@Override
public ListTaskDefinitionFamiliesResult listTaskDefinitionFamilies(ListTaskDefinitionFamiliesRequest request) {
request = beforeClientExecution(request);
return executeListTaskDefinitionFamilies(request);
}
@SdkInternalApi
final ListTaskDefinitionFamiliesResult executeListTaskDefinitionFamilies(ListTaskDefinitionFamiliesRequest listTaskDefinitionFamiliesRequest) {
ExecutionContext executionContext = createExecutionContext(listTaskDefinitionFamiliesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<ListTaskDefinitionFamiliesRequest> request = null;
Response<ListTaskDefinitionFamiliesResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTaskDefinitionFamiliesRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listTaskDefinitionFamiliesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<ListTaskDefinitionFamiliesResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListTaskDefinitionFamiliesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ListTaskDefinitionFamiliesResult listTaskDefinitionFamilies() {
return listTaskDefinitionFamilies(new ListTaskDefinitionFamiliesRequest());
}
/**
* <p>
* Returns a list of task definitions that are registered to your account. You can filter the results by family name
* with the <code>familyPrefix</code> parameter or by status with the <code>status</code> parameter.
* </p>
*
* @param listTaskDefinitionsRequest
* @return Result of the ListTaskDefinitions operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonECS.ListTaskDefinitions
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListTaskDefinitions" target="_top">AWS API
* Documentation</a>
*/
@Override
public ListTaskDefinitionsResult listTaskDefinitions(ListTaskDefinitionsRequest request) {
request = beforeClientExecution(request);
return executeListTaskDefinitions(request);
}
@SdkInternalApi
final ListTaskDefinitionsResult executeListTaskDefinitions(ListTaskDefinitionsRequest listTaskDefinitionsRequest) {
ExecutionContext executionContext = createExecutionContext(listTaskDefinitionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<ListTaskDefinitionsRequest> request = null;
Response<ListTaskDefinitionsResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTaskDefinitionsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listTaskDefinitionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<ListTaskDefinitionsResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListTaskDefinitionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ListTaskDefinitionsResult listTaskDefinitions() {
return listTaskDefinitions(new ListTaskDefinitionsRequest());
}
/**
* <p>
* Returns a list of tasks for a specified cluster. You can filter the results by family name, by a particular
* container instance, or by the desired status of the task with the <code>family</code>,
* <code>containerInstance</code>, and <code>desiredStatus</code> parameters.
* </p>
* <p>
* Recently-stopped tasks might appear in the returned results. Currently, stopped tasks appear in the returned
* results for at least one hour.
* </p>
*
* @param listTasksRequest
* @return Result of the ListTasks operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @throws ServiceNotFoundException
* The specified service could not be found. You can view your available services with <a>ListServices</a>.
* Amazon ECS services are cluster-specific and region-specific.
* @sample AmazonECS.ListTasks
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/ListTasks" target="_top">AWS API
* Documentation</a>
*/
@Override
public ListTasksResult listTasks(ListTasksRequest request) {
request = beforeClientExecution(request);
return executeListTasks(request);
}
@SdkInternalApi
final ListTasksResult executeListTasks(ListTasksRequest listTasksRequest) {
ExecutionContext executionContext = createExecutionContext(listTasksRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<ListTasksRequest> request = null;
Response<ListTasksResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTasksRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listTasksRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<ListTasksResult>> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListTasksResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ListTasksResult listTasks() {
return listTasks(new ListTasksRequest());
}
/**
* <p>
* Create or update an attribute on an Amazon ECS resource. If the attribute does not exist, it is created. If the
* attribute exists, its value is replaced with the specified value. To delete an attribute, use
* <a>DeleteAttributes</a>. For more information, see <a
* href="http://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html#attributes"
* >Attributes</a> in the <i>Amazon EC2 Container Service Developer Guide</i>.
* </p>
*
* @param putAttributesRequest
* @return Result of the PutAttributes operation returned by the service.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @throws TargetNotFoundException
* The specified target could not be found. You can view your available container instances with
* <a>ListContainerInstances</a>. Amazon ECS container instances are cluster-specific and region-specific.
* @throws AttributeLimitExceededException
* You can apply up to 10 custom attributes per resource. You can view the attributes of a resource with
* <a>ListAttributes</a>. You can remove existing attributes on a resource with <a>DeleteAttributes</a>.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonECS.PutAttributes
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/PutAttributes" target="_top">AWS API
* Documentation</a>
*/
@Override
public PutAttributesResult putAttributes(PutAttributesRequest request) {
request = beforeClientExecution(request);
return executePutAttributes(request);
}
@SdkInternalApi
final PutAttributesResult executePutAttributes(PutAttributesRequest putAttributesRequest) {
ExecutionContext executionContext = createExecutionContext(putAttributesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<PutAttributesRequest> request = null;
Response<PutAttributesResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new PutAttributesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(putAttributesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<PutAttributesResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new PutAttributesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <note>
* <p>
* This action is only used by the Amazon EC2 Container Service agent, and it is not intended for use outside of the
* agent.
* </p>
* </note>
* <p>
* Registers an EC2 instance into the specified cluster. This instance becomes available to place containers on.
* </p>
*
* @param registerContainerInstanceRequest
* @return Result of the RegisterContainerInstance operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @sample AmazonECS.RegisterContainerInstance
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/RegisterContainerInstance" target="_top">AWS
* API Documentation</a>
*/
@Override
public RegisterContainerInstanceResult registerContainerInstance(RegisterContainerInstanceRequest request) {
request = beforeClientExecution(request);
return executeRegisterContainerInstance(request);
}
@SdkInternalApi
final RegisterContainerInstanceResult executeRegisterContainerInstance(RegisterContainerInstanceRequest registerContainerInstanceRequest) {
ExecutionContext executionContext = createExecutionContext(registerContainerInstanceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<RegisterContainerInstanceRequest> request = null;
Response<RegisterContainerInstanceResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RegisterContainerInstanceRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(registerContainerInstanceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<RegisterContainerInstanceResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new RegisterContainerInstanceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Registers a new task definition from the supplied <code>family</code> and <code>containerDefinitions</code>.
* Optionally, you can add data volumes to your containers with the <code>volumes</code> parameter. For more
* information about task definition parameters and defaults, see <a
* href="http://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html">Amazon ECS Task
* Definitions</a> in the <i>Amazon EC2 Container Service Developer Guide</i>.
* </p>
* <p>
* You can specify an IAM role for your task with the <code>taskRoleArn</code> parameter. When you specify an IAM
* role for a task, its containers can then use the latest versions of the AWS CLI or SDKs to make API requests to
* the AWS services that are specified in the IAM policy associated with the role. For more information, see <a
* href="http://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM Roles for Tasks</a> in
* the <i>Amazon EC2 Container Service Developer Guide</i>.
* </p>
* <p>
* You can specify a Docker networking mode for the containers in your task definition with the
* <code>networkMode</code> parameter. The available network modes correspond to those described in <a
* href="https://docs.docker.com/engine/reference/run/#/network-settings">Network settings</a> in the Docker run
* reference.
* </p>
*
* @param registerTaskDefinitionRequest
* @return Result of the RegisterTaskDefinition operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @sample AmazonECS.RegisterTaskDefinition
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/RegisterTaskDefinition" target="_top">AWS API
* Documentation</a>
*/
@Override
public RegisterTaskDefinitionResult registerTaskDefinition(RegisterTaskDefinitionRequest request) {
request = beforeClientExecution(request);
return executeRegisterTaskDefinition(request);
}
@SdkInternalApi
final RegisterTaskDefinitionResult executeRegisterTaskDefinition(RegisterTaskDefinitionRequest registerTaskDefinitionRequest) {
ExecutionContext executionContext = createExecutionContext(registerTaskDefinitionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<RegisterTaskDefinitionRequest> request = null;
Response<RegisterTaskDefinitionResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RegisterTaskDefinitionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(registerTaskDefinitionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<RegisterTaskDefinitionResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new RegisterTaskDefinitionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Starts a new task using the specified task definition.
* </p>
* <p>
* You can allow Amazon ECS to place tasks for you, or you can customize how Amazon ECS places tasks using placement
* constraints and placement strategies. For more information, see <a
* href="http://docs.aws.amazon.com/AmazonECS/latest/developerguide/scheduling_tasks.html">Scheduling Tasks</a> in
* the <i>Amazon EC2 Container Service Developer Guide</i>.
* </p>
* <p>
* Alternatively, you can use <a>StartTask</a> to use your own scheduler or place tasks manually on specific
* container instances.
* </p>
*
* @param runTaskRequest
* @return Result of the RunTask operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @sample AmazonECS.RunTask
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/RunTask" target="_top">AWS API
* Documentation</a>
*/
@Override
public RunTaskResult runTask(RunTaskRequest request) {
request = beforeClientExecution(request);
return executeRunTask(request);
}
@SdkInternalApi
final RunTaskResult executeRunTask(RunTaskRequest runTaskRequest) {
ExecutionContext executionContext = createExecutionContext(runTaskRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<RunTaskRequest> request = null;
Response<RunTaskResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RunTaskRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(runTaskRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<RunTaskResult>> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new RunTaskResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Starts a new task from the specified task definition on the specified container instance or instances.
* </p>
* <p>
* Alternatively, you can use <a>RunTask</a> to place tasks for you. For more information, see <a
* href="http://docs.aws.amazon.com/AmazonECS/latest/developerguide/scheduling_tasks.html">Scheduling Tasks</a> in
* the <i>Amazon EC2 Container Service Developer Guide</i>.
* </p>
*
* @param startTaskRequest
* @return Result of the StartTask operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @sample AmazonECS.StartTask
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/StartTask" target="_top">AWS API
* Documentation</a>
*/
@Override
public StartTaskResult startTask(StartTaskRequest request) {
request = beforeClientExecution(request);
return executeStartTask(request);
}
@SdkInternalApi
final StartTaskResult executeStartTask(StartTaskRequest startTaskRequest) {
ExecutionContext executionContext = createExecutionContext(startTaskRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<StartTaskRequest> request = null;
Response<StartTaskResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StartTaskRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(startTaskRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<StartTaskResult>> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new StartTaskResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Stops a running task.
* </p>
* <p>
* When <a>StopTask</a> is called on a task, the equivalent of <code>docker stop</code> is issued to the containers
* running in the task. This results in a <code>SIGTERM</code> and a default 30-second timeout, after which
* <code>SIGKILL</code> is sent and the containers are forcibly stopped. If the container handles the
* <code>SIGTERM</code> gracefully and exits within 30 seconds from receiving it, no <code>SIGKILL</code> is sent.
* </p>
* <note>
* <p>
* The default 30-second timeout can be configured on the Amazon ECS container agent with the
* <code>ECS_CONTAINER_STOP_TIMEOUT</code> variable. For more information, see <a
* href="http://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html">Amazon ECS Container
* Agent Configuration</a> in the <i>Amazon EC2 Container Service Developer Guide</i>.
* </p>
* </note>
*
* @param stopTaskRequest
* @return Result of the StopTask operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @sample AmazonECS.StopTask
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/StopTask" target="_top">AWS API
* Documentation</a>
*/
@Override
public StopTaskResult stopTask(StopTaskRequest request) {
request = beforeClientExecution(request);
return executeStopTask(request);
}
@SdkInternalApi
final StopTaskResult executeStopTask(StopTaskRequest stopTaskRequest) {
ExecutionContext executionContext = createExecutionContext(stopTaskRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<StopTaskRequest> request = null;
Response<StopTaskResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StopTaskRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(stopTaskRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<StopTaskResult>> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new StopTaskResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <note>
* <p>
* This action is only used by the Amazon EC2 Container Service agent, and it is not intended for use outside of the
* agent.
* </p>
* </note>
* <p>
* Sent to acknowledge that a container changed states.
* </p>
*
* @param submitContainerStateChangeRequest
* @return Result of the SubmitContainerStateChange operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @sample AmazonECS.SubmitContainerStateChange
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/SubmitContainerStateChange" target="_top">AWS
* API Documentation</a>
*/
@Override
public SubmitContainerStateChangeResult submitContainerStateChange(SubmitContainerStateChangeRequest request) {
request = beforeClientExecution(request);
return executeSubmitContainerStateChange(request);
}
@SdkInternalApi
final SubmitContainerStateChangeResult executeSubmitContainerStateChange(SubmitContainerStateChangeRequest submitContainerStateChangeRequest) {
ExecutionContext executionContext = createExecutionContext(submitContainerStateChangeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<SubmitContainerStateChangeRequest> request = null;
Response<SubmitContainerStateChangeResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SubmitContainerStateChangeRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(submitContainerStateChangeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<SubmitContainerStateChangeResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new SubmitContainerStateChangeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public SubmitContainerStateChangeResult submitContainerStateChange() {
return submitContainerStateChange(new SubmitContainerStateChangeRequest());
}
/**
* <note>
* <p>
* This action is only used by the Amazon EC2 Container Service agent, and it is not intended for use outside of the
* agent.
* </p>
* </note>
* <p>
* Sent to acknowledge that a task changed states.
* </p>
*
* @param submitTaskStateChangeRequest
* @return Result of the SubmitTaskStateChange operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @sample AmazonECS.SubmitTaskStateChange
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/SubmitTaskStateChange" target="_top">AWS API
* Documentation</a>
*/
@Override
public SubmitTaskStateChangeResult submitTaskStateChange(SubmitTaskStateChangeRequest request) {
request = beforeClientExecution(request);
return executeSubmitTaskStateChange(request);
}
@SdkInternalApi
final SubmitTaskStateChangeResult executeSubmitTaskStateChange(SubmitTaskStateChangeRequest submitTaskStateChangeRequest) {
ExecutionContext executionContext = createExecutionContext(submitTaskStateChangeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<SubmitTaskStateChangeRequest> request = null;
Response<SubmitTaskStateChangeResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SubmitTaskStateChangeRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(submitTaskStateChangeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<SubmitTaskStateChangeResult>> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new SubmitTaskStateChangeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Updates the Amazon ECS container agent on a specified container instance. Updating the Amazon ECS container agent
* does not interrupt running tasks or services on the container instance. The process for updating the agent
* differs depending on whether your container instance was launched with the Amazon ECS-optimized AMI or another
* operating system.
* </p>
* <p>
* <code>UpdateContainerAgent</code> requires the Amazon ECS-optimized AMI or Amazon Linux with the
* <code>ecs-init</code> service installed and running. For help updating the Amazon ECS container agent on other
* operating systems, see <a
* href="http://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html#manually_update_agent"
* >Manually Updating the Amazon ECS Container Agent</a> in the <i>Amazon EC2 Container Service Developer Guide</i>.
* </p>
*
* @param updateContainerAgentRequest
* @return Result of the UpdateContainerAgent operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @throws UpdateInProgressException
* There is already a current Amazon ECS container agent update in progress on the specified container
* instance. If the container agent becomes disconnected while it is in a transitional stage, such as
* <code>PENDING</code> or <code>STAGING</code>, the update process can get stuck in that state. However,
* when the agent reconnects, it resumes where it stopped previously.
* @throws NoUpdateAvailableException
* There is no update available for this Amazon ECS container agent. This could be because the agent is
* already running the latest version, or it is so old that there is no update path to the current version.
* @throws MissingVersionException
* Amazon ECS is unable to determine the current version of the Amazon ECS container agent on the container
* instance and does not have enough information to proceed with an update. This could be because the agent
* running on the container instance is an older or custom version that does not use our version
* information.
* @sample AmazonECS.UpdateContainerAgent
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateContainerAgent" target="_top">AWS API
* Documentation</a>
*/
@Override
public UpdateContainerAgentResult updateContainerAgent(UpdateContainerAgentRequest request) {
request = beforeClientExecution(request);
return executeUpdateContainerAgent(request);
}
@SdkInternalApi
final UpdateContainerAgentResult executeUpdateContainerAgent(UpdateContainerAgentRequest updateContainerAgentRequest) {
ExecutionContext executionContext = createExecutionContext(updateContainerAgentRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<UpdateContainerAgentRequest> request = null;
Response<UpdateContainerAgentResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateContainerAgentRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateContainerAgentRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<UpdateContainerAgentResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateContainerAgentResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Modifies the status of an Amazon ECS container instance.
* </p>
* <p>
* You can change the status of a container instance to <code>DRAINING</code> to manually remove an instance from a
* cluster, for example to perform system updates, update the Docker daemon, or scale down the cluster size.
* </p>
* <p>
* When you set a container instance to <code>DRAINING</code>, Amazon ECS prevents new tasks from being scheduled
* for placement on the container instance and replacement service tasks are started on other container instances in
* the cluster if the resources are available. Service tasks on the container instance that are in the
* <code>PENDING</code> state are stopped immediately.
* </p>
* <p>
* Service tasks on the container instance that are in the <code>RUNNING</code> state are stopped and replaced
* according the service's deployment configuration parameters, <code>minimumHealthyPercent</code> and
* <code>maximumPercent</code>. Note that you can change the deployment configuration of your service using
* <a>UpdateService</a>.
* </p>
* <ul>
* <li>
* <p>
* If <code>minimumHealthyPercent</code> is below 100%, the scheduler can ignore <code>desiredCount</code>
* temporarily during task replacement. For example, <code>desiredCount</code> is four tasks, a minimum of 50%
* allows the scheduler to stop two existing tasks before starting two new tasks. If the minimum is 100%, the
* service scheduler can't remove existing tasks until the replacement tasks are considered healthy. Tasks for
* services that do not use a load balancer are considered healthy if they are in the <code>RUNNING</code> state.
* Tasks for services that use a load balancer are considered healthy if they are in the <code>RUNNING</code> state
* and the container instance they are hosted on is reported as healthy by the load balancer.
* </p>
* </li>
* <li>
* <p>
* The <code>maximumPercent</code> parameter represents an upper limit on the number of running tasks during task
* replacement, which enables you to define the replacement batch size. For example, if <code>desiredCount</code> of
* four tasks, a maximum of 200% starts four new tasks before stopping the four tasks to be drained (provided that
* the cluster resources required to do this are available). If the maximum is 100%, then replacement tasks can't
* start until the draining tasks have stopped.
* </p>
* </li>
* </ul>
* <p>
* Any <code>PENDING</code> or <code>RUNNING</code> tasks that do not belong to a service are not affected; you must
* wait for them to finish or stop them manually.
* </p>
* <p>
* A container instance has completed draining when it has no more <code>RUNNING</code> tasks. You can verify this
* using <a>ListTasks</a>.
* </p>
* <p>
* When you set a container instance to <code>ACTIVE</code>, the Amazon ECS scheduler can begin scheduling tasks on
* the instance again.
* </p>
*
* @param updateContainerInstancesStateRequest
* @return Result of the UpdateContainerInstancesState operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @sample AmazonECS.UpdateContainerInstancesState
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateContainerInstancesState"
* target="_top">AWS API Documentation</a>
*/
@Override
public UpdateContainerInstancesStateResult updateContainerInstancesState(UpdateContainerInstancesStateRequest request) {
request = beforeClientExecution(request);
return executeUpdateContainerInstancesState(request);
}
@SdkInternalApi
final UpdateContainerInstancesStateResult executeUpdateContainerInstancesState(UpdateContainerInstancesStateRequest updateContainerInstancesStateRequest) {
ExecutionContext executionContext = createExecutionContext(updateContainerInstancesStateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<UpdateContainerInstancesStateRequest> request = null;
Response<UpdateContainerInstancesStateResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateContainerInstancesStateRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateContainerInstancesStateRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<UpdateContainerInstancesStateResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateContainerInstancesStateResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* <p>
* Modifies the desired count, deployment configuration, or task definition used in a service.
* </p>
* <p>
* 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 <code>desiredCount</code> parameter.
* </p>
* <p>
* You can use <a>UpdateService</a> to modify your task definition and deploy a new version of your service.
* </p>
* <p>
* You can also update the deployment configuration of a service. When a deployment is triggered by updating the
* task definition of a service, the service scheduler uses the deployment configuration parameters,
* <code>minimumHealthyPercent</code> and <code>maximumPercent</code>, to determine the deployment strategy.
* </p>
* <ul>
* <li>
* <p>
* If <code>minimumHealthyPercent</code> is below 100%, the scheduler can ignore <code>desiredCount</code>
* temporarily during a deployment. For example, if <code>desiredCount</code> is four tasks, a minimum of 50% allows
* the scheduler to stop two existing tasks before starting two new tasks. Tasks for services that do not use a load
* balancer are considered healthy if they are in the <code>RUNNING</code> state. Tasks for services that use a load
* balancer are considered healthy if they are in the <code>RUNNING</code> state and the container instance they are
* hosted on is reported as healthy by the load balancer.
* </p>
* </li>
* <li>
* <p>
* The <code>maximumPercent</code> parameter represents an upper limit on the number of running tasks during a
* deployment, which enables you to define the deployment batch size. For example, if <code>desiredCount</code> is
* four tasks, a maximum of 200% starts four new tasks before stopping the four older tasks (provided that the
* cluster resources required to do this are available).
* </p>
* </li>
* </ul>
* <p>
* When <a>UpdateService</a> stops a task during a deployment, the equivalent of <code>docker stop</code> is issued
* to the containers running in the task. This results in a <code>SIGTERM</code> and a 30-second timeout, after
* which <code>SIGKILL</code> is sent and the containers are forcibly stopped. If the container handles the
* <code>SIGTERM</code> gracefully and exits within 30 seconds from receiving it, no <code>SIGKILL</code> is sent.
* </p>
* <p>
* When the service scheduler launches new tasks, it determines task placement in your cluster with the following
* logic:
* </p>
* <ul>
* <li>
* <p>
* Determine which of the container instances in your cluster can support your service's task definition (for
* example, they have the required CPU, memory, ports, and container instance attributes).
* </p>
* </li>
* <li>
* <p>
* By default, the service scheduler attempts to balance tasks across Availability Zones in this manner (although
* you can choose a different placement strategy):
* </p>
* <ul>
* <li>
* <p>
* Sort the valid container instances by the fewest number of running tasks for this service in the same
* Availability Zone as the instance. For example, if zone A has one running service task and zones B and C each
* have zero, valid container instances in either zone B or C are considered optimal for placement.
* </p>
* </li>
* <li>
* <p>
* Place the new service task on a valid container instance in an optimal Availability Zone (based on the previous
* steps), favoring container instances with the fewest number of running tasks for this service.
* </p>
* </li>
* </ul>
* </li>
* </ul>
* <p>
* When the service scheduler stops running tasks, it attempts to maintain balance across the Availability Zones in
* your cluster using the following logic:
* </p>
* <ul>
* <li>
* <p>
* Sort the container instances by the largest number of running tasks for this service in the same Availability
* Zone as the instance. For example, if zone A has one running service task and zones B and C each have two,
* container instances in either zone B or C are considered optimal for termination.
* </p>
* </li>
* <li>
* <p>
* Stop the task on a container instance in an optimal Availability Zone (based on the previous steps), favoring
* container instances with the largest number of running tasks for this service.
* </p>
* </li>
* </ul>
*
* @param updateServiceRequest
* @return Result of the UpdateService operation returned by the service.
* @throws ServerException
* These errors are usually caused by a server issue.
* @throws ClientException
* These errors are usually caused by a client action, such as using an action or resource on behalf of a
* user that doesn't have permission to use the action or resource, or specifying an identifier that is not
* valid.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with <a>ListClusters</a>.
* Amazon ECS clusters are region-specific.
* @throws ServiceNotFoundException
* The specified service could not be found. You can view your available services with <a>ListServices</a>.
* Amazon ECS services are cluster-specific and region-specific.
* @throws ServiceNotActiveException
* The specified service is not active. You cannot update a service that is not active. If you have
* previously deleted a service, you can re-create it with <a>CreateService</a>.
* @sample AmazonECS.UpdateService
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/ecs-2014-11-13/UpdateService" target="_top">AWS API
* Documentation</a>
*/
@Override
public UpdateServiceResult updateService(UpdateServiceRequest request) {
request = beforeClientExecution(request);
return executeUpdateService(request);
}
@SdkInternalApi
final UpdateServiceResult executeUpdateService(UpdateServiceRequest updateServiceRequest) {
ExecutionContext executionContext = createExecutionContext(updateServiceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request<UpdateServiceRequest> request = null;
Response<UpdateServiceResult> response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateServiceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateServiceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler<AmazonWebServiceResponse<UpdateServiceResult>> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateServiceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* Returns additional metadata for a previously executed successful, request, typically used for debugging issues
* where a service isn't acting as expected. This data isn't considered part of the result data returned by an
* operation, so it's available through this separate, diagnostic interface.
* <p>
* Response metadata is only cached for a limited period of time, so if you need to access this extra diagnostic
* information for an executed request, you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none is available.
*/
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private <X, Y extends AmazonWebServiceRequest> Response<X> invoke(Request<Y> request, HttpResponseHandler<AmazonWebServiceResponse<X>> responseHandler,
ExecutionContext executionContext) {
executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(request.getOriginalRequest(), awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext);
}
/**
* Invoke with no authentication. Credentials are not required and any credentials set on the client or request will
* be ignored for this operation.
**/
private <X, Y extends AmazonWebServiceRequest> Response<X> anonymousInvoke(Request<Y> request,
HttpResponseHandler<AmazonWebServiceResponse<X>> responseHandler, ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack thereof) have been configured in the
* ExecutionContext beforehand.
**/
private <X, Y extends AmazonWebServiceRequest> Response<X> doInvoke(Request<Y> request, HttpResponseHandler<AmazonWebServiceResponse<X>> responseHandler,
ExecutionContext executionContext) {
request.setEndpoint(endpoint);
request.setTimeOffset(timeOffset);
HttpResponseHandler<AmazonServiceException> errorResponseHandler = protocolFactory.createErrorResponseHandler(new JsonErrorResponseMetadata());
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
@Override
public AmazonECSWaiters waiters() {
if (waiters == null) {
synchronized (this) {
if (waiters == null) {
waiters = new AmazonECSWaiters(this);
}
}
}
return waiters;
}
@Override
public void shutdown() {
super.shutdown();
if (waiters != null) {
waiters.shutdown();
}
}
}