[catapult] - Copy Telemetry's gsutilz over to third_party.

third_party/gsutil/third_party/boto/boto/ec2/elb/__init__.py

Index: third_party/gsutil/third_party/boto/boto/ec2/elb/__init__.py
diff --git a/third_party/gsutil/third_party/boto/boto/ec2/elb/__init__.py b/third_party/gsutil/third_party/boto/boto/ec2/elb/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bae45cf42bf1a7e1f4ed5248601efe3247aaa072
--- /dev/null
+++ b/third_party/gsutil/third_party/boto/boto/ec2/elb/__init__.py
@@ -0,0 +1,758 @@
+# 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)