libcloud/loadbalancer/drivers/brightbox.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.


from libcloud.utils.py3 import httplib
from libcloud.utils.misc import reverse_dict
from libcloud.common.brightbox import BrightboxConnection
from libcloud.loadbalancer.base import Driver, Member, Algorithm, LoadBalancer
from libcloud.loadbalancer.types import State

API_VERSION = "1.0"


class BrightboxLBDriver(Driver):
    connectionCls = BrightboxConnection

    name = "Brightbox"
    website = "http://www.brightbox.co.uk/"

    LB_STATE_MAP = {
        "creating": State.PENDING,
        "active": State.RUNNING,
        "deleting": State.UNKNOWN,
        "deleted": State.UNKNOWN,
        "failing": State.UNKNOWN,
        "failed": State.UNKNOWN,
    }

    _VALUE_TO_ALGORITHM_MAP = {
        "round-robin": Algorithm.ROUND_ROBIN,
        "least-connections": Algorithm.LEAST_CONNECTIONS,
    }

    _ALGORITHM_TO_VALUE_MAP = reverse_dict(_VALUE_TO_ALGORITHM_MAP)

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

    def list_balancers(self):
        data = self.connection.request("/%s/load_balancers" % API_VERSION).object

        return list(map(self._to_balancer, data))

    def create_balancer(self, name, port, protocol, algorithm, members):
        response = self._post(
            "/%s/load_balancers" % API_VERSION,
            {
                "name": name,
                "nodes": list(map(self._member_to_node, members)),
                "policy": self._algorithm_to_value(algorithm),
                "listeners": [{"in": port, "out": port, "protocol": protocol}],
                "healthcheck": {"type": protocol, "port": port},
            },
        )

        return self._to_balancer(response.object)

    def destroy_balancer(self, balancer):
        response = self.connection.request(
            "/{}/load_balancers/{}".format(API_VERSION, balancer.id), method="DELETE"
        )

        return response.status == httplib.ACCEPTED

    def get_balancer(self, balancer_id):
        data = self.connection.request(
            "/{}/load_balancers/{}".format(API_VERSION, balancer_id)
        ).object
        return self._to_balancer(data)

    def balancer_attach_compute_node(self, balancer, node):
        return self.balancer_attach_member(balancer, node)

    def balancer_attach_member(self, balancer, member):
        path = "/{}/load_balancers/{}/add_nodes".format(API_VERSION, balancer.id)

        self._post(path, {"nodes": [self._member_to_node(member)]})

        return member

    def balancer_detach_member(self, balancer, member):
        path = "/{}/load_balancers/{}/remove_nodes".format(API_VERSION, balancer.id)

        response = self._post(path, {"nodes": [self._member_to_node(member)]})

        return response.status == httplib.ACCEPTED

    def balancer_list_members(self, balancer):
        path = "/{}/load_balancers/{}".format(API_VERSION, balancer.id)

        data = self.connection.request(path).object

        def func(data):
            return self._node_to_member(data, balancer)

        return list(map(func, data["nodes"]))

    def _post(self, path, data={}):
        headers = {"Content-Type": "application/json"}

        return self.connection.request(path, data=data, headers=headers, method="POST")

    def _to_balancer(self, data):
        return LoadBalancer(
            id=data["id"],
            name=data["name"],
            state=self.LB_STATE_MAP.get(data["status"], State.UNKNOWN),
            ip=self._public_ip(data),
            port=data["listeners"][0]["in"],
            driver=self.connection.driver,
        )

    def _member_to_node(self, member):
        return {"node": member.id}

    def _node_to_member(self, data, balancer):
        return Member(id=data["id"], ip=None, port=None, balancer=balancer)

    def _public_ip(self, data):
        if len(data["cloud_ips"]) > 0:
            ip = data["cloud_ips"][0]["public_ip"]
        else:
            ip = None

        return ip