748 lines
30 KiB
Python
748 lines
30 KiB
Python
# Copyright (c) 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining a
|
|
# copy of this software and associated documentation files (the
|
|
# "Software"), to deal in the Software without restriction, including
|
|
# without limitation the rights to use, copy, modify, merge, publish, dis-
|
|
# tribute, sublicense, and/or sell copies of the Software, and to permit
|
|
# persons to whom the Software is furnished to do so, subject to the fol-
|
|
# lowing conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be included
|
|
# in all copies or substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
|
|
# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
|
# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
# IN THE SOFTWARE.
|
|
#
|
|
|
|
import boto
|
|
from boto.compat import json
|
|
from boto.connection import AWSQueryConnection
|
|
from boto.regioninfo import RegionInfo
|
|
from boto.exception import JSONResponseError
|
|
from boto.ec2containerservice import exceptions
|
|
|
|
|
|
class EC2ContainerServiceConnection(AWSQueryConnection):
|
|
"""
|
|
Amazon EC2 Container Service (Amazon ECS) is a highly scalable,
|
|
fast, container management service that makes it easy to run,
|
|
stop, and manage Docker containers on a cluster of Amazon EC2
|
|
instances. Amazon ECS lets you launch and stop container-enabled
|
|
applications with simple API calls, allows you to get the state of
|
|
your cluster from a centralized service, and gives you access to
|
|
many familiar Amazon EC2 features like security groups, Amazon EBS
|
|
volumes, and IAM roles.
|
|
|
|
You can use Amazon ECS to schedule the placement of containers
|
|
across your cluster based on your resource needs, isolation
|
|
policies, and availability requirements. Amazon EC2 Container
|
|
Service eliminates the need for you to operate your own cluster
|
|
management and configuration management systems or worry about
|
|
scaling your management infrastructure.
|
|
"""
|
|
APIVersion = "2014-11-13"
|
|
DefaultRegionName = "us-east-1"
|
|
DefaultRegionEndpoint = "ecs.us-east-1.amazonaws.com"
|
|
ResponseError = JSONResponseError
|
|
|
|
_faults = {
|
|
"ServerException": exceptions.ServerException,
|
|
"ClientException": exceptions.ClientException,
|
|
}
|
|
|
|
|
|
def __init__(self, **kwargs):
|
|
region = kwargs.pop('region', None)
|
|
if not region:
|
|
region = RegionInfo(self, self.DefaultRegionName,
|
|
self.DefaultRegionEndpoint)
|
|
|
|
if 'host' not in kwargs or kwargs['host'] is None:
|
|
kwargs['host'] = region.endpoint
|
|
|
|
super(EC2ContainerServiceConnection, self).__init__(**kwargs)
|
|
self.region = region
|
|
|
|
def _required_auth_capability(self):
|
|
return ['hmac-v4']
|
|
|
|
def create_cluster(self, cluster_name=None):
|
|
"""
|
|
Creates a new Amazon ECS cluster. By default, your account
|
|
will receive a `default` cluster when you launch your first
|
|
container instance. However, you can create your own cluster
|
|
with a unique name with the `CreateCluster` action.
|
|
|
|
During the preview, each account is limited to two clusters.
|
|
|
|
:type cluster_name: string
|
|
:param cluster_name: The name of your cluster. If you do not specify a
|
|
name for your cluster, you will create a cluster named `default`.
|
|
|
|
"""
|
|
params = {}
|
|
if cluster_name is not None:
|
|
params['clusterName'] = cluster_name
|
|
return self._make_request(
|
|
action='CreateCluster',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def delete_cluster(self, cluster):
|
|
"""
|
|
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.
|
|
|
|
:type cluster: string
|
|
:param cluster: The cluster you want to delete.
|
|
|
|
"""
|
|
params = {'cluster': cluster, }
|
|
return self._make_request(
|
|
action='DeleteCluster',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def deregister_container_instance(self, container_instance, cluster=None,
|
|
force=None):
|
|
"""
|
|
Deregisters an Amazon ECS container instance from the
|
|
specified cluster. This instance will no longer be available
|
|
to run tasks.
|
|
|
|
:type cluster: string
|
|
:param cluster: The short name or full Amazon Resource Name (ARN) of
|
|
the cluster that hosts the container instance you want to
|
|
deregister. If you do not specify a cluster, the default cluster is
|
|
assumed.
|
|
|
|
:type container_instance: string
|
|
:param container_instance: The container instance UUID or full Amazon
|
|
Resource Name (ARN) of the container instance you want to
|
|
deregister. The ARN contains the `arn:aws:ecs` namespace, followed
|
|
by the region of the container instance, the AWS account ID of the
|
|
container instance owner, the `container-instance` namespace, and
|
|
then the container instance UUID. For example, arn:aws:ecs: region
|
|
: aws_account_id :container-instance/ container_instance_UUID .
|
|
|
|
:type force: boolean
|
|
:param force: Force the deregistration of the container instance. You
|
|
can use the `force` parameter if you have several tasks running on
|
|
a container instance and you don't want to run `StopTask` for each
|
|
task before deregistering the container instance.
|
|
|
|
"""
|
|
params = {'containerInstance': container_instance, }
|
|
if cluster is not None:
|
|
params['cluster'] = cluster
|
|
if force is not None:
|
|
params['force'] = str(
|
|
force).lower()
|
|
return self._make_request(
|
|
action='DeregisterContainerInstance',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def deregister_task_definition(self, task_definition):
|
|
"""
|
|
Deregisters the specified task definition. You will no longer
|
|
be able to run tasks from this definition after
|
|
deregistration.
|
|
|
|
:type task_definition: string
|
|
:param task_definition: The `family` and `revision` (
|
|
`family:revision`) or full Amazon Resource Name (ARN) of the task
|
|
definition that you want to deregister.
|
|
|
|
"""
|
|
params = {'taskDefinition': task_definition, }
|
|
return self._make_request(
|
|
action='DeregisterTaskDefinition',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def describe_clusters(self, clusters=None):
|
|
"""
|
|
Describes one or more of your clusters.
|
|
|
|
:type clusters: list
|
|
:param clusters: A space-separated list of cluster names or full
|
|
cluster Amazon Resource Name (ARN) entries. If you do not specify a
|
|
cluster, the default cluster is assumed.
|
|
|
|
"""
|
|
params = {}
|
|
if clusters is not None:
|
|
self.build_list_params(params,
|
|
clusters,
|
|
'clusters.member')
|
|
return self._make_request(
|
|
action='DescribeClusters',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def describe_container_instances(self, container_instances, cluster=None):
|
|
"""
|
|
Describes Amazon EC2 Container Service container instances.
|
|
Returns metadata about registered and remaining resources on
|
|
each container instance requested.
|
|
|
|
:type cluster: string
|
|
:param cluster: The short name or full Amazon Resource Name (ARN) of
|
|
the cluster that hosts the container instances you want to
|
|
describe. If you do not specify a cluster, the default cluster is
|
|
assumed.
|
|
|
|
:type container_instances: list
|
|
:param container_instances: A space-separated list of container
|
|
instance UUIDs or full Amazon Resource Name (ARN) entries.
|
|
|
|
"""
|
|
params = {}
|
|
self.build_list_params(params,
|
|
container_instances,
|
|
'containerInstances.member')
|
|
if cluster is not None:
|
|
params['cluster'] = cluster
|
|
return self._make_request(
|
|
action='DescribeContainerInstances',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def describe_task_definition(self, task_definition):
|
|
"""
|
|
Describes a task definition.
|
|
|
|
:type task_definition: string
|
|
:param task_definition: The `family` and `revision` (
|
|
`family:revision`) or full Amazon Resource Name (ARN) of the task
|
|
definition that you want to describe.
|
|
|
|
"""
|
|
params = {'taskDefinition': task_definition, }
|
|
return self._make_request(
|
|
action='DescribeTaskDefinition',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def describe_tasks(self, tasks, cluster=None):
|
|
"""
|
|
Describes a specified task or tasks.
|
|
|
|
:type cluster: string
|
|
:param cluster: The short name or full Amazon Resource Name (ARN) of
|
|
the cluster that hosts the task you want to describe. If you do not
|
|
specify a cluster, the default cluster is assumed.
|
|
|
|
:type tasks: list
|
|
:param tasks: A space-separated list of task UUIDs or full Amazon
|
|
Resource Name (ARN) entries.
|
|
|
|
"""
|
|
params = {}
|
|
self.build_list_params(params,
|
|
tasks,
|
|
'tasks.member')
|
|
if cluster is not None:
|
|
params['cluster'] = cluster
|
|
return self._make_request(
|
|
action='DescribeTasks',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def discover_poll_endpoint(self, container_instance=None):
|
|
"""
|
|
This action is only used by the Amazon EC2 Container Service
|
|
agent, and it is not intended for use outside of the agent.
|
|
|
|
|
|
Returns an endpoint for the Amazon EC2 Container Service agent
|
|
to poll for updates.
|
|
|
|
:type container_instance: string
|
|
:param container_instance: The container instance UUID or full Amazon
|
|
Resource Name (ARN) of the container instance. The ARN contains the
|
|
`arn:aws:ecs` namespace, followed by the region of the container
|
|
instance, the AWS account ID of the container instance owner, the
|
|
`container-instance` namespace, and then the container instance
|
|
UUID. For example, arn:aws:ecs: region : aws_account_id :container-
|
|
instance/ container_instance_UUID .
|
|
|
|
"""
|
|
params = {}
|
|
if container_instance is not None:
|
|
params['containerInstance'] = container_instance
|
|
return self._make_request(
|
|
action='DiscoverPollEndpoint',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def list_clusters(self, next_token=None, max_results=None):
|
|
"""
|
|
Returns a list of existing clusters.
|
|
|
|
:type next_token: string
|
|
:param next_token: The `nextToken` value returned from a previous
|
|
paginated `ListClusters` request where `maxResults` was used and
|
|
the results exceeded the value of that parameter. Pagination
|
|
continues from the end of the previous results that returned the
|
|
`nextToken` value. This value is `null` when there are no more
|
|
results to return.
|
|
|
|
:type max_results: integer
|
|
:param max_results: The maximum number of cluster results returned by
|
|
`ListClusters` in paginated output. When this parameter is used,
|
|
`ListClusters` only returns `maxResults` results in a single page
|
|
along with a `nextToken` response element. The remaining results of
|
|
the initial request can be seen by sending another `ListClusters`
|
|
request with the returned `nextToken` value. This value can be
|
|
between 1 and 100. If this parameter is not used, then
|
|
`ListClusters` returns up to 100 results and a `nextToken` value if
|
|
applicable.
|
|
|
|
"""
|
|
params = {}
|
|
if next_token is not None:
|
|
params['nextToken'] = next_token
|
|
if max_results is not None:
|
|
params['maxResults'] = max_results
|
|
return self._make_request(
|
|
action='ListClusters',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def list_container_instances(self, cluster=None, next_token=None,
|
|
max_results=None):
|
|
"""
|
|
Returns a list of container instances in a specified cluster.
|
|
|
|
:type cluster: string
|
|
:param cluster: The short name or full Amazon Resource Name (ARN) of
|
|
the cluster that hosts the container instances you want to list. If
|
|
you do not specify a cluster, the default cluster is assumed..
|
|
|
|
:type next_token: string
|
|
:param next_token: The `nextToken` value returned from a previous
|
|
paginated `ListContainerInstances` request where `maxResults` was
|
|
used and the results exceeded the value of that parameter.
|
|
Pagination continues from the end of the previous results that
|
|
returned the `nextToken` value. This value is `null` when there are
|
|
no more results to return.
|
|
|
|
:type max_results: integer
|
|
:param max_results: The maximum number of container instance results
|
|
returned by `ListContainerInstances` in paginated output. When this
|
|
parameter is used, `ListContainerInstances` only returns
|
|
`maxResults` results in a single page along with a `nextToken`
|
|
response element. The remaining results of the initial request can
|
|
be seen by sending another `ListContainerInstances` request with
|
|
the returned `nextToken` value. This value can be between 1 and
|
|
100. If this parameter is not used, then `ListContainerInstances`
|
|
returns up to 100 results and a `nextToken` value if applicable.
|
|
|
|
"""
|
|
params = {}
|
|
if cluster is not None:
|
|
params['cluster'] = cluster
|
|
if next_token is not None:
|
|
params['nextToken'] = next_token
|
|
if max_results is not None:
|
|
params['maxResults'] = max_results
|
|
return self._make_request(
|
|
action='ListContainerInstances',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def list_task_definitions(self, family_prefix=None, next_token=None,
|
|
max_results=None):
|
|
"""
|
|
Returns a list of task definitions that are registered to your
|
|
account. You can filter the results by family name with the
|
|
`familyPrefix` parameter.
|
|
|
|
:type family_prefix: string
|
|
:param family_prefix: The name of the family that you want to filter
|
|
the `ListTaskDefinitions` results with. Specifying a `familyPrefix`
|
|
will limit the listed task definitions to definitions that belong
|
|
to that family.
|
|
|
|
:type next_token: string
|
|
:param next_token: The `nextToken` value returned from a previous
|
|
paginated `ListTaskDefinitions` request where `maxResults` was used
|
|
and the results exceeded the value of that parameter. Pagination
|
|
continues from the end of the previous results that returned the
|
|
`nextToken` value. This value is `null` when there are no more
|
|
results to return.
|
|
|
|
:type max_results: integer
|
|
:param max_results: The maximum number of task definition results
|
|
returned by `ListTaskDefinitions` in paginated output. When this
|
|
parameter is used, `ListTaskDefinitions` only returns `maxResults`
|
|
results in a single page along with a `nextToken` response element.
|
|
The remaining results of the initial request can be seen by sending
|
|
another `ListTaskDefinitions` request with the returned `nextToken`
|
|
value. This value can be between 1 and 100. If this parameter is
|
|
not used, then `ListTaskDefinitions` returns up to 100 results and
|
|
a `nextToken` value if applicable.
|
|
|
|
"""
|
|
params = {}
|
|
if family_prefix is not None:
|
|
params['familyPrefix'] = family_prefix
|
|
if next_token is not None:
|
|
params['nextToken'] = next_token
|
|
if max_results is not None:
|
|
params['maxResults'] = max_results
|
|
return self._make_request(
|
|
action='ListTaskDefinitions',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def list_tasks(self, cluster=None, container_instance=None, family=None,
|
|
next_token=None, max_results=None):
|
|
"""
|
|
Returns a list of tasks for a specified cluster. You can
|
|
filter the results by family name or by a particular container
|
|
instance with the `family` and `containerInstance` parameters.
|
|
|
|
:type cluster: string
|
|
:param cluster: The short name or full Amazon Resource Name (ARN) of
|
|
the cluster that hosts the tasks you want to list. If you do not
|
|
specify a cluster, the default cluster is assumed..
|
|
|
|
:type container_instance: string
|
|
:param container_instance: The container instance UUID or full Amazon
|
|
Resource Name (ARN) of the container instance that you want to
|
|
filter the `ListTasks` results with. Specifying a
|
|
`containerInstance` will limit the results to tasks that belong to
|
|
that container instance.
|
|
|
|
:type family: string
|
|
:param family: The name of the family that you want to filter the
|
|
`ListTasks` results with. Specifying a `family` will limit the
|
|
results to tasks that belong to that family.
|
|
|
|
:type next_token: string
|
|
:param next_token: The `nextToken` value returned from a previous
|
|
paginated `ListTasks` request where `maxResults` was used and the
|
|
results exceeded the value of that parameter. Pagination continues
|
|
from the end of the previous results that returned the `nextToken`
|
|
value. This value is `null` when there are no more results to
|
|
return.
|
|
|
|
:type max_results: integer
|
|
:param max_results: The maximum number of task results returned by
|
|
`ListTasks` in paginated output. When this parameter is used,
|
|
`ListTasks` only returns `maxResults` results in a single page
|
|
along with a `nextToken` response element. The remaining results of
|
|
the initial request can be seen by sending another `ListTasks`
|
|
request with the returned `nextToken` value. This value can be
|
|
between 1 and 100. If this parameter is not used, then `ListTasks`
|
|
returns up to 100 results and a `nextToken` value if applicable.
|
|
|
|
"""
|
|
params = {}
|
|
if cluster is not None:
|
|
params['cluster'] = cluster
|
|
if container_instance is not None:
|
|
params['containerInstance'] = container_instance
|
|
if family is not None:
|
|
params['family'] = family
|
|
if next_token is not None:
|
|
params['nextToken'] = next_token
|
|
if max_results is not None:
|
|
params['maxResults'] = max_results
|
|
return self._make_request(
|
|
action='ListTasks',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def register_container_instance(self, cluster=None,
|
|
instance_identity_document=None,
|
|
instance_identity_document_signature=None,
|
|
total_resources=None):
|
|
"""
|
|
This action is only used by the Amazon EC2 Container Service
|
|
agent, and it is not intended for use outside of the agent.
|
|
|
|
|
|
Registers an Amazon EC2 instance into the specified cluster.
|
|
This instance will become available to place containers on.
|
|
|
|
:type cluster: string
|
|
:param cluster: The short name or full Amazon Resource Name (ARN) of
|
|
the cluster that you want to register your container instance with.
|
|
If you do not specify a cluster, the default cluster is assumed..
|
|
|
|
:type instance_identity_document: string
|
|
:param instance_identity_document:
|
|
|
|
:type instance_identity_document_signature: string
|
|
:param instance_identity_document_signature:
|
|
|
|
:type total_resources: list
|
|
:param total_resources:
|
|
|
|
"""
|
|
params = {}
|
|
if cluster is not None:
|
|
params['cluster'] = cluster
|
|
if instance_identity_document is not None:
|
|
params['instanceIdentityDocument'] = instance_identity_document
|
|
if instance_identity_document_signature is not None:
|
|
params['instanceIdentityDocumentSignature'] = instance_identity_document_signature
|
|
if total_resources is not None:
|
|
self.build_complex_list_params(
|
|
params, total_resources,
|
|
'totalResources.member',
|
|
('name', 'type', 'doubleValue', 'longValue', 'integerValue', 'stringSetValue'))
|
|
return self._make_request(
|
|
action='RegisterContainerInstance',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def register_task_definition(self, family, container_definitions):
|
|
"""
|
|
Registers a new task definition from the supplied `family` and
|
|
`containerDefinitions`.
|
|
|
|
:type family: string
|
|
:param family: You can specify a `family` for a task definition, which
|
|
allows you to track multiple versions of the same task definition.
|
|
You can think of the `family` as a name for your task definition.
|
|
|
|
:type container_definitions: list
|
|
:param container_definitions: A list of container definitions in JSON
|
|
format that describe the different containers that make up your
|
|
task.
|
|
|
|
"""
|
|
params = {'family': family, }
|
|
self.build_complex_list_params(
|
|
params, container_definitions,
|
|
'containerDefinitions.member',
|
|
('name', 'image', 'cpu', 'memory', 'links', 'portMappings', 'essential', 'entryPoint', 'command', 'environment'))
|
|
return self._make_request(
|
|
action='RegisterTaskDefinition',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def run_task(self, task_definition, cluster=None, overrides=None,
|
|
count=None):
|
|
"""
|
|
Start a task using random placement and the default Amazon ECS
|
|
scheduler. If you want to use your own scheduler or place a
|
|
task on a specific container instance, use `StartTask`
|
|
instead.
|
|
|
|
:type cluster: string
|
|
:param cluster: The short name or full Amazon Resource Name (ARN) of
|
|
the cluster that you want to run your task on. If you do not
|
|
specify a cluster, the default cluster is assumed..
|
|
|
|
:type task_definition: string
|
|
:param task_definition: The `family` and `revision` (
|
|
`family:revision`) or full Amazon Resource Name (ARN) of the task
|
|
definition that you want to run.
|
|
|
|
:type overrides: dict
|
|
:param overrides:
|
|
|
|
:type count: integer
|
|
:param count: The number of instances of the specified task that you
|
|
would like to place on your cluster.
|
|
|
|
"""
|
|
params = {'taskDefinition': task_definition, }
|
|
if cluster is not None:
|
|
params['cluster'] = cluster
|
|
if overrides is not None:
|
|
params['overrides'] = overrides
|
|
if count is not None:
|
|
params['count'] = count
|
|
return self._make_request(
|
|
action='RunTask',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def start_task(self, task_definition, container_instances, cluster=None,
|
|
overrides=None):
|
|
"""
|
|
Starts a new task from the specified task definition on the
|
|
specified container instance or instances. If you want to use
|
|
the default Amazon ECS scheduler to place your task, use
|
|
`RunTask` instead.
|
|
|
|
:type cluster: string
|
|
:param cluster: The short name or full Amazon Resource Name (ARN) of
|
|
the cluster that you want to start your task on. If you do not
|
|
specify a cluster, the default cluster is assumed..
|
|
|
|
:type task_definition: string
|
|
:param task_definition: The `family` and `revision` (
|
|
`family:revision`) or full Amazon Resource Name (ARN) of the task
|
|
definition that you want to start.
|
|
|
|
:type overrides: dict
|
|
:param overrides:
|
|
|
|
:type container_instances: list
|
|
:param container_instances: The container instance UUIDs or full Amazon
|
|
Resource Name (ARN) entries for the container instances on which
|
|
you would like to place your task.
|
|
|
|
"""
|
|
params = {'taskDefinition': task_definition, }
|
|
self.build_list_params(params,
|
|
container_instances,
|
|
'containerInstances.member')
|
|
if cluster is not None:
|
|
params['cluster'] = cluster
|
|
if overrides is not None:
|
|
params['overrides'] = overrides
|
|
return self._make_request(
|
|
action='StartTask',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def stop_task(self, task, cluster=None):
|
|
"""
|
|
Stops a running task.
|
|
|
|
:type cluster: string
|
|
:param cluster: The short name or full Amazon Resource Name (ARN) of
|
|
the cluster that hosts the task you want to stop. If you do not
|
|
specify a cluster, the default cluster is assumed..
|
|
|
|
:type task: string
|
|
:param task: The task UUIDs or full Amazon Resource Name (ARN) entry of
|
|
the task you would like to stop.
|
|
|
|
"""
|
|
params = {'task': task, }
|
|
if cluster is not None:
|
|
params['cluster'] = cluster
|
|
return self._make_request(
|
|
action='StopTask',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def submit_container_state_change(self, cluster=None, task=None,
|
|
container_name=None, status=None,
|
|
exit_code=None, reason=None,
|
|
network_bindings=None):
|
|
"""
|
|
This action is only used by the Amazon EC2 Container Service
|
|
agent, and it is not intended for use outside of the agent.
|
|
|
|
|
|
Sent to acknowledge that a container changed states.
|
|
|
|
:type cluster: string
|
|
:param cluster: The short name or full Amazon Resource Name (ARN) of
|
|
the cluster that hosts the container.
|
|
|
|
:type task: string
|
|
:param task: The task UUID or full Amazon Resource Name (ARN) of the
|
|
task that hosts the container.
|
|
|
|
:type container_name: string
|
|
:param container_name: The name of the container.
|
|
|
|
:type status: string
|
|
:param status: The status of the state change request.
|
|
|
|
:type exit_code: integer
|
|
:param exit_code: The exit code returned for the state change request.
|
|
|
|
:type reason: string
|
|
:param reason: The reason for the state change request.
|
|
|
|
:type network_bindings: list
|
|
:param network_bindings: The network bindings of the container.
|
|
|
|
"""
|
|
params = {}
|
|
if cluster is not None:
|
|
params['cluster'] = cluster
|
|
if task is not None:
|
|
params['task'] = task
|
|
if container_name is not None:
|
|
params['containerName'] = container_name
|
|
if status is not None:
|
|
params['status'] = status
|
|
if exit_code is not None:
|
|
params['exitCode'] = exit_code
|
|
if reason is not None:
|
|
params['reason'] = reason
|
|
if network_bindings is not None:
|
|
self.build_complex_list_params(
|
|
params, network_bindings,
|
|
'networkBindings.member',
|
|
('bindIP', 'containerPort', 'hostPort'))
|
|
return self._make_request(
|
|
action='SubmitContainerStateChange',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def submit_task_state_change(self, cluster=None, task=None, status=None,
|
|
reason=None):
|
|
"""
|
|
This action is only used by the Amazon EC2 Container Service
|
|
agent, and it is not intended for use outside of the agent.
|
|
|
|
|
|
Sent to acknowledge that a task changed states.
|
|
|
|
:type cluster: string
|
|
:param cluster: The short name or full Amazon Resource Name (ARN) of
|
|
the cluster that hosts the task.
|
|
|
|
:type task: string
|
|
:param task: The task UUID or full Amazon Resource Name (ARN) of the
|
|
task in the state change request.
|
|
|
|
:type status: string
|
|
:param status: The status of the state change request.
|
|
|
|
:type reason: string
|
|
:param reason: The reason for the state change request.
|
|
|
|
"""
|
|
params = {}
|
|
if cluster is not None:
|
|
params['cluster'] = cluster
|
|
if task is not None:
|
|
params['task'] = task
|
|
if status is not None:
|
|
params['status'] = status
|
|
if reason is not None:
|
|
params['reason'] = reason
|
|
return self._make_request(
|
|
action='SubmitTaskStateChange',
|
|
verb='POST',
|
|
path='/', params=params)
|
|
|
|
def _make_request(self, action, verb, path, params):
|
|
params['ContentType'] = 'JSON'
|
|
response = self.make_request(action=action, verb='POST',
|
|
path='/', params=params)
|
|
body = response.read().decode('utf-8')
|
|
boto.log.debug(body)
|
|
if response.status == 200:
|
|
return json.loads(body)
|
|
else:
|
|
json_body = json.loads(body)
|
|
fault_name = json_body.get('Error', {}).get('Code', None)
|
|
exception_class = self._faults.get(fault_name, self.ResponseError)
|
|
raise exception_class(response.status, response.reason,
|
|
body=json_body)
|