Remove telemetry/third_party/gsutilz

tools/telemetry/third_party/gsutilz/third_party/boto/boto/codedeploy/layer1.py

Index: tools/telemetry/third_party/gsutilz/third_party/boto/boto/codedeploy/layer1.py
diff --git a/tools/telemetry/third_party/gsutilz/third_party/boto/boto/codedeploy/layer1.py b/tools/telemetry/third_party/gsutilz/third_party/boto/boto/codedeploy/layer1.py
deleted file mode 100644
index 6c61a08342962bfcfda3538b78b0337f33c3cea7..0000000000000000000000000000000000000000
--- a/tools/telemetry/third_party/gsutilz/third_party/boto/boto/codedeploy/layer1.py
+++ /dev/null
@@ -1,899 +0,0 @@
-# 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.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)
-