tools/telemetry/third_party/gsutil/third_party/boto/boto/codedeploy/layer1.py - Issue 1260493004: Revert "Add gsutil 4.13 to telemetry/third_party"

Unified Diff: tools/telemetry/third_party/gsutil/third_party/boto/boto/codedeploy/layer1.py

Issue 1260493004: Revert "Add gsutil 4.13 to telemetry/third_party" (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Created 5 years, 5 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

« no previous file with comments | « tools/telemetry/third_party/gsutil/third_party/boto/boto/codedeploy/exceptions.py ('k') | tools/telemetry/third_party/gsutil/third_party/boto/boto/cognito/__init__.py » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: tools/telemetry/third_party/gsutil/third_party/boto/boto/codedeploy/layer1.py

diff --git a/tools/telemetry/third_party/gsutil/third_party/boto/boto/codedeploy/layer1.py b/tools/telemetry/third_party/gsutil/third_party/boto/boto/codedeploy/layer1.py

deleted file mode 100644

index 6c61a08342962bfcfda3538b78b0337f33c3cea7..0000000000000000000000000000000000000000

--- a/tools/telemetry/third_party/gsutil/third_party/boto/boto/codedeploy/layer1.py

+++ /dev/null

@@ -1,899 +0,0 @@

-# 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.codedeploy import exceptions

-class CodeDeployConnection(AWSQueryConnection):

- """

- AWS CodeDeploy **Overview**

- This is the AWS CodeDeploy API Reference. This guide provides

- descriptions of the AWS CodeDeploy APIs. For additional

- information, see the `AWS CodeDeploy User Guide`_.

- **Using the APIs**

- You can use the AWS CodeDeploy APIs to work with the following

- items:

- + Applications , which are unique identifiers that AWS CodeDeploy

- uses to ensure that the correct combinations of revisions,

- deployment configurations, and deployment groups are being

- referenced during deployments. You can work with applications by

- calling CreateApplication, DeleteApplication, GetApplication,

- ListApplications, BatchGetApplications, and UpdateApplication to

- create, delete, and get information about applications, and to

- change information about an application, respectively.

- + Deployment configurations , which are sets of deployment rules

- and deployment success and failure conditions that AWS CodeDeploy

- uses during deployments. You can work with deployment

- configurations by calling CreateDeploymentConfig,

- DeleteDeploymentConfig, GetDeploymentConfig, and

- ListDeploymentConfigs to create, delete, and get information about

- deployment configurations, respectively.

- + Deployment groups , which represent groups of Amazon EC2

- instances to which application revisions can be deployed. You can

- work with deployment groups by calling CreateDeploymentGroup,

- DeleteDeploymentGroup, GetDeploymentGroup, ListDeploymentGroups,

- and UpdateDeploymentGroup to create, delete, and get information

- about single and multiple deployment groups, and to change

- information about a deployment group, respectively.

- + Deployment instances (also known simply as instances ), which

- represent Amazon EC2 instances to which application revisions are

- deployed. Deployment instances are identified by their Amazon EC2

- tags or Auto Scaling group names. Deployment instances belong to

- deployment groups. You can work with deployment instances by

- calling GetDeploymentInstance and ListDeploymentInstances to get

- information about single and multiple deployment instances,

- respectively.

- + Deployments , which represent the process of deploying revisions

- to deployment groups. You can work with deployments by calling

- CreateDeployment, GetDeployment, ListDeployments,

- BatchGetDeployments, and StopDeployment to create and get

- information about deployments, and to stop a deployment,

- respectively.

- + Application revisions (also known simply as revisions ), which

- are archive files that are stored in Amazon S3 buckets or GitHub

- repositories. These revisions contain source content (such as

- source code, web pages, executable files, any deployment scripts,

- and similar) along with an Application Specification file (AppSpec

- file). (The AppSpec file is unique to AWS CodeDeploy; it defines a

- series of deployment actions that you want AWS CodeDeploy to

- execute.) An application revision is uniquely identified by its

- Amazon S3 object key and its ETag, version, or both. Application

- revisions are deployed to deployment groups. You can work with

- application revisions by calling GetApplicationRevision,

- ListApplicationRevisions, and RegisterApplicationRevision to get

- information about application revisions and to inform AWS

- CodeDeploy about an application revision, respectively.

- """

- APIVersion = "2014-10-06"

- DefaultRegionName = "us-east-1"

- DefaultRegionEndpoint = "codedeploy.us-east-1.amazonaws.com"

- ServiceName = "codedeploy"

- TargetPrefix = "CodeDeploy_20141006"

- ResponseError = JSONResponseError

- _faults = {

- "InvalidDeploymentIdException": exceptions.InvalidDeploymentIdException,

- "InvalidDeploymentGroupNameException": exceptions.InvalidDeploymentGroupNameException,

- "DeploymentConfigAlreadyExistsException": exceptions.DeploymentConfigAlreadyExistsException,

- "InvalidRoleException": exceptions.InvalidRoleException,

- "RoleRequiredException": exceptions.RoleRequiredException,

- "DeploymentGroupAlreadyExistsException": exceptions.DeploymentGroupAlreadyExistsException,

- "DeploymentConfigLimitExceededException": exceptions.DeploymentConfigLimitExceededException,

- "InvalidNextTokenException": exceptions.InvalidNextTokenException,

- "InvalidDeploymentConfigNameException": exceptions.InvalidDeploymentConfigNameException,

- "InvalidSortByException": exceptions.InvalidSortByException,

- "InstanceDoesNotExistException": exceptions.InstanceDoesNotExistException,

- "InvalidMinimumHealthyHostValueException": exceptions.InvalidMinimumHealthyHostValueException,

- "ApplicationLimitExceededException": exceptions.ApplicationLimitExceededException,

- "ApplicationNameRequiredException": exceptions.ApplicationNameRequiredException,

- "InvalidEC2TagException": exceptions.InvalidEC2TagException,

- "DeploymentDoesNotExistException": exceptions.DeploymentDoesNotExistException,

- "DeploymentLimitExceededException": exceptions.DeploymentLimitExceededException,

- "InvalidInstanceStatusException": exceptions.InvalidInstanceStatusException,

- "RevisionRequiredException": exceptions.RevisionRequiredException,

- "InvalidBucketNameFilterException": exceptions.InvalidBucketNameFilterException,

- "DeploymentGroupLimitExceededException": exceptions.DeploymentGroupLimitExceededException,

- "DeploymentGroupDoesNotExistException": exceptions.DeploymentGroupDoesNotExistException,

- "DeploymentConfigNameRequiredException": exceptions.DeploymentConfigNameRequiredException,

- "DeploymentAlreadyCompletedException": exceptions.DeploymentAlreadyCompletedException,

- "RevisionDoesNotExistException": exceptions.RevisionDoesNotExistException,

- "DeploymentGroupNameRequiredException": exceptions.DeploymentGroupNameRequiredException,

- "DeploymentIdRequiredException": exceptions.DeploymentIdRequiredException,

- "DeploymentConfigDoesNotExistException": exceptions.DeploymentConfigDoesNotExistException,

- "BucketNameFilterRequiredException": exceptions.BucketNameFilterRequiredException,

- "InvalidTimeRangeException": exceptions.InvalidTimeRangeException,

- "ApplicationDoesNotExistException": exceptions.ApplicationDoesNotExistException,

- "InvalidRevisionException": exceptions.InvalidRevisionException,

- "InvalidSortOrderException": exceptions.InvalidSortOrderException,

- "InvalidOperationException": exceptions.InvalidOperationException,

- "InvalidAutoScalingGroupException": exceptions.InvalidAutoScalingGroupException,

- "InvalidApplicationNameException": exceptions.InvalidApplicationNameException,

- "DescriptionTooLongException": exceptions.DescriptionTooLongException,

- "ApplicationAlreadyExistsException": exceptions.ApplicationAlreadyExistsException,

- "InvalidDeployedStateFilterException": exceptions.InvalidDeployedStateFilterException,

- "DeploymentNotStartedException": exceptions.DeploymentNotStartedException,

- "DeploymentConfigInUseException": exceptions.DeploymentConfigInUseException,

- "InstanceIdRequiredException": exceptions.InstanceIdRequiredException,

- "InvalidKeyPrefixFilterException": exceptions.InvalidKeyPrefixFilterException,

- "InvalidDeploymentStatusException": exceptions.InvalidDeploymentStatusException,

- }

- 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(CodeDeployConnection, self).__init__(**kwargs)

- self.region = region

- def _required_auth_capability(self):

- return ['hmac-v4']

- def batch_get_applications(self, application_names=None):

- """

- Gets information about one or more applications.

- :type application_names: list

- :param application_names: A list of application names, with multiple

- application names separated by spaces.

- """

- params = {}

- if application_names is not None:

- params['applicationNames'] = application_names

- return self.make_request(action='BatchGetApplications',

- body=json.dumps(params))

- def batch_get_deployments(self, deployment_ids=None):

- """

- Gets information about one or more deployments.

- :type deployment_ids: list

- :param deployment_ids: A list of deployment IDs, with multiple

- deployment IDs separated by spaces.

- """

- params = {}

- if deployment_ids is not None:

- params['deploymentIds'] = deployment_ids

- return self.make_request(action='BatchGetDeployments',

- body=json.dumps(params))

- def create_application(self, application_name):

- """

- Creates a new application.

- :type application_name: string

- :param application_name: The name of the application. This name must be

- unique within the AWS user account.

- """

- params = {'applicationName': application_name, }

- return self.make_request(action='CreateApplication',

- body=json.dumps(params))

- def create_deployment(self, application_name, deployment_group_name=None,

- revision=None, deployment_config_name=None,

- description=None,

- ignore_application_stop_failures=None):

- """

- Deploys an application revision to the specified deployment

- group.

- :type application_name: string

- :param application_name: The name of an existing AWS CodeDeploy

- application within the AWS user account.

- :type deployment_group_name: string

- :param deployment_group_name: The deployment group's name.

- :type revision: dict

- :param revision: The type of revision to deploy, along with information

- about the revision's location.

- :type deployment_config_name: string

- :param deployment_config_name: The name of an existing deployment

- configuration within the AWS user account.

- If not specified, the value configured in the deployment group will be

- used as the default. If the deployment group does not have a

- deployment configuration associated with it, then

- CodeDeployDefault.OneAtATime will be used by default.

- :type description: string

- :param description: A comment about the deployment.

- :type ignore_application_stop_failures: boolean

- :param ignore_application_stop_failures: If set to true, then if the

- deployment causes the ApplicationStop deployment lifecycle event to

- fail to a specific instance, the deployment will not be considered

- to have failed to that instance at that point and will continue on

- to the BeforeInstall deployment lifecycle event.

- If set to false or not specified, then if the deployment causes the

- ApplicationStop deployment lifecycle event to fail to a specific

- instance, the deployment will stop to that instance, and the

- deployment to that instance will be considered to have failed.

- """

- params = {'applicationName': application_name, }

- if deployment_group_name is not None:

- params['deploymentGroupName'] = deployment_group_name

- if revision is not None:

- params['revision'] = revision

- if deployment_config_name is not None:

- params['deploymentConfigName'] = deployment_config_name

- if description is not None:

- params['description'] = description

- if ignore_application_stop_failures is not None:

- params['ignoreApplicationStopFailures'] = ignore_application_stop_failures

- return self.make_request(action='CreateDeployment',

- body=json.dumps(params))

- def create_deployment_config(self, deployment_config_name,

- minimum_healthy_hosts=None):

- """

- Creates a new deployment configuration.

- :type deployment_config_name: string

- :param deployment_config_name: The name of the deployment configuration

- to create.

- :type minimum_healthy_hosts: dict

- :param minimum_healthy_hosts: The minimum number of healthy instances

- that should be available at any time during the deployment. There

- are two parameters expected in the input: type and value.

- The type parameter takes either of the following values:

- + HOST_COUNT: The value parameter represents the minimum number of

- healthy instances, as an absolute value.

- + FLEET_PERCENT: The value parameter represents the minimum number of

- healthy instances, as a percentage of the total number of instances

- in the deployment. If you specify FLEET_PERCENT, then at the start

- of the deployment AWS CodeDeploy converts the percentage to the

- equivalent number of instances and rounds fractional instances up.

- The value parameter takes an integer.

- For example, to set a minimum of 95% healthy instances, specify a type

- of FLEET_PERCENT and a value of 95.

- """

- params = {'deploymentConfigName': deployment_config_name, }

- if minimum_healthy_hosts is not None:

- params['minimumHealthyHosts'] = minimum_healthy_hosts

- return self.make_request(action='CreateDeploymentConfig',

- body=json.dumps(params))

- def create_deployment_group(self, application_name,

- deployment_group_name,

- deployment_config_name=None,

- ec_2_tag_filters=None,

- auto_scaling_groups=None,

- service_role_arn=None):

- """

- Creates a new deployment group for application revisions to be

- deployed to.

- :type application_name: string

- :param application_name: The name of an existing AWS CodeDeploy

- application within the AWS user account.

- :type deployment_group_name: string

- :param deployment_group_name: The name of an existing deployment group

- for the specified application.

- :type deployment_config_name: string

- :param deployment_config_name: If specified, the deployment

- configuration name must be one of the predefined values, or it can

- be a custom deployment configuration:

- + CodeDeployDefault.AllAtOnce deploys an application revision to up to

- all of the Amazon EC2 instances at once. The overall deployment

- succeeds if the application revision deploys to at least one of the

- instances. The overall deployment fails after the application

- revision fails to deploy to all of the instances. For example, for

- 9 instances, deploy to up to all 9 instances at once. The overall

- deployment succeeds if any of the 9 instances is successfully

- deployed to, and it fails if all 9 instances fail to be deployed

- to.

- + CodeDeployDefault.HalfAtATime deploys to up to half of the instances

- at a time (with fractions rounded down). The overall deployment

- succeeds if the application revision deploys to at least half of

- the instances (with fractions rounded up); otherwise, the

- deployment fails. For example, for 9 instances, deploy to up to 4

- instances at a time. The overall deployment succeeds if 5 or more

- instances are successfully deployed to; otherwise, the deployment

- fails. Note that the deployment may successfully deploy to some

- instances, even if the overall deployment fails.

- + CodeDeployDefault.OneAtATime deploys the application revision to only

- one of the instances at a time. The overall deployment succeeds if

- the application revision deploys to all of the instances. The

- overall deployment fails after the application revision first fails

- to deploy to any one instance. For example, for 9 instances, deploy

- to one instance at a time. The overall deployment succeeds if all 9

- instances are successfully deployed to, and it fails if any of one

- of the 9 instances fail to be deployed to. Note that the deployment

- may successfully deploy to some instances, even if the overall

- deployment fails. This is the default deployment configuration if a

- configuration isn't specified for either the deployment or the

- deployment group.

- To create a custom deployment configuration, call the create deployment

- configuration operation.

- :type ec_2_tag_filters: list

- :param ec_2_tag_filters: The Amazon EC2 tags to filter on.

- :type auto_scaling_groups: list

- :param auto_scaling_groups: A list of associated Auto Scaling groups.

- :type service_role_arn: string

- :param service_role_arn: A service role ARN that allows AWS CodeDeploy

- to act on the user's behalf when interacting with AWS services.

- """

- params = {

- 'applicationName': application_name,

- 'deploymentGroupName': deployment_group_name,

- }

- if deployment_config_name is not None:

- params['deploymentConfigName'] = deployment_config_name

- if ec_2_tag_filters is not None:

- params['ec2TagFilters'] = ec_2_tag_filters

- if auto_scaling_groups is not None:

- params['autoScalingGroups'] = auto_scaling_groups

- if service_role_arn is not None:

- params['serviceRoleArn'] = service_role_arn

- return self.make_request(action='CreateDeploymentGroup',

- body=json.dumps(params))

- def delete_application(self, application_name):

- """

- Deletes an application.

- :type application_name: string

- :param application_name: The name of an existing AWS CodeDeploy

- application within the AWS user account.

- """

- params = {'applicationName': application_name, }

- return self.make_request(action='DeleteApplication',

- body=json.dumps(params))

- def delete_deployment_config(self, deployment_config_name):

- """

- Deletes a deployment configuration.

- A deployment configuration cannot be deleted if it is

- currently in use. Also, predefined configurations cannot be

- deleted.

- :type deployment_config_name: string

- :param deployment_config_name: The name of an existing deployment

- configuration within the AWS user account.

- """

- params = {'deploymentConfigName': deployment_config_name, }

- return self.make_request(action='DeleteDeploymentConfig',

- body=json.dumps(params))

- def delete_deployment_group(self, application_name,

- deployment_group_name):

- """

- Deletes a deployment group.

- :type application_name: string

- :param application_name: The name of an existing AWS CodeDeploy

- application within the AWS user account.

- :type deployment_group_name: string

- :param deployment_group_name: The name of an existing deployment group

- for the specified application.

- """

- params = {

- 'applicationName': application_name,

- 'deploymentGroupName': deployment_group_name,

- }

- return self.make_request(action='DeleteDeploymentGroup',

- body=json.dumps(params))

- def get_application(self, application_name):

- """

- Gets information about an application.

- :type application_name: string

- :param application_name: The name of an existing AWS CodeDeploy

- application within the AWS user account.

- """

- params = {'applicationName': application_name, }

- return self.make_request(action='GetApplication',

- body=json.dumps(params))

- def get_application_revision(self, application_name, revision):

- """

- Gets information about an application revision.

- :type application_name: string

- :param application_name: The name of the application that corresponds

- to the revision.

- :type revision: dict

- :param revision: Information about the application revision to get,

- including the revision's type and its location.

- """

- params = {

- 'applicationName': application_name,

- 'revision': revision,

- }

- return self.make_request(action='GetApplicationRevision',

- body=json.dumps(params))

- def get_deployment(self, deployment_id):

- """

- Gets information about a deployment.

- :type deployment_id: string

- :param deployment_id: An existing deployment ID within the AWS user

- account.

- """

- params = {'deploymentId': deployment_id, }

- return self.make_request(action='GetDeployment',

- body=json.dumps(params))

- def get_deployment_config(self, deployment_config_name):

- """

- Gets information about a deployment configuration.

- :type deployment_config_name: string

- :param deployment_config_name: The name of an existing deployment

- configuration within the AWS user account.

- """

- params = {'deploymentConfigName': deployment_config_name, }

- return self.make_request(action='GetDeploymentConfig',

- body=json.dumps(params))

- def get_deployment_group(self, application_name, deployment_group_name):

- """

- Gets information about a deployment group.

- :type application_name: string

- :param application_name: The name of an existing AWS CodeDeploy

- application within the AWS user account.

- :type deployment_group_name: string

- :param deployment_group_name: The name of an existing deployment group

- for the specified application.

- """

- params = {

- 'applicationName': application_name,

- 'deploymentGroupName': deployment_group_name,

- }

- return self.make_request(action='GetDeploymentGroup',

- body=json.dumps(params))

- def get_deployment_instance(self, deployment_id, instance_id):

- """

- Gets information about an Amazon EC2 instance as part of a

- deployment.

- :type deployment_id: string

- :param deployment_id: The unique ID of a deployment.

- :type instance_id: string

- :param instance_id: The unique ID of an Amazon EC2 instance in the

- deployment's deployment group.

- """

- params = {

- 'deploymentId': deployment_id,

- 'instanceId': instance_id,

- }

- return self.make_request(action='GetDeploymentInstance',

- body=json.dumps(params))

- def list_application_revisions(self, application_name, sort_by=None,

- sort_order=None, s_3_bucket=None,

- s_3_key_prefix=None, deployed=None,

- next_token=None):

- """

- Lists information about revisions for an application.

- :type application_name: string

- :param application_name: The name of an existing AWS CodeDeploy

- application within the AWS user account.

- :type sort_by: string

- :param sort_by: The column name to sort the list results by:

- + registerTime: Sort the list results by when the revisions were

- registered with AWS CodeDeploy.

- + firstUsedTime: Sort the list results by when the revisions were first

- used by in a deployment.

- + lastUsedTime: Sort the list results by when the revisions were last

- used in a deployment.

- If not specified or set to null, the results will be returned in an

- arbitrary order.

- :type sort_order: string

- :param sort_order: The order to sort the list results by:

- + ascending: Sort the list results in ascending order.

- + descending: Sort the list results in descending order.

- If not specified, the results will be sorted in ascending order.

- If set to null, the results will be sorted in an arbitrary order.

- :type s_3_bucket: string

- :param s_3_bucket: A specific Amazon S3 bucket name to limit the search

- for revisions.

- If set to null, then all of the user's buckets will be searched.

- :type s_3_key_prefix: string

- :param s_3_key_prefix: A specific key prefix for the set of Amazon S3

- objects to limit the search for revisions.

- :type deployed: string

- :param deployed:

- Whether to list revisions based on whether the revision is the target

- revision of an deployment group:

- + include: List revisions that are target revisions of a deployment

- group.

- + exclude: Do not list revisions that are target revisions of a

- deployment group.

- + ignore: List all revisions, regardless of whether they are target

- revisions of a deployment group.

- :type next_token: string

- :param next_token: An identifier that was returned from the previous

- list application revisions call, which can be used to return the

- next set of applications in the list.

- """

- params = {'applicationName': application_name, }

- if sort_by is not None:

- params['sortBy'] = sort_by

- if sort_order is not None:

- params['sortOrder'] = sort_order

- if s_3_bucket is not None:

- params['s3Bucket'] = s_3_bucket

- if s_3_key_prefix is not None:

- params['s3KeyPrefix'] = s_3_key_prefix

- if deployed is not None:

- params['deployed'] = deployed

- if next_token is not None:

- params['nextToken'] = next_token

- return self.make_request(action='ListApplicationRevisions',

- body=json.dumps(params))

- def list_applications(self, next_token=None):

- """

- Lists the applications registered within the AWS user account.

- :type next_token: string

- :param next_token: An identifier that was returned from the previous

- list applications call, which can be used to return the next set of

- applications in the list.

- """

- params = {}

- if next_token is not None:

- params['nextToken'] = next_token

- return self.make_request(action='ListApplications',

- body=json.dumps(params))

- def list_deployment_configs(self, next_token=None):

- """

- Lists the deployment configurations within the AWS user

- account.

- :type next_token: string

- :param next_token: An identifier that was returned from the previous

- list deployment configurations call, which can be used to return

- the next set of deployment configurations in the list.

- """

- params = {}

- if next_token is not None:

- params['nextToken'] = next_token

- return self.make_request(action='ListDeploymentConfigs',

- body=json.dumps(params))

- def list_deployment_groups(self, application_name, next_token=None):

- """

- Lists the deployment groups for an application registered

- within the AWS user account.

- :type application_name: string

- :param application_name: The name of an existing AWS CodeDeploy

- application within the AWS user account.

- :type next_token: string

- :param next_token: An identifier that was returned from the previous

- list deployment groups call, which can be used to return the next

- set of deployment groups in the list.

- """

- params = {'applicationName': application_name, }

- if next_token is not None:

- params['nextToken'] = next_token

- return self.make_request(action='ListDeploymentGroups',

- body=json.dumps(params))

- def list_deployment_instances(self, deployment_id, next_token=None,

- instance_status_filter=None):

- """

- Lists the Amazon EC2 instances for a deployment within the AWS

- user account.

- :type deployment_id: string

- :param deployment_id: The unique ID of a deployment.

- :type next_token: string

- :param next_token: An identifier that was returned from the previous

- list deployment instances call, which can be used to return the

- next set of deployment instances in the list.

- :type instance_status_filter: list

- :param instance_status_filter:

- A subset of instances to list, by status:

- + Pending: Include in the resulting list those instances with pending

- deployments.

- + InProgress: Include in the resulting list those instances with in-

- progress deployments.

- + Succeeded: Include in the resulting list those instances with

- succeeded deployments.

- + Failed: Include in the resulting list those instances with failed

- deployments.

- + Skipped: Include in the resulting list those instances with skipped

- deployments.

- + Unknown: Include in the resulting list those instances with

- deployments in an unknown state.

- """

- params = {'deploymentId': deployment_id, }

- if next_token is not None:

- params['nextToken'] = next_token

- if instance_status_filter is not None:

- params['instanceStatusFilter'] = instance_status_filter

- return self.make_request(action='ListDeploymentInstances',

- body=json.dumps(params))

- def list_deployments(self, application_name=None,

- deployment_group_name=None,

- include_only_statuses=None, create_time_range=None,

- next_token=None):

- """

- Lists the deployments under a deployment group for an

- application registered within the AWS user account.

- :type application_name: string

- :param application_name: The name of an existing AWS CodeDeploy

- application within the AWS user account.

- :type deployment_group_name: string

- :param deployment_group_name: The name of an existing deployment group

- for the specified application.

- :type include_only_statuses: list

- :param include_only_statuses: A subset of deployments to list, by

- status:

- + Created: Include in the resulting list created deployments.

- + Queued: Include in the resulting list queued deployments.

- + In Progress: Include in the resulting list in-progress deployments.

- + Succeeded: Include in the resulting list succeeded deployments.

- + Failed: Include in the resulting list failed deployments.

- + Aborted: Include in the resulting list aborted deployments.

- :type create_time_range: dict

- :param create_time_range: A deployment creation start- and end-time

- range for returning a subset of the list of deployments.

- :type next_token: string

- :param next_token: An identifier that was returned from the previous

- list deployments call, which can be used to return the next set of

- deployments in the list.

- """

- params = {}

- if application_name is not None:

- params['applicationName'] = application_name

- if deployment_group_name is not None:

- params['deploymentGroupName'] = deployment_group_name

- if include_only_statuses is not None:

- params['includeOnlyStatuses'] = include_only_statuses

- if create_time_range is not None:

- params['createTimeRange'] = create_time_range

- if next_token is not None:

- params['nextToken'] = next_token

- return self.make_request(action='ListDeployments',

- body=json.dumps(params))

- def register_application_revision(self, application_name, revision,

- description=None):

- """

- Registers with AWS CodeDeploy a revision for the specified

- application.

- :type application_name: string

- :param application_name: The name of an existing AWS CodeDeploy

- application within the AWS user account.

- :type description: string

- :param description: A comment about the revision.

- :type revision: dict

- :param revision: Information about the application revision to

- register, including the revision's type and its location.

- """

- params = {

- 'applicationName': application_name,

- 'revision': revision,

- }

- if description is not None:

- params['description'] = description

- return self.make_request(action='RegisterApplicationRevision',

- body=json.dumps(params))

- def stop_deployment(self, deployment_id):

- """

- Attempts to stop an ongoing deployment.

- :type deployment_id: string

- :param deployment_id: The unique ID of a deployment.

- """

- params = {'deploymentId': deployment_id, }

- return self.make_request(action='StopDeployment',

- body=json.dumps(params))

- def update_application(self, application_name=None,

- new_application_name=None):

- """

- Changes an existing application's name.

- :type application_name: string

- :param application_name: The current name of the application that you

- want to change.

- :type new_application_name: string

- :param new_application_name: The new name that you want to change the

- application to.

- """

- params = {}

- if application_name is not None:

- params['applicationName'] = application_name

- if new_application_name is not None:

- params['newApplicationName'] = new_application_name

- return self.make_request(action='UpdateApplication',

- body=json.dumps(params))

- def update_deployment_group(self, application_name,

- current_deployment_group_name,

- new_deployment_group_name=None,

- deployment_config_name=None,

- ec_2_tag_filters=None,

- auto_scaling_groups=None,

- service_role_arn=None):

- """

- Changes information about an existing deployment group.

- :type application_name: string

- :param application_name: The application name corresponding to the

- deployment group to update.

- :type current_deployment_group_name: string

- :param current_deployment_group_name: The current name of the existing

- deployment group.

- :type new_deployment_group_name: string

- :param new_deployment_group_name: The new name of the deployment group,

- if you want to change it.

- :type deployment_config_name: string

- :param deployment_config_name: The replacement deployment configuration

- name to use, if you want to change it.

- :type ec_2_tag_filters: list

- :param ec_2_tag_filters: The replacement set of Amazon EC2 tags to

- filter on, if you want to change them.

- :type auto_scaling_groups: list

- :param auto_scaling_groups: The replacement list of Auto Scaling groups

- to be included in the deployment group, if you want to change them.

- :type service_role_arn: string

- :param service_role_arn: A replacement service role's ARN, if you want

- to change it.

- """

- params = {

- 'applicationName': application_name,

- 'currentDeploymentGroupName': current_deployment_group_name,

- }

- if new_deployment_group_name is not None:

- params['newDeploymentGroupName'] = new_deployment_group_name

- if deployment_config_name is not None:

- params['deploymentConfigName'] = deployment_config_name

- if ec_2_tag_filters is not None:

- params['ec2TagFilters'] = ec_2_tag_filters

- if auto_scaling_groups is not None:

- params['autoScalingGroups'] = auto_scaling_groups

- if service_role_arn is not None:

- params['serviceRoleArn'] = service_role_arn

- return self.make_request(action='UpdateDeploymentGroup',

- body=json.dumps(params))

- def make_request(self, action, body):

- headers = {

- 'X-Amz-Target': '%s.%s' % (self.TargetPrefix, action),

- 'Host': self.region.endpoint,

- 'Content-Type': 'application/x-amz-json-1.1',

- 'Content-Length': str(len(body)),

- }

- http_request = self.build_base_http_request(

- method='POST', path='/', auth_path='/', params={},

- headers=headers, data=body)

- response = self._mexe(http_request, sender=None,

- override_num_retries=10)

- response_body = response.read().decode('utf-8')

- boto.log.debug(response_body)

- if response.status == 200:

- if response_body:

- return json.loads(response_body)

- else:

- json_body = json.loads(response_body)

- fault_name = json_body.get('__type', None)

- exception_class = self._faults.get(fault_name, self.ResponseError)

- raise exception_class(response.status, response.reason,

- body=json_body)