22

✏️ Editing: elb.py

# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

__all__ = ["ElasticLBDriver"]

from libcloud.utils.py3 import httplib
from libcloud.utils.xml import findall, findtext
from libcloud.common.aws import AWSGenericResponse, SignedAWSConnection
from libcloud.loadbalancer.base import Driver, Member, LoadBalancer
from libcloud.loadbalancer.types import State

VERSION = "2012-06-01"
HOST = "elasticloadbalancing.%s.amazonaws.com"
ROOT = "/%s/" % (VERSION)
NS = "http://elasticloadbalancing.amazonaws.com/doc/{}/".format(VERSION)

class ELBResponse(AWSGenericResponse):
    """
    Amazon ELB response class.
    """

namespace = NS
    exceptions = {}
    xpath = "Error"

class ELBConnection(SignedAWSConnection):
    version = VERSION
    host = HOST
    responseCls = ELBResponse
    service_name = "elasticloadbalancing"

class ElasticLBDriver(Driver):
    name = "Amazon Elastic Load Balancing"
    website = "http://aws.amazon.com/elasticloadbalancing/"
    connectionCls = ELBConnection
    signature_version = "4"

def __init__(self, access_id, secret, region, token=None):
        self.token = token
        self.region = region
        self.region_name = region
        super().__init__(access_id, secret, token=token, host=HOST % region, region=region)

def list_protocols(self):
        return ["tcp", "ssl", "http", "https"]

def list_balancers(self, ex_fetch_tags=False):
        params = {"Action": "DescribeLoadBalancers"}
        data = self.connection.request(ROOT, params=params).object
        balancers = self._to_balancers(data)

if ex_fetch_tags:
            for balancer in balancers:
                self._ex_populate_balancer_tags(balancer)

return balancers

def create_balancer(
        self,
        name,
        port,
        protocol,
        algorithm,
        members,
        ex_members_availability_zones=None,
    ):
        if ex_members_availability_zones is None:
            ex_members_availability_zones = ["a"]

params = {
            "Action": "CreateLoadBalancer",
            "LoadBalancerName": name,
            "Listeners.member.1.InstancePort": str(port),
            "Listeners.member.1.InstanceProtocol": protocol.upper(),
            "Listeners.member.1.LoadBalancerPort": str(port),
            "Listeners.member.1.Protocol": protocol.upper(),
        }

for i, z in enumerate(ex_members_availability_zones):
            zone = "".join((self.region, z))
            params["AvailabilityZones.member.%d" % (i + 1)] = zone

data = self.connection.request(ROOT, params=params).object

balancer = LoadBalancer(
            id=name,
            name=name,
            state=State.PENDING,
            ip=findtext(element=data, xpath="DNSName", namespace=NS),
            port=port,
            driver=self.connection.driver,
        )
        balancer._members = []
        return balancer

def destroy_balancer(self, balancer):
        params = {"Action": "DeleteLoadBalancer", "LoadBalancerName": balancer.id}
        self.connection.request(ROOT, params=params)
        return True

def get_balancer(self, balancer_id, ex_fetch_tags=False):
        params = {
            "Action": "DescribeLoadBalancers",
            "LoadBalancerNames.member.1": balancer_id,
        }
        data = self.connection.request(ROOT, params=params).object
        balancer = self._to_balancers(data)[0]

if ex_fetch_tags:
            balancer = self._ex_populate_balancer_tags(balancer)

return balancer

def balancer_attach_compute_node(self, balancer, node):
        params = {
            "Action": "RegisterInstancesWithLoadBalancer",
            "LoadBalancerName": balancer.id,
            "Instances.member.1.InstanceId": node.id,
        }
        self.connection.request(ROOT, params=params)
        balancer._members.append(Member(node.id, None, None, balancer=self))

def balancer_detach_member(self, balancer, member):
        params = {
            "Action": "DeregisterInstancesFromLoadBalancer",
            "LoadBalancerName": balancer.id,
            "Instances.member.1.InstanceId": member.id,
        }
        self.connection.request(ROOT, params=params)
        balancer._members = [m for m in balancer._members if m.id != member.id]
        return True

def balancer_list_members(self, balancer):
        return balancer._members

def ex_list_balancer_policies(self, balancer):
        """
        Return a list of policy description string.

:rtype: ``list`` of ``str``
        """
        params = {
            "Action": "DescribeLoadBalancerPolicies",
            "LoadBalancerName": balancer.id,
        }

data = self.connection.request(ROOT, params=params).object
        return self._to_policies(data)

def ex_list_balancer_policy_types(self):
        """
        Return a list of policy type description string.

:rtype: ``list`` of ``str``
        """
        params = {"Action": "DescribeLoadBalancerPolicyTypes"}

data = self.connection.request(ROOT, params=params).object
        return self._to_policy_types(data)

def ex_create_balancer_policy(self, name, policy_name, policy_type, policy_attributes=None):
        """
        Create a new load balancer policy

:param name: Balancer name to create the policy for
        :type  name: ``str``

:param policy_name: policy to be created
        :type  policy_name: ``str``

:param policy_type: policy type being used to create policy.
        :type  policy_type: ``str``

:param policy_attributes: Each list contain values, ['AttributeName',
                                                             'value']
        :type  policy_attributes: ``PolicyAttribute list``
        """
        params = {
            "Action": "CreateLoadBalancerPolicy",
            "LoadBalancerName": name,
            "PolicyName": policy_name,
            "PolicyTypeName": policy_type,
        }

if policy_attributes is not None:
            for index, (name, value) in enumerate(policy_attributes.iteritems(), 1):
                params["PolicyAttributes.member.%d. \
                        AttributeName" % (index)] = name
                params["PolicyAttributes.member.%d. \
                        AttributeValue" % (index)] = value