software.amazon.awssdk.services.ecs.DefaultEcsClient Maven / Gradle / Ivy
/*
* Copyright 2014-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package software.amazon.awssdk.services.ecs;
import java.util.function.Consumer;
import software.amazon.awssdk.annotations.Generated;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.awscore.AwsRequestOverrideConfiguration;
import software.amazon.awssdk.awscore.client.handler.AwsSyncClientHandler;
import software.amazon.awssdk.awscore.exception.AwsServiceException;
import software.amazon.awssdk.core.ApiName;
import software.amazon.awssdk.core.client.config.SdkClientConfiguration;
import software.amazon.awssdk.core.client.handler.ClientExecutionParams;
import software.amazon.awssdk.core.client.handler.SyncClientHandler;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.http.HttpResponseHandler;
import software.amazon.awssdk.core.util.VersionInfo;
import software.amazon.awssdk.protocols.core.ExceptionMetadata;
import software.amazon.awssdk.protocols.json.AwsJsonProtocol;
import software.amazon.awssdk.protocols.json.AwsJsonProtocolFactory;
import software.amazon.awssdk.protocols.json.BaseAwsJsonProtocolFactory;
import software.amazon.awssdk.protocols.json.JsonOperationMetadata;
import software.amazon.awssdk.services.ecs.model.AccessDeniedException;
import software.amazon.awssdk.services.ecs.model.AttributeLimitExceededException;
import software.amazon.awssdk.services.ecs.model.BlockedException;
import software.amazon.awssdk.services.ecs.model.ClientException;
import software.amazon.awssdk.services.ecs.model.ClusterContainsContainerInstancesException;
import software.amazon.awssdk.services.ecs.model.ClusterContainsServicesException;
import software.amazon.awssdk.services.ecs.model.ClusterContainsTasksException;
import software.amazon.awssdk.services.ecs.model.ClusterNotFoundException;
import software.amazon.awssdk.services.ecs.model.CreateClusterRequest;
import software.amazon.awssdk.services.ecs.model.CreateClusterResponse;
import software.amazon.awssdk.services.ecs.model.CreateServiceRequest;
import software.amazon.awssdk.services.ecs.model.CreateServiceResponse;
import software.amazon.awssdk.services.ecs.model.CreateTaskSetRequest;
import software.amazon.awssdk.services.ecs.model.CreateTaskSetResponse;
import software.amazon.awssdk.services.ecs.model.DeleteAccountSettingRequest;
import software.amazon.awssdk.services.ecs.model.DeleteAccountSettingResponse;
import software.amazon.awssdk.services.ecs.model.DeleteAttributesRequest;
import software.amazon.awssdk.services.ecs.model.DeleteAttributesResponse;
import software.amazon.awssdk.services.ecs.model.DeleteClusterRequest;
import software.amazon.awssdk.services.ecs.model.DeleteClusterResponse;
import software.amazon.awssdk.services.ecs.model.DeleteServiceRequest;
import software.amazon.awssdk.services.ecs.model.DeleteServiceResponse;
import software.amazon.awssdk.services.ecs.model.DeleteTaskSetRequest;
import software.amazon.awssdk.services.ecs.model.DeleteTaskSetResponse;
import software.amazon.awssdk.services.ecs.model.DeregisterContainerInstanceRequest;
import software.amazon.awssdk.services.ecs.model.DeregisterContainerInstanceResponse;
import software.amazon.awssdk.services.ecs.model.DeregisterTaskDefinitionRequest;
import software.amazon.awssdk.services.ecs.model.DeregisterTaskDefinitionResponse;
import software.amazon.awssdk.services.ecs.model.DescribeClustersRequest;
import software.amazon.awssdk.services.ecs.model.DescribeClustersResponse;
import software.amazon.awssdk.services.ecs.model.DescribeContainerInstancesRequest;
import software.amazon.awssdk.services.ecs.model.DescribeContainerInstancesResponse;
import software.amazon.awssdk.services.ecs.model.DescribeServicesRequest;
import software.amazon.awssdk.services.ecs.model.DescribeServicesResponse;
import software.amazon.awssdk.services.ecs.model.DescribeTaskDefinitionRequest;
import software.amazon.awssdk.services.ecs.model.DescribeTaskDefinitionResponse;
import software.amazon.awssdk.services.ecs.model.DescribeTaskSetsRequest;
import software.amazon.awssdk.services.ecs.model.DescribeTaskSetsResponse;
import software.amazon.awssdk.services.ecs.model.DescribeTasksRequest;
import software.amazon.awssdk.services.ecs.model.DescribeTasksResponse;
import software.amazon.awssdk.services.ecs.model.DiscoverPollEndpointRequest;
import software.amazon.awssdk.services.ecs.model.DiscoverPollEndpointResponse;
import software.amazon.awssdk.services.ecs.model.EcsException;
import software.amazon.awssdk.services.ecs.model.EcsRequest;
import software.amazon.awssdk.services.ecs.model.InvalidParameterException;
import software.amazon.awssdk.services.ecs.model.ListAccountSettingsRequest;
import software.amazon.awssdk.services.ecs.model.ListAccountSettingsResponse;
import software.amazon.awssdk.services.ecs.model.ListAttributesRequest;
import software.amazon.awssdk.services.ecs.model.ListAttributesResponse;
import software.amazon.awssdk.services.ecs.model.ListClustersRequest;
import software.amazon.awssdk.services.ecs.model.ListClustersResponse;
import software.amazon.awssdk.services.ecs.model.ListContainerInstancesRequest;
import software.amazon.awssdk.services.ecs.model.ListContainerInstancesResponse;
import software.amazon.awssdk.services.ecs.model.ListServicesRequest;
import software.amazon.awssdk.services.ecs.model.ListServicesResponse;
import software.amazon.awssdk.services.ecs.model.ListTagsForResourceRequest;
import software.amazon.awssdk.services.ecs.model.ListTagsForResourceResponse;
import software.amazon.awssdk.services.ecs.model.ListTaskDefinitionFamiliesRequest;
import software.amazon.awssdk.services.ecs.model.ListTaskDefinitionFamiliesResponse;
import software.amazon.awssdk.services.ecs.model.ListTaskDefinitionsRequest;
import software.amazon.awssdk.services.ecs.model.ListTaskDefinitionsResponse;
import software.amazon.awssdk.services.ecs.model.ListTasksRequest;
import software.amazon.awssdk.services.ecs.model.ListTasksResponse;
import software.amazon.awssdk.services.ecs.model.MissingVersionException;
import software.amazon.awssdk.services.ecs.model.NoUpdateAvailableException;
import software.amazon.awssdk.services.ecs.model.PlatformTaskDefinitionIncompatibilityException;
import software.amazon.awssdk.services.ecs.model.PlatformUnknownException;
import software.amazon.awssdk.services.ecs.model.PutAccountSettingDefaultRequest;
import software.amazon.awssdk.services.ecs.model.PutAccountSettingDefaultResponse;
import software.amazon.awssdk.services.ecs.model.PutAccountSettingRequest;
import software.amazon.awssdk.services.ecs.model.PutAccountSettingResponse;
import software.amazon.awssdk.services.ecs.model.PutAttributesRequest;
import software.amazon.awssdk.services.ecs.model.PutAttributesResponse;
import software.amazon.awssdk.services.ecs.model.RegisterContainerInstanceRequest;
import software.amazon.awssdk.services.ecs.model.RegisterContainerInstanceResponse;
import software.amazon.awssdk.services.ecs.model.RegisterTaskDefinitionRequest;
import software.amazon.awssdk.services.ecs.model.RegisterTaskDefinitionResponse;
import software.amazon.awssdk.services.ecs.model.ResourceNotFoundException;
import software.amazon.awssdk.services.ecs.model.RunTaskRequest;
import software.amazon.awssdk.services.ecs.model.RunTaskResponse;
import software.amazon.awssdk.services.ecs.model.ServerException;
import software.amazon.awssdk.services.ecs.model.ServiceNotActiveException;
import software.amazon.awssdk.services.ecs.model.ServiceNotFoundException;
import software.amazon.awssdk.services.ecs.model.StartTaskRequest;
import software.amazon.awssdk.services.ecs.model.StartTaskResponse;
import software.amazon.awssdk.services.ecs.model.StopTaskRequest;
import software.amazon.awssdk.services.ecs.model.StopTaskResponse;
import software.amazon.awssdk.services.ecs.model.SubmitAttachmentStateChangesRequest;
import software.amazon.awssdk.services.ecs.model.SubmitAttachmentStateChangesResponse;
import software.amazon.awssdk.services.ecs.model.SubmitContainerStateChangeRequest;
import software.amazon.awssdk.services.ecs.model.SubmitContainerStateChangeResponse;
import software.amazon.awssdk.services.ecs.model.SubmitTaskStateChangeRequest;
import software.amazon.awssdk.services.ecs.model.SubmitTaskStateChangeResponse;
import software.amazon.awssdk.services.ecs.model.TagResourceRequest;
import software.amazon.awssdk.services.ecs.model.TagResourceResponse;
import software.amazon.awssdk.services.ecs.model.TargetNotFoundException;
import software.amazon.awssdk.services.ecs.model.TaskSetNotFoundException;
import software.amazon.awssdk.services.ecs.model.UnsupportedFeatureException;
import software.amazon.awssdk.services.ecs.model.UntagResourceRequest;
import software.amazon.awssdk.services.ecs.model.UntagResourceResponse;
import software.amazon.awssdk.services.ecs.model.UpdateContainerAgentRequest;
import software.amazon.awssdk.services.ecs.model.UpdateContainerAgentResponse;
import software.amazon.awssdk.services.ecs.model.UpdateContainerInstancesStateRequest;
import software.amazon.awssdk.services.ecs.model.UpdateContainerInstancesStateResponse;
import software.amazon.awssdk.services.ecs.model.UpdateInProgressException;
import software.amazon.awssdk.services.ecs.model.UpdateServicePrimaryTaskSetRequest;
import software.amazon.awssdk.services.ecs.model.UpdateServicePrimaryTaskSetResponse;
import software.amazon.awssdk.services.ecs.model.UpdateServiceRequest;
import software.amazon.awssdk.services.ecs.model.UpdateServiceResponse;
import software.amazon.awssdk.services.ecs.model.UpdateTaskSetRequest;
import software.amazon.awssdk.services.ecs.model.UpdateTaskSetResponse;
import software.amazon.awssdk.services.ecs.paginators.ListClustersIterable;
import software.amazon.awssdk.services.ecs.paginators.ListContainerInstancesIterable;
import software.amazon.awssdk.services.ecs.paginators.ListServicesIterable;
import software.amazon.awssdk.services.ecs.paginators.ListTaskDefinitionFamiliesIterable;
import software.amazon.awssdk.services.ecs.paginators.ListTaskDefinitionsIterable;
import software.amazon.awssdk.services.ecs.paginators.ListTasksIterable;
import software.amazon.awssdk.services.ecs.transform.CreateClusterRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.CreateServiceRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.CreateTaskSetRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.DeleteAccountSettingRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.DeleteAttributesRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.DeleteClusterRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.DeleteServiceRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.DeleteTaskSetRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.DeregisterContainerInstanceRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.DeregisterTaskDefinitionRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.DescribeClustersRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.DescribeContainerInstancesRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.DescribeServicesRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.DescribeTaskDefinitionRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.DescribeTaskSetsRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.DescribeTasksRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.DiscoverPollEndpointRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.ListAccountSettingsRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.ListAttributesRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.ListClustersRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.ListContainerInstancesRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.ListServicesRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.ListTagsForResourceRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.ListTaskDefinitionFamiliesRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.ListTaskDefinitionsRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.ListTasksRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.PutAccountSettingDefaultRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.PutAccountSettingRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.PutAttributesRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.RegisterContainerInstanceRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.RegisterTaskDefinitionRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.RunTaskRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.StartTaskRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.StopTaskRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.SubmitAttachmentStateChangesRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.SubmitContainerStateChangeRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.SubmitTaskStateChangeRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.TagResourceRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.UntagResourceRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.UpdateContainerAgentRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.UpdateContainerInstancesStateRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.UpdateServicePrimaryTaskSetRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.UpdateServiceRequestMarshaller;
import software.amazon.awssdk.services.ecs.transform.UpdateTaskSetRequestMarshaller;
/**
* Internal implementation of {@link EcsClient}.
*
* @see EcsClient#builder()
*/
@Generated("software.amazon.awssdk:codegen")
@SdkInternalApi
final class DefaultEcsClient implements EcsClient {
private final SyncClientHandler clientHandler;
private final AwsJsonProtocolFactory protocolFactory;
private final SdkClientConfiguration clientConfiguration;
protected DefaultEcsClient(SdkClientConfiguration clientConfiguration) {
this.clientHandler = new AwsSyncClientHandler(clientConfiguration);
this.clientConfiguration = clientConfiguration;
this.protocolFactory = init(AwsJsonProtocolFactory.builder()).build();
}
@Override
public final String serviceName() {
return SERVICE_NAME;
}
/**
*
* Creates a new Amazon ECS cluster. By default, your account receives a default cluster when you
* launch your first container instance. However, you can create your own cluster with a unique name with the
* CreateCluster action.
*
*
*
* When you call the CreateCluster API operation, Amazon ECS attempts to create the service-linked role for
* your account so that required resources in other AWS services can be managed on your behalf. However, if the IAM
* user that makes the call does not have permissions to create the service-linked role, it is not created. For more
* information, see Using
* Service-Linked Roles for Amazon ECS in the Amazon Elastic Container Service Developer Guide.
*
*
*
* @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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.CreateCluster
* @see AWS API
* Documentation
*/
@Override
public CreateClusterResponse createCluster(CreateClusterRequest createClusterRequest) throws ServerException,
ClientException, InvalidParameterException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
CreateClusterResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("CreateCluster").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(createClusterRequest)
.withMarshaller(new CreateClusterRequestMarshaller(protocolFactory)));
}
/**
*
* Runs and maintains a desired number of tasks from a specified task definition. If the number of tasks running in
* a service drops below the desiredCount, Amazon ECS spawns another copy of the task in the specified
* cluster. To update an existing service, see UpdateService.
*
*
* 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 Service Load
* Balancing in the Amazon Elastic Container Service Developer Guide.
*
*
* Tasks for services that do not use a load balancer are considered healthy if they're in the
* RUNNING state. Tasks for services that do use a load balancer are considered healthy if
* they're in the RUNNING state and the container instance that they're hosted on is reported as
* healthy by the load balancer.
*
*
* There are two service scheduler strategies available:
*
*
* -
*
* REPLICA - The replica scheduling strategy places and maintains the desired number of tasks across
* your cluster. By default, the service scheduler spreads tasks across Availability Zones. You can use task
* placement strategies and constraints to customize task placement decisions. For more information, see Service Scheduler
* Concepts in the Amazon Elastic Container Service Developer Guide.
*
*
* -
*
* DAEMON - The daemon scheduling strategy deploys exactly one task on each active container instance
* that meets all of the task placement constraints that you specify in your cluster. When using this strategy, you
* don't need to specify a desired number of tasks, a task placement strategy, or use Service Auto Scaling policies.
* For more information, see Service Scheduler
* Concepts in the Amazon Elastic Container Service Developer Guide.
*
*
*
*
* You can optionally specify a deployment configuration for your service. The deployment is triggered by changing
* properties, such as the task definition or the desired count of a service, with an UpdateService
* operation. The default value for a replica service for minimumHealthyPercent is 100%. The default
* value for a daemon service for minimumHealthyPercent is 0%.
*
*
* If a service is using the ECS deployment controller, the minimum healthy percent represents a lower
* limit on the number of tasks in a service that must remain in the RUNNING state during a deployment,
* as a percentage of the desired number of tasks (rounded up to the nearest integer), and while any container
* instances are in the DRAINING state if the service contains tasks using the EC2 launch type. This
* parameter enables you to deploy without using additional cluster capacity. For example, if your service has a
* desired number of four tasks and a minimum healthy percent of 50%, the scheduler might stop two existing tasks to
* free up cluster capacity before starting two new tasks. Tasks for services that do not use a load balancer
* are considered healthy if they're in the RUNNING state. Tasks for services that do use a load
* balancer are considered healthy if they're in the RUNNING state and they're reported as healthy by
* the load balancer. The default value for minimum healthy percent is 100%.
*
*
* If a service is using the ECS deployment controller, the maximum percent parameter represents
* an upper limit on the number of tasks in a service that are allowed in the RUNNING or
* PENDING state during a deployment, as a percentage of the desired number of tasks (rounded down to
* the nearest integer), and while any container instances are in the DRAINING state if the service
* contains tasks using the EC2 launch type. This parameter enables you to define the deployment batch size. For
* example, if your service has a desired number of four tasks and a maximum percent value of 200%, the scheduler
* may 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 maximum percent is 200%.
*
*
* If a service is using either the CODE_DEPLOY or EXTERNAL deployment controller types
* and tasks that use the EC2 launch type, the minimum healthy percent and maximum percent values are
* used only to define the lower and upper limit on the number of the tasks in the service that remain in the
* RUNNING state while the container instances are in the DRAINING state. If the tasks in
* the service use the Fargate launch type, the minimum healthy percent and maximum percent values aren't used,
* although they're currently visible when describing your service.
*
*
* When creating a service that uses the EXTERNAL deployment controller, you can specify only
* parameters that aren't controlled at the task set level. The only required parameter is the service name. You
* control your services using the CreateTaskSet operation. For more information, see Amazon ECS Deployment
* Types in the Amazon Elastic Container Service Developer Guide.
*
*
* When the service scheduler launches new tasks, it determines task placement in your cluster using the following
* logic:
*
*
* -
*
* 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).
*
*
* -
*
* 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 placementStrategy parameter):
*
*
* -
*
* Sort the valid container instances, giving priority to instances that have the fewest number of running tasks for
* this service in their respective Availability Zone. 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.
*
*
* -
*
* 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.
*
*
*
*
*
*
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws UnsupportedFeatureException
* The specified task is not supported in this Region.
* @throws PlatformUnknownException
* The specified platform version does not exist.
* @throws PlatformTaskDefinitionIncompatibilityException
* The specified platform version does not satisfy the task definition's required capabilities.
* @throws AccessDeniedException
* You do not have authorization to perform the requested action.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.CreateService
* @see AWS API
* Documentation
*/
@Override
public CreateServiceResponse createService(CreateServiceRequest createServiceRequest) throws ServerException,
ClientException, InvalidParameterException, ClusterNotFoundException, UnsupportedFeatureException,
PlatformUnknownException, PlatformTaskDefinitionIncompatibilityException, AccessDeniedException, AwsServiceException,
SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
CreateServiceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("CreateService").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(createServiceRequest)
.withMarshaller(new CreateServiceRequestMarshaller(protocolFactory)));
}
/**
*
* Create a task set in the specified cluster and service. This is used when a service uses the
* EXTERNAL deployment controller type. For more information, see Amazon ECS Deployment
* Types in the Amazon Elastic Container Service Developer Guide.
*
*
* @param createTaskSetRequest
* @return Result of the CreateTaskSet 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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws UnsupportedFeatureException
* The specified task is not supported in this Region.
* @throws PlatformUnknownException
* The specified platform version does not exist.
* @throws PlatformTaskDefinitionIncompatibilityException
* The specified platform version does not satisfy the task definition's required capabilities.
* @throws AccessDeniedException
* You do not have authorization to perform the requested action.
* @throws ServiceNotFoundException
* The specified service could not be found. You can view your available services with ListServices.
* Amazon ECS services are cluster-specific and Region-specific.
* @throws ServiceNotActiveException
* The specified service is not active. You can't update a service that is inactive. If you have previously
* deleted a service, you can re-create it with CreateService.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.CreateTaskSet
* @see AWS API
* Documentation
*/
@Override
public CreateTaskSetResponse createTaskSet(CreateTaskSetRequest createTaskSetRequest) throws ServerException,
ClientException, InvalidParameterException, ClusterNotFoundException, UnsupportedFeatureException,
PlatformUnknownException, PlatformTaskDefinitionIncompatibilityException, AccessDeniedException,
ServiceNotFoundException, ServiceNotActiveException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
CreateTaskSetResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("CreateTaskSet").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(createTaskSetRequest)
.withMarshaller(new CreateTaskSetRequestMarshaller(protocolFactory)));
}
/**
*
* Disables an account setting for a specified IAM user, IAM role, or the root user for an account.
*
*
* @param deleteAccountSettingRequest
* @return Result of the DeleteAccountSetting 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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.DeleteAccountSetting
* @see AWS API
* Documentation
*/
@Override
public DeleteAccountSettingResponse deleteAccountSetting(DeleteAccountSettingRequest deleteAccountSettingRequest)
throws ServerException, ClientException, InvalidParameterException, AwsServiceException, SdkClientException,
EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DeleteAccountSettingResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("DeleteAccountSetting").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(deleteAccountSettingRequest)
.withMarshaller(new DeleteAccountSettingRequestMarshaller(protocolFactory)));
}
/**
*
* Deletes one or more custom attributes from an Amazon ECS resource.
*
*
* @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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws TargetNotFoundException
* The specified target could not be found. You can view your available container instances with
* ListContainerInstances. 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.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.DeleteAttributes
* @see AWS API
* Documentation
*/
@Override
public DeleteAttributesResponse deleteAttributes(DeleteAttributesRequest deleteAttributesRequest)
throws ClusterNotFoundException, TargetNotFoundException, InvalidParameterException, AwsServiceException,
SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
DeleteAttributesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("DeleteAttributes").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(deleteAttributesRequest)
.withMarshaller(new DeleteAttributesRequestMarshaller(protocolFactory)));
}
/**
*
* Deletes the specified cluster. You must deregister all container instances from this cluster before you may
* delete it. You can list the container instances in a cluster with ListContainerInstances and deregister
* them with DeregisterContainerInstance.
*
*
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws ClusterContainsContainerInstancesException
* You cannot delete a cluster that has registered container instances. First, deregister the container
* instances before you can delete the cluster. For more information, see
* DeregisterContainerInstance.
* @throws ClusterContainsServicesException
* You cannot delete a cluster that contains services. First, update the service to reduce its desired task
* count to 0 and then delete the service. For more information, see UpdateService and
* DeleteService.
* @throws ClusterContainsTasksException
* You cannot delete a cluster that has active tasks.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.DeleteCluster
* @see AWS API
* Documentation
*/
@Override
public DeleteClusterResponse deleteCluster(DeleteClusterRequest deleteClusterRequest) throws ServerException,
ClientException, InvalidParameterException, ClusterNotFoundException, ClusterContainsContainerInstancesException,
ClusterContainsServicesException, ClusterContainsTasksException, AwsServiceException, SdkClientException,
EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
DeleteClusterResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("DeleteCluster").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(deleteClusterRequest)
.withMarshaller(new DeleteClusterRequestMarshaller(protocolFactory)));
}
/**
*
* 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 UpdateService.
*
*
*
* When you delete a service, if there are still running tasks that require cleanup, the service status moves from
* ACTIVE to DRAINING, and the service is no longer visible in the console or in the
* ListServices API operation. After all tasks have transitioned to either STOPPING or
* STOPPED status, the service status moves from DRAINING to INACTIVE.
* Services in the DRAINING or INACTIVE status can still be viewed with the
* DescribeServices API operation. However, in the future, INACTIVE services may be cleaned up
* and purged from Amazon ECS record keeping, and DescribeServices calls on those services return a
* ServiceNotFoundException error.
*
*
*
* If you attempt to create a new service with the same name as an existing service in either ACTIVE or
* DRAINING status, you receive an error.
*
*
*
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws ServiceNotFoundException
* The specified service could not be found. You can view your available services with ListServices.
* Amazon ECS services are cluster-specific and Region-specific.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.DeleteService
* @see AWS API
* Documentation
*/
@Override
public DeleteServiceResponse deleteService(DeleteServiceRequest deleteServiceRequest) throws ServerException,
ClientException, InvalidParameterException, ClusterNotFoundException, ServiceNotFoundException, AwsServiceException,
SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
DeleteServiceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("DeleteService").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(deleteServiceRequest)
.withMarshaller(new DeleteServiceRequestMarshaller(protocolFactory)));
}
/**
*
* Deletes a specified task set within a service. This is used when a service uses the EXTERNAL
* deployment controller type. For more information, see Amazon ECS Deployment
* Types in the Amazon Elastic Container Service Developer Guide.
*
*
* @param deleteTaskSetRequest
* @return Result of the DeleteTaskSet 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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws UnsupportedFeatureException
* The specified task is not supported in this Region.
* @throws AccessDeniedException
* You do not have authorization to perform the requested action.
* @throws ServiceNotFoundException
* The specified service could not be found. You can view your available services with ListServices.
* Amazon ECS services are cluster-specific and Region-specific.
* @throws ServiceNotActiveException
* The specified service is not active. You can't update a service that is inactive. If you have previously
* deleted a service, you can re-create it with CreateService.
* @throws TaskSetNotFoundException
* The specified task set could not be found. You can view your available container instances with
* DescribeTaskSets. Task sets are specific to each cluster, service and Region.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.DeleteTaskSet
* @see AWS API
* Documentation
*/
@Override
public DeleteTaskSetResponse deleteTaskSet(DeleteTaskSetRequest deleteTaskSetRequest) throws ServerException,
ClientException, InvalidParameterException, ClusterNotFoundException, UnsupportedFeatureException,
AccessDeniedException, ServiceNotFoundException, ServiceNotActiveException, TaskSetNotFoundException,
AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
DeleteTaskSetResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("DeleteTaskSet").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(deleteTaskSetRequest)
.withMarshaller(new DeleteTaskSetRequestMarshaller(protocolFactory)));
}
/**
*
* Deregisters an Amazon ECS container instance from the specified cluster. This instance is no longer available to
* run tasks.
*
*
* 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. That prevents any orphaned tasks from
* consuming resources.
*
*
* 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.
*
*
*
* 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).
*
*
*
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.DeregisterContainerInstance
* @see AWS API Documentation
*/
@Override
public DeregisterContainerInstanceResponse deregisterContainerInstance(
DeregisterContainerInstanceRequest deregisterContainerInstanceRequest) throws ServerException, ClientException,
InvalidParameterException, ClusterNotFoundException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DeregisterContainerInstanceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeregisterContainerInstance").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(deregisterContainerInstanceRequest)
.withMarshaller(new DeregisterContainerInstanceRequestMarshaller(protocolFactory)));
}
/**
*
* Deregisters the specified task definition by family and revision. Upon deregistration, the task definition is
* marked as INACTIVE. Existing tasks and services that reference an INACTIVE task
* definition continue to run without disruption. Existing services that reference an INACTIVE task
* definition can still scale up or down by modifying the service's desired count.
*
*
* You cannot use an INACTIVE task definition to run new tasks or create new services, and you cannot
* update an existing service to reference an INACTIVE task definition. However, there may be up to a
* 10-minute window following deregistration where these restrictions have not yet taken effect.
*
*
*
* At this time, INACTIVE task definitions remain discoverable in your account indefinitely. However,
* this behavior is subject to change in the future, so you should not rely on INACTIVE task
* definitions persisting beyond the lifecycle of any associated tasks and services.
*
*
*
* @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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.DeregisterTaskDefinition
* @see AWS
* API Documentation
*/
@Override
public DeregisterTaskDefinitionResponse deregisterTaskDefinition(
DeregisterTaskDefinitionRequest deregisterTaskDefinitionRequest) throws ServerException, ClientException,
InvalidParameterException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DeregisterTaskDefinitionResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeregisterTaskDefinition").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(deregisterTaskDefinitionRequest)
.withMarshaller(new DeregisterTaskDefinitionRequestMarshaller(protocolFactory)));
}
/**
*
* Describes one or more of your clusters.
*
*
* @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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.DescribeClusters
* @see AWS API
* Documentation
*/
@Override
public DescribeClustersResponse describeClusters(DescribeClustersRequest describeClustersRequest) throws ServerException,
ClientException, InvalidParameterException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
DescribeClustersResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("DescribeClusters").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(describeClustersRequest)
.withMarshaller(new DescribeClustersRequestMarshaller(protocolFactory)));
}
/**
*
* Describes Amazon Elastic Container Service container instances. Returns metadata about registered and remaining
* resources on each container instance requested.
*
*
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.DescribeContainerInstances
* @see AWS
* API Documentation
*/
@Override
public DescribeContainerInstancesResponse describeContainerInstances(
DescribeContainerInstancesRequest describeContainerInstancesRequest) throws ServerException, ClientException,
InvalidParameterException, ClusterNotFoundException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DescribeContainerInstancesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DescribeContainerInstances").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(describeContainerInstancesRequest)
.withMarshaller(new DescribeContainerInstancesRequestMarshaller(protocolFactory)));
}
/**
*
* Describes the specified services running in your cluster.
*
*
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.DescribeServices
* @see AWS API
* Documentation
*/
@Override
public DescribeServicesResponse describeServices(DescribeServicesRequest describeServicesRequest) throws ServerException,
ClientException, InvalidParameterException, ClusterNotFoundException, AwsServiceException, SdkClientException,
EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
DescribeServicesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("DescribeServices").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(describeServicesRequest)
.withMarshaller(new DescribeServicesRequestMarshaller(protocolFactory)));
}
/**
*
* Describes a task definition. You can specify a family and revision to find information
* about a specific task definition, or you can simply specify the family to find the latest ACTIVE
* revision in that family.
*
*
*
* You can only describe INACTIVE task definitions while an active task or service references them.
*
*
*
* @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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.DescribeTaskDefinition
* @see AWS API
* Documentation
*/
@Override
public DescribeTaskDefinitionResponse describeTaskDefinition(DescribeTaskDefinitionRequest describeTaskDefinitionRequest)
throws ServerException, ClientException, InvalidParameterException, AwsServiceException, SdkClientException,
EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DescribeTaskDefinitionResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("DescribeTaskDefinition").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(describeTaskDefinitionRequest)
.withMarshaller(new DescribeTaskDefinitionRequestMarshaller(protocolFactory)));
}
/**
*
* Describes the task sets in the specified cluster and service. This is used when a service uses the
* EXTERNAL deployment controller type. For more information, see Amazon ECS Deployment
* Types in the Amazon Elastic Container Service Developer Guide.
*
*
* @param describeTaskSetsRequest
* @return Result of the DescribeTaskSets 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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws UnsupportedFeatureException
* The specified task is not supported in this Region.
* @throws AccessDeniedException
* You do not have authorization to perform the requested action.
* @throws ServiceNotFoundException
* The specified service could not be found. You can view your available services with ListServices.
* Amazon ECS services are cluster-specific and Region-specific.
* @throws ServiceNotActiveException
* The specified service is not active. You can't update a service that is inactive. If you have previously
* deleted a service, you can re-create it with CreateService.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.DescribeTaskSets
* @see AWS API
* Documentation
*/
@Override
public DescribeTaskSetsResponse describeTaskSets(DescribeTaskSetsRequest describeTaskSetsRequest) throws ServerException,
ClientException, InvalidParameterException, ClusterNotFoundException, UnsupportedFeatureException,
AccessDeniedException, ServiceNotFoundException, ServiceNotActiveException, AwsServiceException, SdkClientException,
EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
DescribeTaskSetsResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("DescribeTaskSets").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(describeTaskSetsRequest)
.withMarshaller(new DescribeTaskSetsRequestMarshaller(protocolFactory)));
}
/**
*
* Describes a specified task or tasks.
*
*
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.DescribeTasks
* @see AWS API
* Documentation
*/
@Override
public DescribeTasksResponse describeTasks(DescribeTasksRequest describeTasksRequest) throws ServerException,
ClientException, InvalidParameterException, ClusterNotFoundException, AwsServiceException, SdkClientException,
EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
DescribeTasksResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("DescribeTasks").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(describeTasksRequest)
.withMarshaller(new DescribeTasksRequestMarshaller(protocolFactory)));
}
/**
*
*
* This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.
*
*
*
* Returns an endpoint for the Amazon ECS agent to poll for updates.
*
*
* @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 permissions to use the action or resource, or specifying an identifier that is not
* valid.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.DiscoverPollEndpoint
* @see AWS API
* Documentation
*/
@Override
public DiscoverPollEndpointResponse discoverPollEndpoint(DiscoverPollEndpointRequest discoverPollEndpointRequest)
throws ServerException, ClientException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DiscoverPollEndpointResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("DiscoverPollEndpoint").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(discoverPollEndpointRequest)
.withMarshaller(new DiscoverPollEndpointRequestMarshaller(protocolFactory)));
}
/**
*
* Lists the account settings for a specified principal.
*
*
* @param listAccountSettingsRequest
* @return Result of the ListAccountSettings 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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.ListAccountSettings
* @see AWS API
* Documentation
*/
@Override
public ListAccountSettingsResponse listAccountSettings(ListAccountSettingsRequest listAccountSettingsRequest)
throws ServerException, ClientException, InvalidParameterException, AwsServiceException, SdkClientException,
EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, ListAccountSettingsResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("ListAccountSettings").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(listAccountSettingsRequest)
.withMarshaller(new ListAccountSettingsRequestMarshaller(protocolFactory)));
}
/**
*
* Lists the attributes for Amazon ECS resources within a specified target type and cluster. When you specify a
* target type and cluster, ListAttributes 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 (ecs.os-type=linux).
*
*
* @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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.ListAttributes
* @see AWS API
* Documentation
*/
@Override
public ListAttributesResponse listAttributes(ListAttributesRequest listAttributesRequest) throws ClusterNotFoundException,
InvalidParameterException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
ListAttributesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("ListAttributes").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(listAttributesRequest)
.withMarshaller(new ListAttributesRequestMarshaller(protocolFactory)));
}
/**
*
* Returns a list of existing clusters.
*
*
* @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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.ListClusters
* @see AWS API
* Documentation
*/
@Override
public ListClustersResponse listClusters(ListClustersRequest listClustersRequest) throws ServerException, ClientException,
InvalidParameterException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
ListClustersResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("ListClusters").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(listClustersRequest)
.withMarshaller(new ListClustersRequestMarshaller(protocolFactory)));
}
/**
*
* Returns a list of existing clusters.
*
*
*
* This is a variant of {@link #listClusters(software.amazon.awssdk.services.ecs.model.ListClustersRequest)}
* operation. The return type is a custom iterable that can be used to iterate through all the pages. SDK will
* internally handle making service calls for you.
*
*
* When this operation is called, a custom iterable is returned but no service calls are made yet. So there is no
* guarantee that the request is valid. As you iterate through the iterable, SDK will start lazily loading response
* pages by making service calls until there are no pages left or your iteration stops. If there are errors in your
* request, you will see the failures only after you start iterating through the iterable.
*
*
*
* The following are few ways to iterate through the response pages:
*
* 1) Using a Stream
*
*
* {@code
* software.amazon.awssdk.services.ecs.paginators.ListClustersIterable responses = client.listClustersPaginator(request);
* responses.stream().forEach(....);
* }
*
*
* 2) Using For loop
*
*
* {
* @code
* software.amazon.awssdk.services.ecs.paginators.ListClustersIterable responses = client.listClustersPaginator(request);
* for (software.amazon.awssdk.services.ecs.model.ListClustersResponse response : responses) {
* // do something;
* }
* }
*
*
* 3) Use iterator directly
*
*
* {@code
* software.amazon.awssdk.services.ecs.paginators.ListClustersIterable responses = client.listClustersPaginator(request);
* responses.iterator().forEachRemaining(....);
* }
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listClusters(software.amazon.awssdk.services.ecs.model.ListClustersRequest)} operation.
*
*
* @param listClustersRequest
* @return A custom iterable that can be used to iterate through all the response pages.
* @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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.ListClusters
* @see AWS API
* Documentation
*/
@Override
public ListClustersIterable listClustersPaginator(ListClustersRequest listClustersRequest) throws ServerException,
ClientException, InvalidParameterException, AwsServiceException, SdkClientException, EcsException {
return new ListClustersIterable(this, applyPaginatorUserAgent(listClustersRequest));
}
/**
*
* Returns a list of container instances in a specified cluster. You can filter the results of a
* ListContainerInstances operation with cluster query language statements inside the
* filter parameter. For more information, see Cluster Query
* Language in the Amazon Elastic Container Service Developer Guide.
*
*
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.ListContainerInstances
* @see AWS API
* Documentation
*/
@Override
public ListContainerInstancesResponse listContainerInstances(ListContainerInstancesRequest listContainerInstancesRequest)
throws ServerException, ClientException, InvalidParameterException, ClusterNotFoundException, AwsServiceException,
SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, ListContainerInstancesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("ListContainerInstances").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(listContainerInstancesRequest)
.withMarshaller(new ListContainerInstancesRequestMarshaller(protocolFactory)));
}
/**
*
* Returns a list of container instances in a specified cluster. You can filter the results of a
* ListContainerInstances operation with cluster query language statements inside the
* filter parameter. For more information, see Cluster Query
* Language in the Amazon Elastic Container Service Developer Guide.
*
*
*
* This is a variant of
* {@link #listContainerInstances(software.amazon.awssdk.services.ecs.model.ListContainerInstancesRequest)}
* operation. The return type is a custom iterable that can be used to iterate through all the pages. SDK will
* internally handle making service calls for you.
*
*
* When this operation is called, a custom iterable is returned but no service calls are made yet. So there is no
* guarantee that the request is valid. As you iterate through the iterable, SDK will start lazily loading response
* pages by making service calls until there are no pages left or your iteration stops. If there are errors in your
* request, you will see the failures only after you start iterating through the iterable.
*
*
*
* The following are few ways to iterate through the response pages:
*
* 1) Using a Stream
*
*
* {@code
* software.amazon.awssdk.services.ecs.paginators.ListContainerInstancesIterable responses = client.listContainerInstancesPaginator(request);
* responses.stream().forEach(....);
* }
*
*
* 2) Using For loop
*
*
* {
* @code
* software.amazon.awssdk.services.ecs.paginators.ListContainerInstancesIterable responses = client
* .listContainerInstancesPaginator(request);
* for (software.amazon.awssdk.services.ecs.model.ListContainerInstancesResponse response : responses) {
* // do something;
* }
* }
*
*
* 3) Use iterator directly
*
*
* {@code
* software.amazon.awssdk.services.ecs.paginators.ListContainerInstancesIterable responses = client.listContainerInstancesPaginator(request);
* responses.iterator().forEachRemaining(....);
* }
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listContainerInstances(software.amazon.awssdk.services.ecs.model.ListContainerInstancesRequest)}
* operation.
*
*
* @param listContainerInstancesRequest
* @return A custom iterable that can be used to iterate through all the response pages.
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.ListContainerInstances
* @see AWS API
* Documentation
*/
@Override
public ListContainerInstancesIterable listContainerInstancesPaginator(
ListContainerInstancesRequest listContainerInstancesRequest) throws ServerException, ClientException,
InvalidParameterException, ClusterNotFoundException, AwsServiceException, SdkClientException, EcsException {
return new ListContainerInstancesIterable(this, applyPaginatorUserAgent(listContainerInstancesRequest));
}
/**
*
* Lists the services that are running in a specified cluster.
*
*
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.ListServices
* @see AWS API
* Documentation
*/
@Override
public ListServicesResponse listServices(ListServicesRequest listServicesRequest) throws ServerException, ClientException,
InvalidParameterException, ClusterNotFoundException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
ListServicesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("ListServices").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(listServicesRequest)
.withMarshaller(new ListServicesRequestMarshaller(protocolFactory)));
}
/**
*
* Lists the services that are running in a specified cluster.
*
*
*
* This is a variant of {@link #listServices(software.amazon.awssdk.services.ecs.model.ListServicesRequest)}
* operation. The return type is a custom iterable that can be used to iterate through all the pages. SDK will
* internally handle making service calls for you.
*
*
* When this operation is called, a custom iterable is returned but no service calls are made yet. So there is no
* guarantee that the request is valid. As you iterate through the iterable, SDK will start lazily loading response
* pages by making service calls until there are no pages left or your iteration stops. If there are errors in your
* request, you will see the failures only after you start iterating through the iterable.
*
*
*
* The following are few ways to iterate through the response pages:
*
* 1) Using a Stream
*
*
* {@code
* software.amazon.awssdk.services.ecs.paginators.ListServicesIterable responses = client.listServicesPaginator(request);
* responses.stream().forEach(....);
* }
*
*
* 2) Using For loop
*
*
* {
* @code
* software.amazon.awssdk.services.ecs.paginators.ListServicesIterable responses = client.listServicesPaginator(request);
* for (software.amazon.awssdk.services.ecs.model.ListServicesResponse response : responses) {
* // do something;
* }
* }
*
*
* 3) Use iterator directly
*
*
* {@code
* software.amazon.awssdk.services.ecs.paginators.ListServicesIterable responses = client.listServicesPaginator(request);
* responses.iterator().forEachRemaining(....);
* }
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listServices(software.amazon.awssdk.services.ecs.model.ListServicesRequest)} operation.
*
*
* @param listServicesRequest
* @return A custom iterable that can be used to iterate through all the response pages.
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.ListServices
* @see AWS API
* Documentation
*/
@Override
public ListServicesIterable listServicesPaginator(ListServicesRequest listServicesRequest) throws ServerException,
ClientException, InvalidParameterException, ClusterNotFoundException, AwsServiceException, SdkClientException,
EcsException {
return new ListServicesIterable(this, applyPaginatorUserAgent(listServicesRequest));
}
/**
*
* List the tags for an Amazon ECS resource.
*
*
* @param listTagsForResourceRequest
* @return Result of the ListTagsForResource 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 permissions to use the action or resource, or specifying an identifier that is not
* valid.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.ListTagsForResource
* @see AWS API
* Documentation
*/
@Override
public ListTagsForResourceResponse listTagsForResource(ListTagsForResourceRequest listTagsForResourceRequest)
throws ServerException, ClientException, ClusterNotFoundException, InvalidParameterException, AwsServiceException,
SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, ListTagsForResourceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("ListTagsForResource").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(listTagsForResourceRequest)
.withMarshaller(new ListTagsForResourceRequestMarshaller(protocolFactory)));
}
/**
*
* Returns a list of task definition families that are registered to your account (which may include task definition
* families that no longer have any ACTIVE task definition revisions).
*
*
* You can filter out task definition families that do not contain any ACTIVE task definition revisions
* by setting the status parameter to ACTIVE. You can also filter the results with the
* familyPrefix parameter.
*
*
* @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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.ListTaskDefinitionFamilies
* @see AWS
* API Documentation
*/
@Override
public ListTaskDefinitionFamiliesResponse listTaskDefinitionFamilies(
ListTaskDefinitionFamiliesRequest listTaskDefinitionFamiliesRequest) throws ServerException, ClientException,
InvalidParameterException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, ListTaskDefinitionFamiliesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler
.execute(new ClientExecutionParams()
.withOperationName("ListTaskDefinitionFamilies").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(listTaskDefinitionFamiliesRequest)
.withMarshaller(new ListTaskDefinitionFamiliesRequestMarshaller(protocolFactory)));
}
/**
*
* Returns a list of task definition families that are registered to your account (which may include task definition
* families that no longer have any ACTIVE task definition revisions).
*
*
* You can filter out task definition families that do not contain any ACTIVE task definition revisions
* by setting the status parameter to ACTIVE. You can also filter the results with the
* familyPrefix parameter.
*
*
*
* This is a variant of
* {@link #listTaskDefinitionFamilies(software.amazon.awssdk.services.ecs.model.ListTaskDefinitionFamiliesRequest)}
* operation. The return type is a custom iterable that can be used to iterate through all the pages. SDK will
* internally handle making service calls for you.
*
*
* When this operation is called, a custom iterable is returned but no service calls are made yet. So there is no
* guarantee that the request is valid. As you iterate through the iterable, SDK will start lazily loading response
* pages by making service calls until there are no pages left or your iteration stops. If there are errors in your
* request, you will see the failures only after you start iterating through the iterable.
*
*
*
* The following are few ways to iterate through the response pages:
*
* 1) Using a Stream
*
*
* {@code
* software.amazon.awssdk.services.ecs.paginators.ListTaskDefinitionFamiliesIterable responses = client.listTaskDefinitionFamiliesPaginator(request);
* responses.stream().forEach(....);
* }
*
*
* 2) Using For loop
*
*
* {
* @code
* software.amazon.awssdk.services.ecs.paginators.ListTaskDefinitionFamiliesIterable responses = client
* .listTaskDefinitionFamiliesPaginator(request);
* for (software.amazon.awssdk.services.ecs.model.ListTaskDefinitionFamiliesResponse response : responses) {
* // do something;
* }
* }
*
*
* 3) Use iterator directly
*
*
* {@code
* software.amazon.awssdk.services.ecs.paginators.ListTaskDefinitionFamiliesIterable responses = client.listTaskDefinitionFamiliesPaginator(request);
* responses.iterator().forEachRemaining(....);
* }
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listTaskDefinitionFamilies(software.amazon.awssdk.services.ecs.model.ListTaskDefinitionFamiliesRequest)}
* operation.
*
*
* @param listTaskDefinitionFamiliesRequest
* @return A custom iterable that can be used to iterate through all the response pages.
* @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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.ListTaskDefinitionFamilies
* @see AWS
* API Documentation
*/
@Override
public ListTaskDefinitionFamiliesIterable listTaskDefinitionFamiliesPaginator(
ListTaskDefinitionFamiliesRequest listTaskDefinitionFamiliesRequest) throws ServerException, ClientException,
InvalidParameterException, AwsServiceException, SdkClientException, EcsException {
return new ListTaskDefinitionFamiliesIterable(this, applyPaginatorUserAgent(listTaskDefinitionFamiliesRequest));
}
/**
*
* Returns a list of task definitions that are registered to your account. You can filter the results by family name
* with the familyPrefix parameter or by status with the status parameter.
*
*
* @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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.ListTaskDefinitions
* @see AWS API
* Documentation
*/
@Override
public ListTaskDefinitionsResponse listTaskDefinitions(ListTaskDefinitionsRequest listTaskDefinitionsRequest)
throws ServerException, ClientException, InvalidParameterException, AwsServiceException, SdkClientException,
EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, ListTaskDefinitionsResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("ListTaskDefinitions").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(listTaskDefinitionsRequest)
.withMarshaller(new ListTaskDefinitionsRequestMarshaller(protocolFactory)));
}
/**
*
* Returns a list of task definitions that are registered to your account. You can filter the results by family name
* with the familyPrefix parameter or by status with the status parameter.
*
*
*
* This is a variant of
* {@link #listTaskDefinitions(software.amazon.awssdk.services.ecs.model.ListTaskDefinitionsRequest)} operation. The
* return type is a custom iterable that can be used to iterate through all the pages. SDK will internally handle
* making service calls for you.
*
*
* When this operation is called, a custom iterable is returned but no service calls are made yet. So there is no
* guarantee that the request is valid. As you iterate through the iterable, SDK will start lazily loading response
* pages by making service calls until there are no pages left or your iteration stops. If there are errors in your
* request, you will see the failures only after you start iterating through the iterable.
*
*
*
* The following are few ways to iterate through the response pages:
*
* 1) Using a Stream
*
*
* {@code
* software.amazon.awssdk.services.ecs.paginators.ListTaskDefinitionsIterable responses = client.listTaskDefinitionsPaginator(request);
* responses.stream().forEach(....);
* }
*
*
* 2) Using For loop
*
*
* {
* @code
* software.amazon.awssdk.services.ecs.paginators.ListTaskDefinitionsIterable responses = client
* .listTaskDefinitionsPaginator(request);
* for (software.amazon.awssdk.services.ecs.model.ListTaskDefinitionsResponse response : responses) {
* // do something;
* }
* }
*
*
* 3) Use iterator directly
*
*
* {@code
* software.amazon.awssdk.services.ecs.paginators.ListTaskDefinitionsIterable responses = client.listTaskDefinitionsPaginator(request);
* responses.iterator().forEachRemaining(....);
* }
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listTaskDefinitions(software.amazon.awssdk.services.ecs.model.ListTaskDefinitionsRequest)} operation.
*
*
* @param listTaskDefinitionsRequest
* @return A custom iterable that can be used to iterate through all the response pages.
* @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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.ListTaskDefinitions
* @see AWS API
* Documentation
*/
@Override
public ListTaskDefinitionsIterable listTaskDefinitionsPaginator(ListTaskDefinitionsRequest listTaskDefinitionsRequest)
throws ServerException, ClientException, InvalidParameterException, AwsServiceException, SdkClientException,
EcsException {
return new ListTaskDefinitionsIterable(this, applyPaginatorUserAgent(listTaskDefinitionsRequest));
}
/**
*
* 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 family,
* containerInstance, and desiredStatus parameters.
*
*
* Recently stopped tasks might appear in the returned results. Currently, stopped tasks appear in the returned
* results for at least one hour.
*
*
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws ServiceNotFoundException
* The specified service could not be found. You can view your available services with ListServices.
* Amazon ECS services are cluster-specific and Region-specific.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.ListTasks
* @see AWS API
* Documentation
*/
@Override
public ListTasksResponse listTasks(ListTasksRequest listTasksRequest) throws ServerException, ClientException,
InvalidParameterException, ClusterNotFoundException, ServiceNotFoundException, AwsServiceException,
SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
ListTasksResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("ListTasks").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(listTasksRequest)
.withMarshaller(new ListTasksRequestMarshaller(protocolFactory)));
}
/**
*
* 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 family,
* containerInstance, and desiredStatus parameters.
*
*
* Recently stopped tasks might appear in the returned results. Currently, stopped tasks appear in the returned
* results for at least one hour.
*
*
*
* This is a variant of {@link #listTasks(software.amazon.awssdk.services.ecs.model.ListTasksRequest)} operation.
* The return type is a custom iterable that can be used to iterate through all the pages. SDK will internally
* handle making service calls for you.
*
*
* When this operation is called, a custom iterable is returned but no service calls are made yet. So there is no
* guarantee that the request is valid. As you iterate through the iterable, SDK will start lazily loading response
* pages by making service calls until there are no pages left or your iteration stops. If there are errors in your
* request, you will see the failures only after you start iterating through the iterable.
*
*
*
* The following are few ways to iterate through the response pages:
*
* 1) Using a Stream
*
*
* {@code
* software.amazon.awssdk.services.ecs.paginators.ListTasksIterable responses = client.listTasksPaginator(request);
* responses.stream().forEach(....);
* }
*
*
* 2) Using For loop
*
*
* {
* @code
* software.amazon.awssdk.services.ecs.paginators.ListTasksIterable responses = client.listTasksPaginator(request);
* for (software.amazon.awssdk.services.ecs.model.ListTasksResponse response : responses) {
* // do something;
* }
* }
*
*
* 3) Use iterator directly
*
*
* {@code
* software.amazon.awssdk.services.ecs.paginators.ListTasksIterable responses = client.listTasksPaginator(request);
* responses.iterator().forEachRemaining(....);
* }
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listTasks(software.amazon.awssdk.services.ecs.model.ListTasksRequest)} operation.
*
*
* @param listTasksRequest
* @return A custom iterable that can be used to iterate through all the response pages.
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws ServiceNotFoundException
* The specified service could not be found. You can view your available services with ListServices.
* Amazon ECS services are cluster-specific and Region-specific.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.ListTasks
* @see AWS API
* Documentation
*/
@Override
public ListTasksIterable listTasksPaginator(ListTasksRequest listTasksRequest) throws ServerException, ClientException,
InvalidParameterException, ClusterNotFoundException, ServiceNotFoundException, AwsServiceException,
SdkClientException, EcsException {
return new ListTasksIterable(this, applyPaginatorUserAgent(listTasksRequest));
}
/**
*
* Modifies an account setting. Account settings are set on a per-Region basis.
*
*
* If you change the account setting for the root user, the default settings for all of the IAM users and roles for
* which no individual account setting has been specified are reset. For more information, see Account Settings
* in the Amazon Elastic Container Service Developer Guide.
*
*
* When serviceLongArnFormat, taskLongArnFormat, or
* containerInstanceLongArnFormat are specified, the Amazon Resource Name (ARN) and resource ID format
* of the resource type for a specified IAM user, IAM role, or the root user for an account is affected. The opt-in
* and opt-out account setting must be set for each Amazon ECS resource separately. The ARN and resource ID format
* of a resource will be defined by the opt-in status of the IAM user or role that created the resource. You must
* enable this setting to use Amazon ECS features such as resource tagging.
*
*
* When awsvpcTrunking is specified, the elastic network interface (ENI) limit for any new container
* instances that support the feature is changed. If awsvpcTrunking is enabled, any new container
* instances that support the feature are launched have the increased ENI limits available to them. For more
* information, see Elastic Network
* Interface Trunking in the Amazon Elastic Container Service Developer Guide.
*
*
* When containerInsights is specified, the default setting indicating whether CloudWatch Container
* Insights is enabled for your clusters is changed. If containerInsights is enabled, any new clusters
* that are created will have Container Insights enabled unless you disable it during cluster creation. For more
* information, see CloudWatch
* Container Insights in the Amazon Elastic Container Service Developer Guide.
*
*
* @param putAccountSettingRequest
* @return Result of the PutAccountSetting 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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.PutAccountSetting
* @see AWS API
* Documentation
*/
@Override
public PutAccountSettingResponse putAccountSetting(PutAccountSettingRequest putAccountSettingRequest) throws ServerException,
ClientException, InvalidParameterException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
PutAccountSettingResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("PutAccountSetting").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(putAccountSettingRequest)
.withMarshaller(new PutAccountSettingRequestMarshaller(protocolFactory)));
}
/**
*
* Modifies an account setting for all IAM users on an account for whom no individual account setting has been
* specified. Account settings are set on a per-Region basis.
*
*
* @param putAccountSettingDefaultRequest
* @return Result of the PutAccountSettingDefault 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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.PutAccountSettingDefault
* @see AWS
* API Documentation
*/
@Override
public PutAccountSettingDefaultResponse putAccountSettingDefault(
PutAccountSettingDefaultRequest putAccountSettingDefaultRequest) throws ServerException, ClientException,
InvalidParameterException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, PutAccountSettingDefaultResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler
.execute(new ClientExecutionParams()
.withOperationName("PutAccountSettingDefault").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(putAccountSettingDefaultRequest)
.withMarshaller(new PutAccountSettingDefaultRequestMarshaller(protocolFactory)));
}
/**
*
* 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
* DeleteAttributes. For more information, see Attributes in the Amazon Elastic Container Service Developer Guide.
*
*
* @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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws TargetNotFoundException
* The specified target could not be found. You can view your available container instances with
* ListContainerInstances. 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
* ListAttributes. You can remove existing attributes on a resource with DeleteAttributes.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.PutAttributes
* @see AWS API
* Documentation
*/
@Override
public PutAttributesResponse putAttributes(PutAttributesRequest putAttributesRequest) throws ClusterNotFoundException,
TargetNotFoundException, AttributeLimitExceededException, InvalidParameterException, AwsServiceException,
SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
PutAttributesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("PutAttributes").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(putAttributesRequest)
.withMarshaller(new PutAttributesRequestMarshaller(protocolFactory)));
}
/**
*
*
* This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.
*
*
*
* Registers an EC2 instance into the specified cluster. This instance becomes available to place containers on.
*
*
* @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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.RegisterContainerInstance
* @see AWS
* API Documentation
*/
@Override
public RegisterContainerInstanceResponse registerContainerInstance(
RegisterContainerInstanceRequest registerContainerInstanceRequest) throws ServerException, ClientException,
InvalidParameterException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, RegisterContainerInstanceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler
.execute(new ClientExecutionParams()
.withOperationName("RegisterContainerInstance").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(registerContainerInstanceRequest)
.withMarshaller(new RegisterContainerInstanceRequestMarshaller(protocolFactory)));
}
/**
*
* Registers a new task definition from the supplied family and containerDefinitions.
* Optionally, you can add data volumes to your containers with the volumes parameter. For more
* information about task definition parameters and defaults, see Amazon ECS Task
* Definitions in the Amazon Elastic Container Service Developer Guide.
*
*
* You can specify an IAM role for your task with the taskRoleArn 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 IAM Roles for Tasks in
* the Amazon Elastic Container Service Developer Guide.
*
*
* You can specify a Docker networking mode for the containers in your task definition with the
* networkMode parameter. The available network modes correspond to those described in Network settings in the Docker run
* reference. If you specify the awsvpc network mode, the task is allocated an elastic network
* interface, and you must specify a NetworkConfiguration when you create a service or run a task with the
* task definition. For more information, see Task Networking in
* the Amazon Elastic Container Service Developer Guide.
*
*
* @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 permissions 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 SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.RegisterTaskDefinition
* @see AWS API
* Documentation
*/
@Override
public RegisterTaskDefinitionResponse registerTaskDefinition(RegisterTaskDefinitionRequest registerTaskDefinitionRequest)
throws ServerException, ClientException, InvalidParameterException, AwsServiceException, SdkClientException,
EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, RegisterTaskDefinitionResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("RegisterTaskDefinition").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(registerTaskDefinitionRequest)
.withMarshaller(new RegisterTaskDefinitionRequestMarshaller(protocolFactory)));
}
/**
*
* Starts a new task using the specified task definition.
*
*
* 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 Scheduling Tasks in
* the Amazon Elastic Container Service Developer Guide.
*
*
* Alternatively, you can use StartTask to use your own scheduler or place tasks manually on specific
* container instances.
*
*
* The Amazon ECS API follows an eventual consistency model, due to the distributed nature of the system supporting
* the API. This means that the result of an API command you run that affects your Amazon ECS resources might not be
* immediately visible to all subsequent commands you run. Keep this in mind when you carry out an API command that
* immediately follows a previous API command.
*
*
* To manage eventual consistency, you can do the following:
*
*
* -
*
* Confirm the state of the resource before you run a command to modify it. Run the DescribeTasks command using an
* exponential backoff algorithm to ensure that you allow enough time for the previous command to propagate through
* the system. To do this, run the DescribeTasks command repeatedly, starting with a couple of seconds of wait time
* and increasing gradually up to five minutes of wait time.
*
*
* -
*
* Add wait time between subsequent commands, even if the DescribeTasks command returns an accurate response. Apply
* an exponential backoff algorithm starting with a couple of seconds of wait time, and increase gradually up to
* about five minutes of wait time.
*
*
*
*
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws UnsupportedFeatureException
* The specified task is not supported in this Region.
* @throws PlatformUnknownException
* The specified platform version does not exist.
* @throws PlatformTaskDefinitionIncompatibilityException
* The specified platform version does not satisfy the task definition's required capabilities.
* @throws AccessDeniedException
* You do not have authorization to perform the requested action.
* @throws BlockedException
* Your AWS account has been blocked. For more information, contact AWS Support.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.RunTask
* @see AWS API
* Documentation
*/
@Override
public RunTaskResponse runTask(RunTaskRequest runTaskRequest) throws ServerException, ClientException,
InvalidParameterException, ClusterNotFoundException, UnsupportedFeatureException, PlatformUnknownException,
PlatformTaskDefinitionIncompatibilityException, AccessDeniedException, BlockedException, AwsServiceException,
SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
RunTaskResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams().withOperationName("RunTask")
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler).withInput(runTaskRequest)
.withMarshaller(new RunTaskRequestMarshaller(protocolFactory)));
}
/**
*
* Starts a new task from the specified task definition on the specified container instance or instances.
*
*
* Alternatively, you can use RunTask to place tasks for you. For more information, see Scheduling Tasks in
* the Amazon Elastic Container Service Developer Guide.
*
*
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.StartTask
* @see AWS API
* Documentation
*/
@Override
public StartTaskResponse startTask(StartTaskRequest startTaskRequest) throws ServerException, ClientException,
InvalidParameterException, ClusterNotFoundException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
StartTaskResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("StartTask").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(startTaskRequest)
.withMarshaller(new StartTaskRequestMarshaller(protocolFactory)));
}
/**
*
* Stops a running task. Any tags associated with the task will be deleted.
*
*
* When StopTask is called on a task, the equivalent of docker stop is issued to the containers
* running in the task. This results in a SIGTERM value and a default 30-second timeout, after which
* the SIGKILL value is sent and the containers are forcibly stopped. If the container handles the
* SIGTERM value gracefully and exits within 30 seconds from receiving it, no SIGKILL
* value is sent.
*
*
*
* The default 30-second timeout can be configured on the Amazon ECS container agent with the
* ECS_CONTAINER_STOP_TIMEOUT variable. For more information, see Amazon ECS Container
* Agent Configuration in the Amazon Elastic Container Service Developer Guide.
*
*
*
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.StopTask
* @see AWS API
* Documentation
*/
@Override
public StopTaskResponse stopTask(StopTaskRequest stopTaskRequest) throws ServerException, ClientException,
InvalidParameterException, ClusterNotFoundException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
StopTaskResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams().withOperationName("StopTask")
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler).withInput(stopTaskRequest)
.withMarshaller(new StopTaskRequestMarshaller(protocolFactory)));
}
/**
*
*
* This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.
*
*
*
* Sent to acknowledge that an attachment changed states.
*
*
* @param submitAttachmentStateChangesRequest
* @return Result of the SubmitAttachmentStateChanges 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 permissions to use the action or resource, or specifying an identifier that is not
* valid.
* @throws AccessDeniedException
* You do not have authorization to perform the requested action.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.SubmitAttachmentStateChanges
* @see AWS API Documentation
*/
@Override
public SubmitAttachmentStateChangesResponse submitAttachmentStateChanges(
SubmitAttachmentStateChangesRequest submitAttachmentStateChangesRequest) throws ServerException, ClientException,
AccessDeniedException, InvalidParameterException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, SubmitAttachmentStateChangesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler
.execute(new ClientExecutionParams()
.withOperationName("SubmitAttachmentStateChanges").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(submitAttachmentStateChangesRequest)
.withMarshaller(new SubmitAttachmentStateChangesRequestMarshaller(protocolFactory)));
}
/**
*
*
* This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.
*
*
*
* Sent to acknowledge that a container changed states.
*
*
* @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 permissions to use the action or resource, or specifying an identifier that is not
* valid.
* @throws AccessDeniedException
* You do not have authorization to perform the requested action.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.SubmitContainerStateChange
* @see AWS
* API Documentation
*/
@Override
public SubmitContainerStateChangeResponse submitContainerStateChange(
SubmitContainerStateChangeRequest submitContainerStateChangeRequest) throws ServerException, ClientException,
AccessDeniedException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, SubmitContainerStateChangeResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler
.execute(new ClientExecutionParams()
.withOperationName("SubmitContainerStateChange").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(submitContainerStateChangeRequest)
.withMarshaller(new SubmitContainerStateChangeRequestMarshaller(protocolFactory)));
}
/**
*
*
* This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.
*
*
*
* Sent to acknowledge that a task changed states.
*
*
* @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 permissions to use the action or resource, or specifying an identifier that is not
* valid.
* @throws AccessDeniedException
* You do not have authorization to perform the requested action.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.SubmitTaskStateChange
* @see AWS API
* Documentation
*/
@Override
public SubmitTaskStateChangeResponse submitTaskStateChange(SubmitTaskStateChangeRequest submitTaskStateChangeRequest)
throws ServerException, ClientException, AccessDeniedException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, SubmitTaskStateChangeResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("SubmitTaskStateChange").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(submitTaskStateChangeRequest)
.withMarshaller(new SubmitTaskStateChangeRequestMarshaller(protocolFactory)));
}
/**
*
* Associates the specified tags to a resource with the specified resourceArn. If existing tags on a
* resource are not specified in the request parameters, they are not changed. When a resource is deleted, the tags
* associated with that resource are deleted as well.
*
*
* @param tagResourceRequest
* @return Result of the TagResource 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 permissions to use the action or resource, or specifying an identifier that is not
* valid.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws ResourceNotFoundException
* The specified resource could not be found.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.TagResource
* @see AWS API
* Documentation
*/
@Override
public TagResourceResponse tagResource(TagResourceRequest tagResourceRequest) throws ServerException, ClientException,
ClusterNotFoundException, ResourceNotFoundException, InvalidParameterException, AwsServiceException,
SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
TagResourceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("TagResource").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(tagResourceRequest)
.withMarshaller(new TagResourceRequestMarshaller(protocolFactory)));
}
/**
*
* Deletes specified tags from a resource.
*
*
* @param untagResourceRequest
* @return Result of the UntagResource 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 permissions to use the action or resource, or specifying an identifier that is not
* valid.
* @throws ClusterNotFoundException
* The specified cluster could not be found. You can view your available clusters with ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws ResourceNotFoundException
* The specified resource could not be found.
* @throws InvalidParameterException
* The specified parameter is invalid. Review the available parameters for the API request.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.UntagResource
* @see AWS API
* Documentation
*/
@Override
public UntagResourceResponse untagResource(UntagResourceRequest untagResourceRequest) throws ServerException,
ClientException, ClusterNotFoundException, ResourceNotFoundException, InvalidParameterException, AwsServiceException,
SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
UntagResourceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("UntagResource").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(untagResourceRequest)
.withMarshaller(new UntagResourceRequestMarshaller(protocolFactory)));
}
/**
*
* 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.
*
*
* UpdateContainerAgent requires the Amazon ECS-optimized AMI or Amazon Linux with the
* ecs-init service installed and running. For help updating the Amazon ECS container agent on other
* operating systems, see Manually Updating the Amazon ECS Container Agent in the Amazon Elastic Container Service Developer
* Guide.
*
*
* @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 permissions 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 ListClusters.
* 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
* PENDING or STAGING, 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.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.UpdateContainerAgent
* @see AWS API
* Documentation
*/
@Override
public UpdateContainerAgentResponse updateContainerAgent(UpdateContainerAgentRequest updateContainerAgentRequest)
throws ServerException, ClientException, InvalidParameterException, ClusterNotFoundException,
UpdateInProgressException, NoUpdateAvailableException, MissingVersionException, AwsServiceException,
SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, UpdateContainerAgentResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("UpdateContainerAgent").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(updateContainerAgentRequest)
.withMarshaller(new UpdateContainerAgentRequestMarshaller(protocolFactory)));
}
/**
*
* Modifies the status of an Amazon ECS container instance.
*
*
* Once a container instance has reached an ACTIVE state, you can change the status of a container
* instance to DRAINING to manually remove an instance from a cluster, for example to perform system
* updates, update the Docker daemon, or scale down the cluster size.
*
*
*
* A container instance cannot be changed to DRAINING until it has reached an ACTIVE
* status. If the instance is in any other status, an error will be received.
*
*
*
* When you set a container instance to DRAINING, 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
* PENDING state are stopped immediately.
*
*
* Service tasks on the container instance that are in the RUNNING state are stopped and replaced
* according to the service's deployment configuration parameters, minimumHealthyPercent and
* maximumPercent. You can change the deployment configuration of your service using
* UpdateService.
*
*
* -
*
* If minimumHealthyPercent is below 100%, the scheduler can ignore desiredCount
* temporarily during task replacement. For example, desiredCount 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 RUNNING state.
* Tasks for services that use a load balancer are considered healthy if they are in the RUNNING state
* and the container instance they are hosted on is reported as healthy by the load balancer.
*
*
* -
*
* The maximumPercent 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 desiredCount is
* 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.
*
*
*
*
* Any PENDING or RUNNING tasks that do not belong to a service are not affected. You must
* wait for them to finish or stop them manually.
*
*
* A container instance has completed draining when it has no more RUNNING tasks. You can verify this
* using ListTasks.
*
*
* When a container instance has been drained, you can set a container instance to ACTIVE status and
* once it has reached that status the Amazon ECS scheduler can begin scheduling tasks on the instance again.
*
*
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.UpdateContainerInstancesState
* @see AWS API Documentation
*/
@Override
public UpdateContainerInstancesStateResponse updateContainerInstancesState(
UpdateContainerInstancesStateRequest updateContainerInstancesStateRequest) throws ServerException, ClientException,
InvalidParameterException, ClusterNotFoundException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, UpdateContainerInstancesStateResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler
.execute(new ClientExecutionParams()
.withOperationName("UpdateContainerInstancesState").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(updateContainerInstancesStateRequest)
.withMarshaller(new UpdateContainerInstancesStateRequestMarshaller(protocolFactory)));
}
/**
*
* Modifies the parameters of a service.
*
*
* For services using the rolling update (ECS) deployment controller, the desired count, deployment
* configuration, network configuration, or task definition used can be updated.
*
*
* For services using the blue/green (CODE_DEPLOY) deployment controller, only the desired count,
* deployment configuration, and health check grace period can be updated using this API. If the network
* configuration, platform version, or task definition need to be updated, a new AWS CodeDeploy deployment should be
* created. For more information, see CreateDeployment
* in the AWS CodeDeploy API Reference.
*
*
* For services using an external deployment controller, you can update only the desired count and health check
* grace period using this API. If the launch type, load balancer, network configuration, platform version, or task
* definition need to be updated, you should create a new task set. For more information, see CreateTaskSet.
*
*
* You can add to or subtract from the number of instantiations of a task definition in a service by specifying the
* cluster that the service is running in and a new desiredCount parameter.
*
*
* If you have updated the Docker image of your application, you can create a new task definition with that image
* and deploy it to your service. The service scheduler uses the minimum healthy percent and maximum percent
* parameters (in the service's deployment configuration) to determine the deployment strategy.
*
*
*
* If your updated Docker image uses the same tag as what is in the existing task definition for your service (for
* example, my_image:latest), you do not need to create a new revision of your task definition. You can
* update the service using the forceNewDeployment option. The new tasks launched by the deployment
* pull the current image/tag combination from your repository when they start.
*
*
*
* 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,
* minimumHealthyPercent and maximumPercent, to determine the deployment strategy.
*
*
* -
*
* If minimumHealthyPercent is below 100%, the scheduler can ignore desiredCount
* temporarily during a deployment. For example, if desiredCount 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 RUNNING state. Tasks for services that use a load
* balancer are considered healthy if they are in the RUNNING state and the container instance they are
* hosted on is reported as healthy by the load balancer.
*
*
* -
*
* The maximumPercent 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 desiredCount 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).
*
*
*
*
* When UpdateService stops a task during a deployment, the equivalent of docker stop is issued
* to the containers running in the task. This results in a SIGTERM and a 30-second timeout, after
* which SIGKILL is sent and the containers are forcibly stopped. If the container handles the
* SIGTERM gracefully and exits within 30 seconds from receiving it, no SIGKILL is sent.
*
*
* When the service scheduler launches new tasks, it determines task placement in your cluster with the following
* logic:
*
*
* -
*
* 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).
*
*
* -
*
* By default, the service scheduler attempts to balance tasks across Availability Zones in this manner (although
* you can choose a different placement strategy):
*
*
* -
*
* 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.
*
*
* -
*
* 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.
*
*
*
*
*
*
* When the service scheduler stops running tasks, it attempts to maintain balance across the Availability Zones in
* your cluster using the following logic:
*
*
* -
*
* 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.
*
*
* -
*
* 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.
*
*
*
*
* @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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws ServiceNotFoundException
* The specified service could not be found. You can view your available services with ListServices.
* Amazon ECS services are cluster-specific and Region-specific.
* @throws ServiceNotActiveException
* The specified service is not active. You can't update a service that is inactive. If you have previously
* deleted a service, you can re-create it with CreateService.
* @throws PlatformUnknownException
* The specified platform version does not exist.
* @throws PlatformTaskDefinitionIncompatibilityException
* The specified platform version does not satisfy the task definition's required capabilities.
* @throws AccessDeniedException
* You do not have authorization to perform the requested action.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.UpdateService
* @see AWS API
* Documentation
*/
@Override
public UpdateServiceResponse updateService(UpdateServiceRequest updateServiceRequest) throws ServerException,
ClientException, InvalidParameterException, ClusterNotFoundException, ServiceNotFoundException,
ServiceNotActiveException, PlatformUnknownException, PlatformTaskDefinitionIncompatibilityException,
AccessDeniedException, AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
UpdateServiceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("UpdateService").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(updateServiceRequest)
.withMarshaller(new UpdateServiceRequestMarshaller(protocolFactory)));
}
/**
*
* Modifies which task set in a service is the primary task set. Any parameters that are updated on the primary task
* set in a service will transition to the service. This is used when a service uses the EXTERNAL
* deployment controller type. For more information, see Amazon ECS Deployment
* Types in the Amazon Elastic Container Service Developer Guide.
*
*
* @param updateServicePrimaryTaskSetRequest
* @return Result of the UpdateServicePrimaryTaskSet 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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws UnsupportedFeatureException
* The specified task is not supported in this Region.
* @throws AccessDeniedException
* You do not have authorization to perform the requested action.
* @throws ServiceNotFoundException
* The specified service could not be found. You can view your available services with ListServices.
* Amazon ECS services are cluster-specific and Region-specific.
* @throws ServiceNotActiveException
* The specified service is not active. You can't update a service that is inactive. If you have previously
* deleted a service, you can re-create it with CreateService.
* @throws TaskSetNotFoundException
* The specified task set could not be found. You can view your available container instances with
* DescribeTaskSets. Task sets are specific to each cluster, service and Region.
* @throws AccessDeniedException
* You do not have authorization to perform the requested action.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.UpdateServicePrimaryTaskSet
* @see AWS API Documentation
*/
@Override
public UpdateServicePrimaryTaskSetResponse updateServicePrimaryTaskSet(
UpdateServicePrimaryTaskSetRequest updateServicePrimaryTaskSetRequest) throws ServerException, ClientException,
InvalidParameterException, ClusterNotFoundException, UnsupportedFeatureException, AccessDeniedException,
ServiceNotFoundException, ServiceNotActiveException, TaskSetNotFoundException, AwsServiceException,
SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, UpdateServicePrimaryTaskSetResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler
.execute(new ClientExecutionParams()
.withOperationName("UpdateServicePrimaryTaskSet").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(updateServicePrimaryTaskSetRequest)
.withMarshaller(new UpdateServicePrimaryTaskSetRequestMarshaller(protocolFactory)));
}
/**
*
* Modifies a task set. This is used when a service uses the EXTERNAL deployment controller type. For
* more information, see Amazon ECS Deployment
* Types in the Amazon Elastic Container Service Developer Guide.
*
*
* @param updateTaskSetRequest
* @return Result of the UpdateTaskSet 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 permissions 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 ListClusters.
* Amazon ECS clusters are Region-specific.
* @throws UnsupportedFeatureException
* The specified task is not supported in this Region.
* @throws AccessDeniedException
* You do not have authorization to perform the requested action.
* @throws ServiceNotFoundException
* The specified service could not be found. You can view your available services with ListServices.
* Amazon ECS services are cluster-specific and Region-specific.
* @throws ServiceNotActiveException
* The specified service is not active. You can't update a service that is inactive. If you have previously
* deleted a service, you can re-create it with CreateService.
* @throws TaskSetNotFoundException
* The specified task set could not be found. You can view your available container instances with
* DescribeTaskSets. Task sets are specific to each cluster, service and Region.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws EcsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample EcsClient.UpdateTaskSet
* @see AWS API
* Documentation
*/
@Override
public UpdateTaskSetResponse updateTaskSet(UpdateTaskSetRequest updateTaskSetRequest) throws ServerException,
ClientException, InvalidParameterException, ClusterNotFoundException, UnsupportedFeatureException,
AccessDeniedException, ServiceNotFoundException, ServiceNotActiveException, TaskSetNotFoundException,
AwsServiceException, SdkClientException, EcsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
UpdateTaskSetResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("UpdateTaskSet").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(updateTaskSetRequest)
.withMarshaller(new UpdateTaskSetRequestMarshaller(protocolFactory)));
}
private HttpResponseHandler createErrorResponseHandler(BaseAwsJsonProtocolFactory protocolFactory,
JsonOperationMetadata operationMetadata) {
return protocolFactory.createErrorResponseHandler(operationMetadata);
}
private > T init(T builder) {
return builder
.clientConfiguration(clientConfiguration)
.defaultServiceExceptionSupplier(EcsException::builder)
.protocol(AwsJsonProtocol.AWS_JSON)
.protocolVersion("1.1")
.registerModeledException(
ExceptionMetadata.builder().errorCode("BlockedException")
.exceptionBuilderSupplier(BlockedException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ClusterContainsServicesException")
.exceptionBuilderSupplier(ClusterContainsServicesException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("UnsupportedFeatureException")
.exceptionBuilderSupplier(UnsupportedFeatureException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ClusterNotFoundException")
.exceptionBuilderSupplier(ClusterNotFoundException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ResourceNotFoundException")
.exceptionBuilderSupplier(ResourceNotFoundException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ClientException")
.exceptionBuilderSupplier(ClientException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("PlatformUnknownException")
.exceptionBuilderSupplier(PlatformUnknownException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("UpdateInProgressException")
.exceptionBuilderSupplier(UpdateInProgressException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ClusterContainsTasksException")
.exceptionBuilderSupplier(ClusterContainsTasksException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("InvalidParameterException")
.exceptionBuilderSupplier(InvalidParameterException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("NoUpdateAvailableException")
.exceptionBuilderSupplier(NoUpdateAvailableException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("PlatformTaskDefinitionIncompatibilityException")
.exceptionBuilderSupplier(PlatformTaskDefinitionIncompatibilityException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("MissingVersionException")
.exceptionBuilderSupplier(MissingVersionException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ClusterContainsContainerInstancesException")
.exceptionBuilderSupplier(ClusterContainsContainerInstancesException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ServiceNotFoundException")
.exceptionBuilderSupplier(ServiceNotFoundException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("TaskSetNotFoundException")
.exceptionBuilderSupplier(TaskSetNotFoundException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("AttributeLimitExceededException")
.exceptionBuilderSupplier(AttributeLimitExceededException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("AccessDeniedException")
.exceptionBuilderSupplier(AccessDeniedException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ServiceNotActiveException")
.exceptionBuilderSupplier(ServiceNotActiveException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ServerException")
.exceptionBuilderSupplier(ServerException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("TargetNotFoundException")
.exceptionBuilderSupplier(TargetNotFoundException::builder).build());
}
@Override
public void close() {
clientHandler.close();
}
private T applyPaginatorUserAgent(T request) {
Consumer userAgentApplier = b -> b.addApiName(ApiName.builder()
.version(VersionInfo.SDK_VERSION).name("PAGINATED").build());
AwsRequestOverrideConfiguration overrideConfiguration = request.overrideConfiguration()
.map(c -> c.toBuilder().applyMutation(userAgentApplier).build())
.orElse((AwsRequestOverrideConfiguration.builder().applyMutation(userAgentApplier).build()));
return (T) request.toBuilder().overrideConfiguration(overrideConfiguration).build();
}
}