googlecloud 0.0.4 → 0.0.6

data/packages/gsutil/boto/boto/ec2/autoscale/__init__.py

@@ -0,0 +1,781 @@
+# Copyright (c) 2009-2011 Reza Lotun http://reza.lotun.name/
+# Copyright (c) 2011 Jann Kleen
+# Copyright (c) 2012 Mitch Garnaat http://garnaat.org/
+# Copyright (c) 2012 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.
+
+"""
+This module provides an interface to the Elastic Compute Cloud (EC2)
+Auto Scaling service.
+"""
+
+import base64
+
+import boto
+from boto.connection import AWSQueryConnection
+from boto.ec2.regioninfo import RegionInfo
+from boto.ec2.autoscale.request import Request
+from boto.ec2.autoscale.launchconfig import LaunchConfiguration
+from boto.ec2.autoscale.group import AutoScalingGroup
+from boto.ec2.autoscale.group import ProcessType
+from boto.ec2.autoscale.activity import Activity
+from boto.ec2.autoscale.policy import AdjustmentType
+from boto.ec2.autoscale.policy import MetricCollectionTypes
+from boto.ec2.autoscale.policy import ScalingPolicy
+from boto.ec2.autoscale.policy import TerminationPolicies
+from boto.ec2.autoscale.instance import Instance
+from boto.ec2.autoscale.scheduled import ScheduledUpdateGroupAction
+from boto.ec2.autoscale.tag import Tag
+
+RegionData = {
+    'us-east-1': 'autoscaling.us-east-1.amazonaws.com',
+    'us-west-1': 'autoscaling.us-west-1.amazonaws.com',
+    'us-west-2': 'autoscaling.us-west-2.amazonaws.com',
+    'sa-east-1': 'autoscaling.sa-east-1.amazonaws.com',
+    'eu-west-1': 'autoscaling.eu-west-1.amazonaws.com',
+    'ap-northeast-1': 'autoscaling.ap-northeast-1.amazonaws.com',
+    'ap-southeast-1': 'autoscaling.ap-southeast-1.amazonaws.com',
+    'ap-southeast-2': 'autoscaling.ap-southeast-2.amazonaws.com',
+}
+
+
+def regions():
+    """
+    Get all available regions for the Auto Scaling service.
+
+    :rtype: list
+    :return: A list of :class:`boto.RegionInfo` instances
+    """
+    regions = []
+    for region_name in RegionData:
+        region = RegionInfo(name=region_name,
+                            endpoint=RegionData[region_name],
+                            connection_cls=AutoScaleConnection)
+        regions.append(region)
+    return regions
+
+
+def connect_to_region(region_name, **kw_params):
+    """
+    Given a valid region name, return a
+    :class:`boto.ec2.autoscale.AutoScaleConnection`.
+
+    :param str region_name: The name of the region to connect to.
+
+    :rtype: :class:`boto.ec2.AutoScaleConnection` or ``None``
+    :return: A connection to the given region, or None if an invalid region
+        name is given
+    """
+    for region in regions():
+        if region.name == region_name:
+            return region.connect(**kw_params)
+    return None
+
+
+class AutoScaleConnection(AWSQueryConnection):
+    APIVersion = boto.config.get('Boto', 'autoscale_version', '2011-01-01')
+    DefaultRegionEndpoint = boto.config.get('Boto', 'autoscale_endpoint',
+                                            'autoscaling.us-east-1.amazonaws.com')
+    DefaultRegionName = boto.config.get('Boto', 'autoscale_region_name',
+                                        'us-east-1')
+
+    def __init__(self, aws_access_key_id=None, aws_secret_access_key=None,
+                 is_secure=True, port=None, proxy=None, proxy_port=None,
+                 proxy_user=None, proxy_pass=None, debug=0,
+                 https_connection_factory=None, region=None, path='/',
+                 security_token=None, validate_certs=True):
+        """
+        Init method to create a new connection to the AutoScaling service.
+
+        B{Note:} The host argument is overridden by the host specified in the
+                 boto configuration file.
+        """
+        if not region:
+            region = RegionInfo(self, self.DefaultRegionName,
+                                self.DefaultRegionEndpoint,
+                                AutoScaleConnection)
+        self.region = region
+        AWSQueryConnection.__init__(self, aws_access_key_id,
+                                    aws_secret_access_key,
+                                    is_secure, port, proxy, proxy_port,
+                                    proxy_user, proxy_pass,
+                                    self.region.endpoint, debug,
+                                    https_connection_factory, path=path,
+                                    security_token=security_token,
+                                    validate_certs=validate_certs)
+
+    def _required_auth_capability(self):
+        return ['hmac-v4']
+
+    def build_list_params(self, params, items, label):
+        """
+        Items is a list of dictionaries or strings::
+
+            [
+                {
+                    'Protocol' : 'HTTP',
+                    'LoadBalancerPort' : '80',
+                    'InstancePort' : '80'
+                },
+                ..
+            ] etc.
+
+        or::
+
+            ['us-east-1b',...]
+        """
+        # different from EC2 list params
+        for i in xrange(1, len(items) + 1):
+            if isinstance(items[i - 1], dict):
+                for k, v in items[i - 1].iteritems():
+                    if isinstance(v, dict):
+                        for kk, vv in v.iteritems():
+                            params['%s.member.%d.%s.%s' % (label, i, k, kk)] = vv
+                    else:
+                        params['%s.member.%d.%s' % (label, i, k)] = v
+            elif isinstance(items[i - 1], basestring):
+                params['%s.member.%d' % (label, i)] = items[i - 1]
+
+    def _update_group(self, op, as_group):
+        params = {'AutoScalingGroupName': as_group.name,
+                  'LaunchConfigurationName': as_group.launch_config_name,
+                  'MinSize': as_group.min_size,
+                  'MaxSize': as_group.max_size}
+        # get availability zone information (required param)
+        zones = as_group.availability_zones
+        self.build_list_params(params, zones, 'AvailabilityZones')
+        if as_group.desired_capacity:
+            params['DesiredCapacity'] = as_group.desired_capacity
+        if as_group.vpc_zone_identifier:
+            params['VPCZoneIdentifier'] = as_group.vpc_zone_identifier
+        if as_group.health_check_period:
+            params['HealthCheckGracePeriod'] = as_group.health_check_period
+        if as_group.health_check_type:
+            params['HealthCheckType'] = as_group.health_check_type
+        if as_group.default_cooldown:
+            params['DefaultCooldown'] = as_group.default_cooldown
+        if as_group.placement_group:
+            params['PlacementGroup'] = as_group.placement_group
+        if as_group.termination_policies:
+            self.build_list_params(params, as_group.termination_policies,
+                                   'TerminationPolicies')
+        if op.startswith('Create'):
+            # you can only associate load balancers with an autoscale
+            # group at creation time
+            if as_group.load_balancers:
+                self.build_list_params(params, as_group.load_balancers,
+                                       'LoadBalancerNames')
+            if as_group.tags:
+                for i, tag in enumerate(as_group.tags):
+                    tag.build_params(params, i + 1)
+        return self.get_object(op, params, Request)
+
+    def create_auto_scaling_group(self, as_group):
+        """
+        Create auto scaling group.
+        """
+        return self._update_group('CreateAutoScalingGroup', as_group)
+
+    def delete_auto_scaling_group(self, name, force_delete=False):
+        """
+        Deletes the specified auto scaling group if the group has no instances
+        and no scaling activities in progress.
+        """
+        if(force_delete):
+            params = {'AutoScalingGroupName': name, 'ForceDelete': 'true'}
+        else:
+            params = {'AutoScalingGroupName': name}
+        return self.get_object('DeleteAutoScalingGroup', params, Request)
+
+    def create_launch_configuration(self, launch_config):
+        """
+        Creates a new Launch Configuration.
+
+        :type launch_config: :class:`boto.ec2.autoscale.launchconfig.LaunchConfiguration`
+        :param launch_config: LaunchConfiguration object.
+        """
+        params = {'ImageId': launch_config.image_id,
+                  'LaunchConfigurationName': launch_config.name,
+                  'InstanceType': launch_config.instance_type}
+        if launch_config.key_name:
+            params['KeyName'] = launch_config.key_name
+        if launch_config.user_data:
+            params['UserData'] = base64.b64encode(launch_config.user_data)
+        if launch_config.kernel_id:
+            params['KernelId'] = launch_config.kernel_id
+        if launch_config.ramdisk_id:
+            params['RamdiskId'] = launch_config.ramdisk_id
+        if launch_config.block_device_mappings:
+            self.build_list_params(params, launch_config.block_device_mappings,
+                                   'BlockDeviceMappings')
+        if launch_config.security_groups:
+            self.build_list_params(params, launch_config.security_groups,
+                                   'SecurityGroups')
+        if launch_config.instance_monitoring:
+            params['InstanceMonitoring.Enabled'] = 'true'
+        else:
+            params['InstanceMonitoring.Enabled'] = 'false'
+        if launch_config.spot_price is not None:
+            params['SpotPrice'] = str(launch_config.spot_price)
+        if launch_config.instance_profile_name is not None:
+            params['IamInstanceProfile'] = launch_config.instance_profile_name
+        return self.get_object('CreateLaunchConfiguration', params,
+                               Request, verb='POST')
+
+    def create_scaling_policy(self, scaling_policy):
+        """
+        Creates a new Scaling Policy.
+
+        :type scaling_policy: :class:`boto.ec2.autoscale.policy.ScalingPolicy`
+        :param scaling_policy: ScalingPolicy object.
+        """
+        params = {'AdjustmentType': scaling_policy.adjustment_type,
+                  'AutoScalingGroupName': scaling_policy.as_name,
+                  'PolicyName': scaling_policy.name,
+                  'ScalingAdjustment': scaling_policy.scaling_adjustment}
+        if scaling_policy.cooldown is not None:
+            params['Cooldown'] = scaling_policy.cooldown
+
+        return self.get_object('PutScalingPolicy', params, Request)
+
+    def delete_launch_configuration(self, launch_config_name):
+        """
+        Deletes the specified LaunchConfiguration.
+
+        The specified launch configuration must not be attached to an Auto
+        Scaling group. Once this call completes, the launch configuration is no
+        longer available for use.
+        """
+        params = {'LaunchConfigurationName': launch_config_name}
+        return self.get_object('DeleteLaunchConfiguration', params, Request)
+
+    def get_all_groups(self, names=None, max_records=None, next_token=None):
+        """
+        Returns a full description of each Auto Scaling group in the given
+        list. This includes all Amazon EC2 instances that are members of the
+        group. If a list of names is not provided, the service returns the full
+        details of all Auto Scaling groups.
+
+        This action supports pagination by returning a token if there are more
+        pages to retrieve. To get the next page, call this action again with
+        the returned token as the NextToken parameter.
+
+        :type names: list
+        :param names: List of group names which should be searched for.
+
+        :type max_records: int
+        :param max_records: Maximum amount of groups to return.
+
+        :rtype: list
+        :returns: List of :class:`boto.ec2.autoscale.group.AutoScalingGroup`
+            instances.
+        """
+        params = {}
+        if max_records:
+            params['MaxRecords'] = max_records
+        if next_token:
+            params['NextToken'] = next_token
+        if names:
+            self.build_list_params(params, names, 'AutoScalingGroupNames')
+        return self.get_list('DescribeAutoScalingGroups', params,
+                             [('member', AutoScalingGroup)])
+
+    def get_all_launch_configurations(self, **kwargs):
+        """
+        Returns a full description of the launch configurations given the
+        specified names.
+
+        If no names are specified, then the full details of all launch
+        configurations are returned.
+
+        :type names: list
+        :param names: List of configuration names which should be searched for.
+
+        :type max_records: int
+        :param max_records: Maximum amount of configurations to return.
+
+        :type next_token: str
+        :param next_token: If you have more results than can be returned
+            at once, pass in this  parameter to page through all results.
+
+        :rtype: list
+        :returns: List of
+            :class:`boto.ec2.autoscale.launchconfig.LaunchConfiguration`
+            instances.
+        """
+        params = {}
+        max_records = kwargs.get('max_records', None)
+        names = kwargs.get('names', None)
+        if max_records is not None:
+            params['MaxRecords'] = max_records
+        if names:
+            self.build_list_params(params, names, 'LaunchConfigurationNames')
+        next_token = kwargs.get('next_token')
+        if next_token:
+            params['NextToken'] = next_token
+        return self.get_list('DescribeLaunchConfigurations', params,
+                             [('member', LaunchConfiguration)])
+
+    def get_all_activities(self, autoscale_group, activity_ids=None,
+                           max_records=None, next_token=None):
+        """
+        Get all activities for the given autoscaling group.
+
+        This action supports pagination by returning a token if there are more
+        pages to retrieve. To get the next page, call this action again with
+        the returned token as the NextToken parameter
+
+        :type autoscale_group: str or
+            :class:`boto.ec2.autoscale.group.AutoScalingGroup` object
+        :param autoscale_group: The auto scaling group to get activities on.
+
+        :type max_records: int
+        :param max_records: Maximum amount of activities to return.
+
+        :rtype: list
+        :returns: List of
+            :class:`boto.ec2.autoscale.activity.Activity` instances.
+        """
+        name = autoscale_group
+        if isinstance(autoscale_group, AutoScalingGroup):
+            name = autoscale_group.name
+        params = {'AutoScalingGroupName': name}
+        if max_records:
+            params['MaxRecords'] = max_records
+        if next_token:
+            params['NextToken'] = next_token
+        if activity_ids:
+            self.build_list_params(params, activity_ids, 'ActivityIds')
+        return self.get_list('DescribeScalingActivities',
+                             params, [('member', Activity)])
+
+    def get_termination_policies(self):
+        """Gets all valid termination policies.
+
+        These values can then be used as the termination_policies arg
+        when creating and updating autoscale groups.
+        """
+        return self.get_object('DescribeTerminationPolicyTypes',
+                               {}, TerminationPolicies)
+
+    def delete_scheduled_action(self, scheduled_action_name,
+                                autoscale_group=None):
+        """
+        Deletes a previously scheduled action.
+
+        :type scheduled_action_name: str
+        :param scheduled_action_name: The name of the action you want
+            to delete.
+
+        :type autoscale_group: str
+        :param autoscale_group: The name of the autoscale group.
+        """
+        params = {'ScheduledActionName': scheduled_action_name}
+        if autoscale_group:
+            params['AutoScalingGroupName'] = autoscale_group
+        return self.get_status('DeleteScheduledAction', params)
+
+    def terminate_instance(self, instance_id, decrement_capacity=True):
+        """
+        Terminates the specified instance. The desired group size can
+        also be adjusted, if desired.
+
+        :type instance_id: str
+        :param instance_id: The ID of the instance to be terminated.
+
+        :type decrement_capability: bool
+        :param decrement_capacity: Whether to decrement the size of the
+            autoscaling group or not.
+        """
+        params = {'InstanceId': instance_id}
+        if decrement_capacity:
+            params['ShouldDecrementDesiredCapacity'] = 'true'
+        else:
+            params['ShouldDecrementDesiredCapacity'] = 'false'
+        return self.get_object('TerminateInstanceInAutoScalingGroup', params,
+                               Activity)
+
+    def delete_policy(self, policy_name, autoscale_group=None):
+        """
+        Delete a policy.
+
+        :type policy_name: str
+        :param policy_name: The name or ARN of the policy to delete.
+
+        :type autoscale_group: str
+        :param autoscale_group: The name of the autoscale group.
+        """
+        params = {'PolicyName': policy_name}
+        if autoscale_group:
+            params['AutoScalingGroupName'] = autoscale_group
+        return self.get_status('DeletePolicy', params)
+
+    def get_all_adjustment_types(self):
+        return self.get_list('DescribeAdjustmentTypes', {},
+                             [('member', AdjustmentType)])
+
+    def get_all_autoscaling_instances(self, instance_ids=None,
+                                      max_records=None, next_token=None):
+        """
+        Returns a description of each Auto Scaling instance in the instance_ids
+        list. If a list is not provided, the service returns the full details
+        of all instances up to a maximum of fifty.
+
+        This action supports pagination by returning a token if there are more
+        pages to retrieve. To get the next page, call this action again with
+        the returned token as the NextToken parameter.
+
+        :type instance_ids: list
+        :param instance_ids: List of Autoscaling Instance IDs which should be
+            searched for.
+
+        :type max_records: int
+        :param max_records: Maximum number of results to return.
+
+        :rtype: list
+        :returns: List of
+            :class:`boto.ec2.autoscale.instance.Instance` objects.
+        """
+        params = {}
+        if instance_ids:
+            self.build_list_params(params, instance_ids, 'InstanceIds')
+        if max_records:
+            params['MaxRecords'] = max_records
+        if next_token:
+            params['NextToken'] = next_token
+        return self.get_list('DescribeAutoScalingInstances',
+                             params, [('member', Instance)])
+
+    def get_all_metric_collection_types(self):
+        """
+        Returns a list of metrics and a corresponding list of granularities
+        for each metric.
+        """
+        return self.get_object('DescribeMetricCollectionTypes',
+                               {}, MetricCollectionTypes)
+
+    def get_all_policies(self, as_group=None, policy_names=None,
+                         max_records=None, next_token=None):
+        """
+        Returns descriptions of what each policy does. This action supports
+        pagination. If the response includes a token, there are more records
+        available. To get the additional records, repeat the request with the
+        response token as the NextToken parameter.
+
+        If no group name or list of policy names are provided, all
+        available policies are returned.
+
+        :type as_name: str
+        :param as_name: The name of the
+            :class:`boto.ec2.autoscale.group.AutoScalingGroup` to filter for.
+
+        :type names: list
+        :param names: List of policy names which should be searched for.
+
+        :type max_records: int
+        :param max_records: Maximum amount of groups to return.
+        """
+        params = {}
+        if as_group:
+            params['AutoScalingGroupName'] = as_group
+        if policy_names:
+            self.build_list_params(params, policy_names, 'PolicyNames')
+        if max_records:
+            params['MaxRecords'] = max_records
+        if next_token:
+            params['NextToken'] = next_token
+        return self.get_list('DescribePolicies', params,
+                             [('member', ScalingPolicy)])
+
+    def get_all_scaling_process_types(self):
+        """
+        Returns scaling process types for use in the ResumeProcesses and
+        SuspendProcesses actions.
+        """
+        return self.get_list('DescribeScalingProcessTypes', {},
+                             [('member', ProcessType)])
+
+    def suspend_processes(self, as_group, scaling_processes=None):
+        """
+        Suspends Auto Scaling processes for an Auto Scaling group.
+
+        :type as_group: string
+        :param as_group: The auto scaling group to suspend processes on.
+
+        :type scaling_processes: list
+        :param scaling_processes: Processes you want to suspend. If omitted,
+            all processes will be suspended.
+        """
+        params = {'AutoScalingGroupName': as_group}
+        if scaling_processes:
+            self.build_list_params(params, scaling_processes,
+                                   'ScalingProcesses')
+        return self.get_status('SuspendProcesses', params)
+
+    def resume_processes(self, as_group, scaling_processes=None):
+        """
+        Resumes Auto Scaling processes for an Auto Scaling group.
+
+        :type as_group: string
+        :param as_group: The auto scaling group to resume processes on.
+
+        :type scaling_processes: list
+        :param scaling_processes: Processes you want to resume. If omitted, all
+            processes will be resumed.
+        """
+        params = {'AutoScalingGroupName': as_group}
+
+        if scaling_processes:
+            self.build_list_params(params, scaling_processes,
+                                   'ScalingProcesses')
+        return self.get_status('ResumeProcesses', params)
+
+    def create_scheduled_group_action(self, as_group, name, time,
+                                      desired_capacity=None,
+                                      min_size=None, max_size=None):
+        """
+        Creates a scheduled scaling action for a Auto Scaling group. If you
+        leave a parameter unspecified, the corresponding value remains
+        unchanged in the affected Auto Scaling group.
+
+        :type as_group: string
+        :param as_group: The auto scaling group to get activities on.
+
+        :type name: string
+        :param name: Scheduled action name.
+
+        :type time: datetime.datetime
+        :param time: The time for this action to start.
+
+        :type desired_capacity: int
+        :param desired_capacity: The number of EC2 instances that should
+            be running in this group.
+
+        :type min_size: int
+        :param min_size: The minimum size for the new auto scaling group.
+
+        :type max_size: int
+        :param max_size: The minimum size for the new auto scaling group.
+        """
+        params = {'AutoScalingGroupName': as_group,
+                  'ScheduledActionName': name,
+                  'Time': time.isoformat()}
+        if desired_capacity is not None:
+            params['DesiredCapacity'] = desired_capacity
+        if min_size is not None:
+            params['MinSize'] = min_size
+        if max_size is not None:
+            params['MaxSize'] = max_size
+        return self.get_status('PutScheduledUpdateGroupAction', params)
+
+    def get_all_scheduled_actions(self, as_group=None, start_time=None,
+                                  end_time=None, scheduled_actions=None,
+                                  max_records=None, next_token=None):
+        params = {}
+        if as_group:
+            params['AutoScalingGroupName'] = as_group
+        if scheduled_actions:
+            self.build_list_params(params, scheduled_actions,
+                                   'ScheduledActionNames')
+        if max_records:
+            params['MaxRecords'] = max_records
+        if next_token:
+            params['NextToken'] = next_token
+        return self.get_list('DescribeScheduledActions', params,
+                             [('member', ScheduledUpdateGroupAction)])
+
+    def disable_metrics_collection(self, as_group, metrics=None):
+        """
+        Disables monitoring of group metrics for the Auto Scaling group
+        specified in AutoScalingGroupName. You can specify the list of affected
+        metrics with the Metrics parameter.
+        """
+        params = {'AutoScalingGroupName': as_group}
+
+        if metrics:
+            self.build_list_params(params, metrics, 'Metrics')
+        return self.get_status('DisableMetricsCollection', params)
+
+    def enable_metrics_collection(self, as_group, granularity, metrics=None):
+        """
+        Enables monitoring of group metrics for the Auto Scaling group
+        specified in AutoScalingGroupName. You can specify the list of enabled
+        metrics with the Metrics parameter.
+
+        Auto scaling metrics collection can be turned on only if the
+        InstanceMonitoring.Enabled flag, in the Auto Scaling group's launch
+        configuration, is set to true.
+
+        :type autoscale_group: string
+        :param autoscale_group: The auto scaling group to get activities on.
+
+        :type granularity: string
+        :param granularity: The granularity to associate with the metrics to
+            collect. Currently, the only legal granularity is "1Minute".
+
+        :type metrics: string list
+        :param metrics: The list of metrics to collect. If no metrics are
+                        specified, all metrics are enabled.
+        """
+        params = {'AutoScalingGroupName': as_group,
+                  'Granularity': granularity}
+        if metrics:
+            self.build_list_params(params, metrics, 'Metrics')
+        return self.get_status('EnableMetricsCollection', params)
+
+    def execute_policy(self, policy_name, as_group=None, honor_cooldown=None):
+        params = {'PolicyName': policy_name}
+        if as_group:
+            params['AutoScalingGroupName'] = as_group
+        if honor_cooldown:
+            params['HonorCooldown'] = honor_cooldown
+        return self.get_status('ExecutePolicy', params)
+
+    def put_notification_configuration(self, autoscale_group, topic, notification_types):
+        """
+        Configures an Auto Scaling group to send notifications when
+        specified events take place.
+
+        :type as_group: str or
+            :class:`boto.ec2.autoscale.group.AutoScalingGroup` object
+        :param as_group: The Auto Scaling group to put notification
+            configuration on.
+
+        :type topic: str
+        :param topic: The Amazon Resource Name (ARN) of the Amazon Simple
+            Notification Service (SNS) topic.
+
+        :type notification_types: list
+        :param notification_types: The type of events that will trigger
+            the notification.
+        """
+
+        name = autoscale_group
+        if isinstance(autoscale_group, AutoScalingGroup):
+            name = autoscale_group.name
+
+        params = {'AutoScalingGroupName': name,
+                  'TopicARN': topic}
+        self.build_list_params(params, notification_types, 'NotificationTypes')
+        return self.get_status('PutNotificationConfiguration', params)
+
+    def set_instance_health(self, instance_id, health_status,
+                            should_respect_grace_period=True):
+        """
+        Explicitly set the health status of an instance.
+
+        :type instance_id: str
+        :param instance_id: The identifier of the EC2 instance.
+
+        :type health_status: str
+        :param health_status: The health status of the instance.
+            "Healthy" means that the instance is healthy and should remain
+            in service. "Unhealthy" means that the instance is unhealthy.
+            Auto Scaling should terminate and replace it.
+
+        :type should_respect_grace_period: bool
+        :param should_respect_grace_period: If True, this call should
+            respect the grace period associated with the group.
+        """
+        params = {'InstanceId': instance_id,
+                  'HealthStatus': health_status}
+        if should_respect_grace_period:
+            params['ShouldRespectGracePeriod'] = 'true'
+        else:
+            params['ShouldRespectGracePeriod'] = 'false'
+        return self.get_status('SetInstanceHealth', params)
+
+    def set_desired_capacity(self, group_name, desired_capacity, honor_cooldown=False):
+        """
+        Adjusts the desired size of the AutoScalingGroup by initiating scaling
+        activities. When reducing the size of the group, it is not possible to define
+        which Amazon EC2 instances will be terminated. This applies to any Auto Scaling
+        decisions that might result in terminating instances.
+
+        :type group_name: string
+        :param group_name: name of the auto scaling group
+
+        :type desired_capacity: integer
+        :param desired_capacity: new capacity setting for auto scaling group
+
+        :type honor_cooldown: boolean
+        :param honor_cooldown: by default, overrides any cooldown period
+        """
+        params = {'AutoScalingGroupName': group_name,
+                  'DesiredCapacity': desired_capacity}
+        if honor_cooldown:
+            params['HonorCooldown'] = json.dumps('True')
+
+        return self.get_status('SetDesiredCapacity', params)
+
+    # Tag methods
+
+    def get_all_tags(self, filters=None, max_records=None, next_token=None):
+        """
+        Lists the Auto Scaling group tags.
+
+        This action supports pagination by returning a token if there
+        are more pages to retrieve. To get the next page, call this
+        action again with the returned token as the NextToken
+        parameter.
+
+        :type filters: dict
+        :param filters: The value of the filter type used to identify
+            the tags to be returned.  NOT IMPLEMENTED YET.
+
+        :type max_records: int
+        :param max_records: Maximum number of tags to return.
+
+        :rtype: list
+        :returns: List of :class:`boto.ec2.autoscale.tag.Tag`
+            instances.
+        """
+        params = {}
+        if max_records:
+            params['MaxRecords'] = max_records
+        if next_token:
+            params['NextToken'] = next_token
+        return self.get_list('DescribeTags', params,
+                             [('member', Tag)])
+
+    def create_or_update_tags(self, tags):
+        """
+        Creates new tags or updates existing tags for an Auto Scaling group.
+
+        :type tags: List of :class:`boto.ec2.autoscale.tag.Tag`
+        :param tags: The new or updated tags.
+        """
+        params = {}
+        for i, tag in enumerate(tags):
+            tag.build_params(params, i + 1)
+        return self.get_status('CreateOrUpdateTags', params, verb='POST')
+
+    def delete_tags(self, tags):
+        """
+        Deletes existing tags for an Auto Scaling group.
+
+        :type tags: List of :class:`boto.ec2.autoscale.tag.Tag`
+        :param tags: The new or updated tags.
+        """
+        params = {}
+        for i, tag in enumerate(tags):
+            tag.build_params(params, i + 1)
+        return self.get_status('DeleteTags', params, verb='POST')