| # 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) |
| |
