Remove telemetry/third_party/gsutilz

tools/telemetry/third_party/gsutilz/third_party/boto/boto/ec2/elb/__init__.py

Index: tools/telemetry/third_party/gsutilz/third_party/boto/boto/ec2/elb/__init__.py
diff --git a/tools/telemetry/third_party/gsutilz/third_party/boto/boto/ec2/elb/__init__.py b/tools/telemetry/third_party/gsutilz/third_party/boto/boto/ec2/elb/__init__.py
deleted file mode 100644
index bae45cf42bf1a7e1f4ed5248601efe3247aaa072..0000000000000000000000000000000000000000
--- a/tools/telemetry/third_party/gsutilz/third_party/boto/boto/ec2/elb/__init__.py
+++ /dev/null
@@ -1,758 +0,0 @@
-# Copyright (c) 2006-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)
-load balancing service from AWS.
-"""
-from boto.connection import AWSQueryConnection
-from boto.ec2.instanceinfo import InstanceInfo
-from boto.ec2.elb.loadbalancer import LoadBalancer, LoadBalancerZones
-from boto.ec2.elb.instancestate import InstanceState
-from boto.ec2.elb.healthcheck import HealthCheck
-from boto.regioninfo import RegionInfo, get_regions, load_regions
-import boto
-from boto.compat import six
-
-RegionData = load_regions().get('elasticloadbalancing', {})
-
-
-def regions():
-    """
-    Get all available regions for the ELB service.
-
-    :rtype: list
-    :return: A list of :class:`boto.RegionInfo` instances
-    """
-    return get_regions('elasticloadbalancing', connection_cls=ELBConnection)
-
-
-def connect_to_region(region_name, **kw_params):
-    """
-    Given a valid region name, return a
-    :class:`boto.ec2.elb.ELBConnection`.
-
-    :param str region_name: The name of the region to connect to.
-
-    :rtype: :class:`boto.ec2.ELBConnection` 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 ELBConnection(AWSQueryConnection):
-
-    APIVersion = boto.config.get('Boto', 'elb_version', '2012-06-01')
-    DefaultRegionName = boto.config.get('Boto', 'elb_region_name', 'us-east-1')
-    DefaultRegionEndpoint = boto.config.get(
-        'Boto', 'elb_region_endpoint',
-        'elasticloadbalancing.us-east-1.amazonaws.com')
-
-    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, profile_name=None):
-        """
-        Init method to create a new connection to EC2 Load Balancing Service.
-
-        .. note:: The region argument is overridden by the region specified in
-            the boto configuration file.
-        """
-        if not region:
-            region = RegionInfo(self, self.DefaultRegionName,
-                                self.DefaultRegionEndpoint)
-        self.region = region
-        super(ELBConnection, self).__init__(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,
-                                            security_token,
-                                            validate_certs=validate_certs,
-                                            profile_name=profile_name)
-
-    def _required_auth_capability(self):
-        return ['hmac-v4']
-
-    def build_list_params(self, params, items, label):
-        if isinstance(items, six.string_types):
-            items = [items]
-        for index, item in enumerate(items):
-            params[label % (index + 1)] = item
-
-    def get_all_load_balancers(self, load_balancer_names=None, marker=None):
-        """
-        Retrieve all load balancers associated with your account.
-
-        :type load_balancer_names: list
-        :keyword load_balancer_names: An optional list of load balancer names.
-
-        :type marker: string
-        :param marker: Use this only when paginating results and only
-            in follow-up request after you've received a response
-            where the results are truncated.  Set this to the value of
-            the Marker element in the response you just received.
-
-        :rtype: :py:class:`boto.resultset.ResultSet`
-        :return: A ResultSet containing instances of
-            :class:`boto.ec2.elb.loadbalancer.LoadBalancer`
-        """
-        params = {}
-        if load_balancer_names:
-            self.build_list_params(params, load_balancer_names,
-                                   'LoadBalancerNames.member.%d')
-
-        if marker:
-            params['Marker'] = marker
-
-        return self.get_list('DescribeLoadBalancers', params,
-                             [('member', LoadBalancer)])
-
-    def create_load_balancer(self, name, zones, listeners=None, subnets=None,
-                             security_groups=None, scheme='internet-facing',
-                             complex_listeners=None):
-        """
-        Create a new load balancer for your account. By default the load
-        balancer will be created in EC2. To create a load balancer inside a
-        VPC, parameter zones must be set to None and subnets must not be None.
-        The load balancer will be automatically created under the VPC that
-        contains the subnet(s) specified.
-
-        :type name: string
-        :param name: The mnemonic name associated with the new load balancer
-
-        :type zones: List of strings
-        :param zones: The names of the availability zone(s) to add.
-
-        :type listeners: List of tuples
-        :param listeners: Each tuple contains three or four values,
-            (LoadBalancerPortNumber, InstancePortNumber, Protocol,
-            [SSLCertificateId]) where LoadBalancerPortNumber and
-            InstancePortNumber are integer values between 1 and 65535,
-            Protocol is a string containing either 'TCP', 'SSL', HTTP', or
-            'HTTPS'; SSLCertificateID is the ARN of a AWS IAM
-            certificate, and must be specified when doing HTTPS.
-
-        :type subnets: list of strings
-        :param subnets: A list of subnet IDs in your VPC to attach to
-            your LoadBalancer.
-
-        :type security_groups: list of strings
-        :param security_groups: The security groups assigned to your
-            LoadBalancer within your VPC.
-
-        :type scheme: string
-        :param scheme: The type of a LoadBalancer.  By default, Elastic
-            Load Balancing creates an internet-facing LoadBalancer with
-            a publicly resolvable DNS name, which resolves to public IP
-            addresses.
-
-            Specify the value internal for this option to create an
-            internal LoadBalancer with a DNS name that resolves to
-            private IP addresses.
-
-            This option is only available for LoadBalancers attached
-            to an Amazon VPC.
-
-        :type complex_listeners: List of tuples
-        :param complex_listeners: Each tuple contains four or five values,
-            (LoadBalancerPortNumber, InstancePortNumber, Protocol,
-             InstanceProtocol, SSLCertificateId).
-
-            Where:
-                - LoadBalancerPortNumber and InstancePortNumber are integer
-                  values between 1 and 65535
-                - Protocol and InstanceProtocol is a string containing
-                  either 'TCP',
-                  'SSL', 'HTTP', or 'HTTPS'
-                - SSLCertificateId is the ARN of an SSL certificate loaded into
-                  AWS IAM
-
-        :rtype: :class:`boto.ec2.elb.loadbalancer.LoadBalancer`
-        :return: The newly created
-            :class:`boto.ec2.elb.loadbalancer.LoadBalancer`
-        """
-        if not listeners and not complex_listeners:
-            # Must specify one of the two options
-            return None
-
-        params = {'LoadBalancerName': name,
-                  'Scheme': scheme}
-
-        # Handle legacy listeners
-        if listeners:
-            for index, listener in enumerate(listeners):
-                i = index + 1
-                protocol = listener[2].upper()
-                params['Listeners.member.%d.LoadBalancerPort' % i] = listener[0]
-                params['Listeners.member.%d.InstancePort' % i] = listener[1]
-                params['Listeners.member.%d.Protocol' % i] = listener[2]
-                if protocol == 'HTTPS' or protocol == 'SSL':
-                    params['Listeners.member.%d.SSLCertificateId' % i] = listener[3]
-
-        # Handle the full listeners
-        if complex_listeners:
-            for index, listener in enumerate(complex_listeners):
-                i = index + 1
-                protocol = listener[2].upper()
-                InstanceProtocol = listener[3].upper()
-                params['Listeners.member.%d.LoadBalancerPort' % i] = listener[0]
-                params['Listeners.member.%d.InstancePort' % i] = listener[1]
-                params['Listeners.member.%d.Protocol' % i] = listener[2]
-                params['Listeners.member.%d.InstanceProtocol' % i] = listener[3]
-                if protocol == 'HTTPS' or protocol == 'SSL':
-                    params['Listeners.member.%d.SSLCertificateId' % i] = listener[4]
-
-        if zones:
-            self.build_list_params(params, zones, 'AvailabilityZones.member.%d')
-
-        if subnets:
-            self.build_list_params(params, subnets, 'Subnets.member.%d')
-
-        if security_groups:
-            self.build_list_params(params, security_groups,
-                                   'SecurityGroups.member.%d')
-
-        load_balancer = self.get_object('CreateLoadBalancer',
-                                        params, LoadBalancer)
-        load_balancer.name = name
-        load_balancer.listeners = listeners
-        load_balancer.availability_zones = zones
-        load_balancer.subnets = subnets
-        load_balancer.security_groups = security_groups
-        return load_balancer
-
-    def create_load_balancer_listeners(self, name, listeners=None,
-                                       complex_listeners=None):
-        """
-        Creates a Listener (or group of listeners) for an existing
-        Load Balancer
-
-        :type name: string
-        :param name: The name of the load balancer to create the listeners for
-
-        :type listeners: List of tuples
-        :param listeners: Each tuple contains three or four values,
-            (LoadBalancerPortNumber, InstancePortNumber, Protocol,
-            [SSLCertificateId]) where LoadBalancerPortNumber and
-            InstancePortNumber are integer values between 1 and 65535,
-            Protocol is a string containing either 'TCP', 'SSL', HTTP', or
-            'HTTPS'; SSLCertificateID is the ARN of a AWS IAM
-            certificate, and must be specified when doing HTTPS.
-
-        :type complex_listeners: List of tuples
-        :param complex_listeners: Each tuple contains four or five values,
-            (LoadBalancerPortNumber, InstancePortNumber, Protocol,
-             InstanceProtocol, SSLCertificateId).
-
-            Where:
-                - LoadBalancerPortNumber and InstancePortNumber are integer
-                  values between 1 and 65535
-                - Protocol and InstanceProtocol is a string containing
-                  either 'TCP',
-                  'SSL', 'HTTP', or 'HTTPS'
-                - SSLCertificateId is the ARN of an SSL certificate loaded into
-                  AWS IAM
-
-        :return: The status of the request
-        """
-        if not listeners and not complex_listeners:
-            # Must specify one of the two options
-            return None
-
-        params = {'LoadBalancerName': name}
-
-        # Handle the simple listeners
-        if listeners:
-            for index, listener in enumerate(listeners):
-                i = index + 1
-                protocol = listener[2].upper()
-                params['Listeners.member.%d.LoadBalancerPort' % i] = listener[0]
-                params['Listeners.member.%d.InstancePort' % i] = listener[1]
-                params['Listeners.member.%d.Protocol' % i] = listener[2]
-                if protocol == 'HTTPS' or protocol == 'SSL':
-                    params['Listeners.member.%d.SSLCertificateId' % i] = listener[3]
-
-        # Handle the full listeners
-        if complex_listeners:
-            for index, listener in enumerate(complex_listeners):
-                i = index + 1
-                protocol = listener[2].upper()
-                InstanceProtocol = listener[3].upper()
-                params['Listeners.member.%d.LoadBalancerPort' % i] = listener[0]
-                params['Listeners.member.%d.InstancePort' % i] = listener[1]
-                params['Listeners.member.%d.Protocol' % i] = listener[2]
-                params['Listeners.member.%d.InstanceProtocol' % i] = listener[3]
-                if protocol == 'HTTPS' or protocol == 'SSL':
-                    params['Listeners.member.%d.SSLCertificateId' % i] = listener[4]
-
-        return self.get_status('CreateLoadBalancerListeners', params)
-
-    def delete_load_balancer(self, name):
-        """
-        Delete a Load Balancer from your account.
-
-        :type name: string
-        :param name: The name of the Load Balancer to delete
-        """
-        params = {'LoadBalancerName': name}
-        return self.get_status('DeleteLoadBalancer', params)
-
-    def delete_load_balancer_listeners(self, name, ports):
-        """
-        Deletes a load balancer listener (or group of listeners)
-
-        :type name: string
-        :param name: The name of the load balancer to create the listeners for
-
-        :type ports: List int
-        :param ports: Each int represents the port on the ELB to be removed
-
-        :return: The status of the request
-        """
-        params = {'LoadBalancerName': name}
-        for index, port in enumerate(ports):
-            params['LoadBalancerPorts.member.%d' % (index + 1)] = port
-        return self.get_status('DeleteLoadBalancerListeners', params)
-
-    def enable_availability_zones(self, load_balancer_name, zones_to_add):
-        """
-        Add availability zones to an existing Load Balancer
-        All zones must be in the same region as the Load Balancer
-        Adding zones that are already registered with the Load Balancer
-        has no effect.
-
-        :type load_balancer_name: string
-        :param load_balancer_name: The name of the Load Balancer
-
-        :type zones: List of strings
-        :param zones: The name of the zone(s) to add.
-
-        :rtype: List of strings
-        :return: An updated list of zones for this Load Balancer.
-
-        """
-        params = {'LoadBalancerName': load_balancer_name}
-        self.build_list_params(params, zones_to_add,
-                               'AvailabilityZones.member.%d')
-        obj = self.get_object('EnableAvailabilityZonesForLoadBalancer',
-                              params, LoadBalancerZones)
-        return obj.zones
-
-    def disable_availability_zones(self, load_balancer_name, zones_to_remove):
-        """
-        Remove availability zones from an existing Load Balancer.
-        All zones must be in the same region as the Load Balancer.
-        Removing zones that are not registered with the Load Balancer
-        has no effect.
-        You cannot remove all zones from an Load Balancer.
-
-        :type load_balancer_name: string
-        :param load_balancer_name: The name of the Load Balancer
-
-        :type zones: List of strings
-        :param zones: The name of the zone(s) to remove.
-
-        :rtype: List of strings
-        :return: An updated list of zones for this Load Balancer.
-
-        """
-        params = {'LoadBalancerName': load_balancer_name}
-        self.build_list_params(params, zones_to_remove,
-                               'AvailabilityZones.member.%d')
-        obj = self.get_object('DisableAvailabilityZonesForLoadBalancer',
-                              params, LoadBalancerZones)
-        return obj.zones
-
-    def modify_lb_attribute(self, load_balancer_name, attribute, value):
-        """Changes an attribute of a Load Balancer
-
-        :type load_balancer_name: string
-        :param load_balancer_name: The name of the Load Balancer
-
-        :type attribute: string
-        :param attribute: The attribute you wish to change.
-
-        * crossZoneLoadBalancing - Boolean (true)
-        * connectingSettings - :py:class:`ConnectionSettingAttribute` instance
-        * accessLog - :py:class:`AccessLogAttribute` instance
-        * connectionDraining - :py:class:`ConnectionDrainingAttribute` instance
-
-        :type value: string
-        :param value: The new value for the attribute
-
-        :rtype: bool
-        :return: Whether the operation succeeded or not
-        """
-
-        bool_reqs = ('crosszoneloadbalancing',)
-        if attribute.lower() in bool_reqs:
-            if isinstance(value, bool):
-                if value:
-                    value = 'true'
-                else:
-                    value = 'false'
-
-        params = {'LoadBalancerName': load_balancer_name}
-        if attribute.lower() == 'crosszoneloadbalancing':
-            params['LoadBalancerAttributes.CrossZoneLoadBalancing.Enabled'
-                   ] = value
-        elif attribute.lower() == 'accesslog':
-            params['LoadBalancerAttributes.AccessLog.Enabled'] = \
-                value.enabled and 'true' or 'false'
-            params['LoadBalancerAttributes.AccessLog.S3BucketName'] = \
-                value.s3_bucket_name
-            params['LoadBalancerAttributes.AccessLog.S3BucketPrefix'] = \
-                value.s3_bucket_prefix
-            params['LoadBalancerAttributes.AccessLog.EmitInterval'] = \
-                value.emit_interval
-        elif attribute.lower() == 'connectiondraining':
-            params['LoadBalancerAttributes.ConnectionDraining.Enabled'] = \
-                value.enabled and 'true' or 'false'
-            params['LoadBalancerAttributes.ConnectionDraining.Timeout'] = \
-                value.timeout
-        elif attribute.lower() == 'connectingsettings':
-            params['LoadBalancerAttributes.ConnectionSettings.IdleTimeout'] = \
-                value.idle_timeout
-        else:
-            raise ValueError('InvalidAttribute', attribute)
-        return self.get_status('ModifyLoadBalancerAttributes', params,
-                               verb='GET')
-
-    def get_all_lb_attributes(self, load_balancer_name):
-        """Gets all Attributes of a Load Balancer
-
-        :type load_balancer_name: string
-        :param load_balancer_name: The name of the Load Balancer
-
-        :rtype: boto.ec2.elb.attribute.LbAttributes
-        :return: The attribute object of the ELB.
-        """
-        from boto.ec2.elb.attributes import LbAttributes
-        params = {'LoadBalancerName': load_balancer_name}
-        return self.get_object('DescribeLoadBalancerAttributes',
-                               params, LbAttributes)
-
-    def get_lb_attribute(self, load_balancer_name, attribute):
-        """Gets an attribute of a Load Balancer
-
-        This will make an EC2 call for each method call.
-
-        :type load_balancer_name: string
-        :param load_balancer_name: The name of the Load Balancer
-
-        :type attribute: string
-        :param attribute: The attribute you wish to see.
-
-          * accessLog - :py:class:`AccessLogAttribute` instance
-          * crossZoneLoadBalancing - Boolean
-          * connectingSettings - :py:class:`ConnectionSettingAttribute` instance
-          * connectionDraining - :py:class:`ConnectionDrainingAttribute`
-            instance
-
-        :rtype: Attribute dependent
-        :return: The new value for the attribute
-        """
-        attributes = self.get_all_lb_attributes(load_balancer_name)
-        if attribute.lower() == 'accesslog':
-            return attributes.access_log
-        if attribute.lower() == 'crosszoneloadbalancing':
-            return attributes.cross_zone_load_balancing.enabled
-        if attribute.lower() == 'connectiondraining':
-            return attributes.connection_draining
-        if attribute.lower() == 'connectingsettings':
-            return attributes.connecting_settings
-        return None
-
-    def register_instances(self, load_balancer_name, instances):
-        """
-        Add new Instances to an existing Load Balancer.
-
-        :type load_balancer_name: string
-        :param load_balancer_name: The name of the Load Balancer
-
-        :type instances: List of strings
-        :param instances: The instance ID's of the EC2 instances to add.
-
-        :rtype: List of strings
-        :return: An updated list of instances for this Load Balancer.
-
-        """
-        params = {'LoadBalancerName': load_balancer_name}
-        self.build_list_params(params, instances,
-                               'Instances.member.%d.InstanceId')
-        return self.get_list('RegisterInstancesWithLoadBalancer',
-                             params, [('member', InstanceInfo)])
-
-    def deregister_instances(self, load_balancer_name, instances):
-        """
-        Remove Instances from an existing Load Balancer.
-
-        :type load_balancer_name: string
-        :param load_balancer_name: The name of the Load Balancer
-
-        :type instances: List of strings
-        :param instances: The instance ID's of the EC2 instances to remove.
-
-        :rtype: List of strings
-        :return: An updated list of instances for this Load Balancer.
-
-        """
-        params = {'LoadBalancerName': load_balancer_name}
-        self.build_list_params(params, instances,
-                               'Instances.member.%d.InstanceId')
-        return self.get_list('DeregisterInstancesFromLoadBalancer',
-                             params, [('member', InstanceInfo)])
-
-    def describe_instance_health(self, load_balancer_name, instances=None):
-        """
-        Get current state of all Instances registered to an Load Balancer.
-
-        :type load_balancer_name: string
-        :param load_balancer_name: The name of the Load Balancer
-
-        :type instances: List of strings
-        :param instances: The instance ID's of the EC2 instances
-                          to return status for.  If not provided,
-                          the state of all instances will be returned.
-
-        :rtype: List of :class:`boto.ec2.elb.instancestate.InstanceState`
-        :return: list of state info for instances in this Load Balancer.
-
-        """
-        params = {'LoadBalancerName': load_balancer_name}
-        if instances:
-            self.build_list_params(params, instances,
-                                   'Instances.member.%d.InstanceId')
-        return self.get_list('DescribeInstanceHealth', params,
-                             [('member', InstanceState)])
-
-    def configure_health_check(self, name, health_check):
-        """
-        Define a health check for the EndPoints.
-
-        :type name: string
-        :param name: The mnemonic name associated with the load balancer
-
-        :type health_check: :class:`boto.ec2.elb.healthcheck.HealthCheck`
-        :param health_check: A HealthCheck object populated with the desired
-                             values.
-
-        :rtype: :class:`boto.ec2.elb.healthcheck.HealthCheck`
-        :return: The updated :class:`boto.ec2.elb.healthcheck.HealthCheck`
-        """
-        params = {'LoadBalancerName': name,
-                  'HealthCheck.Timeout': health_check.timeout,
-                  'HealthCheck.Target': health_check.target,
-                  'HealthCheck.Interval': health_check.interval,
-                  'HealthCheck.UnhealthyThreshold': health_check.unhealthy_threshold,
-                  'HealthCheck.HealthyThreshold': health_check.healthy_threshold}
-        return self.get_object('ConfigureHealthCheck', params, HealthCheck)
-
-    def set_lb_listener_SSL_certificate(self, lb_name, lb_port,
-                                        ssl_certificate_id):
-        """
-        Sets the certificate that terminates the specified listener's SSL
-        connections. The specified certificate replaces any prior certificate
-        that was used on the same LoadBalancer and port.
-        """
-        params = {'LoadBalancerName': lb_name,
-                  'LoadBalancerPort': lb_port,
-                  'SSLCertificateId': ssl_certificate_id}
-        return self.get_status('SetLoadBalancerListenerSSLCertificate', params)
-
-    def create_app_cookie_stickiness_policy(self, name, lb_name, policy_name):
-        """
-        Generates a stickiness policy with sticky session lifetimes that follow
-        that of an application-generated cookie. This policy can only be
-        associated with HTTP listeners.
-
-        This policy is similar to the policy created by
-        CreateLBCookieStickinessPolicy, except that the lifetime of the special
-        Elastic Load Balancing cookie follows the lifetime of the
-        application-generated cookie specified in the policy configuration. The
-        load balancer only inserts a new stickiness cookie when the application
-        response includes a new application cookie.
-
-        If the application cookie is explicitly removed or expires, the session
-        stops being sticky until a new application cookie is issued.
-        """
-        params = {'CookieName': name,
-                  'LoadBalancerName': lb_name,
-                  'PolicyName': policy_name}
-        return self.get_status('CreateAppCookieStickinessPolicy', params)
-
-    def create_lb_cookie_stickiness_policy(self, cookie_expiration_period,
-                                           lb_name, policy_name):
-        """
-        Generates a stickiness policy with sticky session lifetimes controlled
-        by the lifetime of the browser (user-agent) or a specified expiration
-        period. This policy can only be associated only with HTTP listeners.
-
-        When a load balancer implements this policy, the load balancer uses a
-        special cookie to track the backend server instance for each request.
-        When the load balancer receives a request, it first checks to see if
-        this cookie is present in the request. If so, the load balancer sends
-        the request to the application server specified in the cookie. If not,
-        the load balancer sends the request to a server that is chosen based on
-        the existing load balancing algorithm.
-
-        A cookie is inserted into the response for binding subsequent requests
-        from the same user to that server. The validity of the cookie is based
-        on the cookie expiration time, which is specified in the policy
-        configuration.
-
-        None may be passed for cookie_expiration_period.
-        """
-        params = {'LoadBalancerName': lb_name,
-                  'PolicyName': policy_name}
-        if cookie_expiration_period is not None:
-            params['CookieExpirationPeriod'] = cookie_expiration_period
-        return self.get_status('CreateLBCookieStickinessPolicy', params)
-
-    def create_lb_policy(self, lb_name, policy_name, policy_type,
-                         policy_attributes):
-        """
-        Creates a new policy that contains the necessary attributes
-        depending on the policy type. Policies are settings that are
-        saved for your load balancer and that can be applied to the
-        front-end listener, or the back-end application server.
-
-        """
-        params = {'LoadBalancerName': lb_name,
-                  'PolicyName': policy_name,
-                  'PolicyTypeName': policy_type}
-        for index, (name, value) in enumerate(six.iteritems(policy_attributes), 1):
-            params['PolicyAttributes.member.%d.AttributeName' % index] = name
-            params['PolicyAttributes.member.%d.AttributeValue' % index] = value
-        else:
-            params['PolicyAttributes'] = ''
-        return self.get_status('CreateLoadBalancerPolicy', params)
-
-    def delete_lb_policy(self, lb_name, policy_name):
-        """
-        Deletes a policy from the LoadBalancer. The specified policy must not
-        be enabled for any listeners.
-        """
-        params = {'LoadBalancerName': lb_name,
-                  'PolicyName': policy_name}
-        return self.get_status('DeleteLoadBalancerPolicy', params)
-
-    def set_lb_policies_of_listener(self, lb_name, lb_port, policies):
-        """
-        Associates, updates, or disables a policy with a listener on the load
-        balancer. Currently only zero (0) or one (1) policy can be associated
-        with a listener.
-        """
-        params = {'LoadBalancerName': lb_name,
-                  'LoadBalancerPort': lb_port}
-        if len(policies):
-            self.build_list_params(params, policies, 'PolicyNames.member.%d')
-        else:
-            params['PolicyNames'] = ''
-        return self.get_status('SetLoadBalancerPoliciesOfListener', params)
-
-    def set_lb_policies_of_backend_server(self, lb_name, instance_port,
-                                          policies):
-        """
-        Replaces the current set of policies associated with a port on which
-        the back-end server is listening with a new set of policies.
-        """
-        params = {'LoadBalancerName': lb_name,
-                  'InstancePort': instance_port}
-        if policies:
-            self.build_list_params(params, policies, 'PolicyNames.member.%d')
-        else:
-            params['PolicyNames'] = ''
-        return self.get_status('SetLoadBalancerPoliciesForBackendServer',
-                               params)
-
-    def apply_security_groups_to_lb(self, name, security_groups):
-        """
-        Associates one or more security groups with the load balancer.
-        The provided security groups will override any currently applied
-        security groups.
-
-        :type name: string
-        :param name: The name of the Load Balancer
-
-        :type security_groups: List of strings
-        :param security_groups: The name of the security group(s) to add.
-
-        :rtype: List of strings
-        :return: An updated list of security groups for this Load Balancer.
-
-        """
-        params = {'LoadBalancerName': name}
-        self.build_list_params(params, security_groups,
-                               'SecurityGroups.member.%d')
-        return self.get_list('ApplySecurityGroupsToLoadBalancer',
-                             params, None)
-
-    def attach_lb_to_subnets(self, name, subnets):
-        """
-        Attaches load balancer to one or more subnets.
-        Attaching subnets that are already registered with the
-        Load Balancer has no effect.
-
-        :type name: string
-        :param name: The name of the Load Balancer
-
-        :type subnets: List of strings
-        :param subnets: The name of the subnet(s) to add.
-
-        :rtype: List of strings
-        :return: An updated list of subnets for this Load Balancer.
-
-        """
-        params = {'LoadBalancerName': name}
-        self.build_list_params(params, subnets,
-                               'Subnets.member.%d')
-        return self.get_list('AttachLoadBalancerToSubnets',
-                             params, None)
-
-    def detach_lb_from_subnets(self, name, subnets):
-        """
-        Detaches load balancer from one or more subnets.
-
-        :type name: string
-        :param name: The name of the Load Balancer
-
-        :type subnets: List of strings
-        :param subnets: The name of the subnet(s) to detach.
-
-        :rtype: List of strings
-        :return: An updated list of subnets for this Load Balancer.
-
-        """
-        params = {'LoadBalancerName': name}
-        self.build_list_params(params, subnets,
-                               'Subnets.member.%d')
-        return self.get_list('DetachLoadBalancerFromSubnets',
-                             params, None)