# 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.

"""
Drivers for CloudSigma API v1.0 and v2.0.
"""

import re
import copy
import time
import base64
import hashlib

from libcloud.utils.py3 import b, httplib
from libcloud.utils.misc import dict2str, str2list, str2dicts, get_secure_random_string
from libcloud.common.base import Response, JsonResponse, ConnectionUserAndKey
from libcloud.common.types import ProviderError, InvalidCredsError
from libcloud.compute.base import Node, KeyPair, NodeSize, NodeImage, NodeDriver, is_private_subnet
from libcloud.compute.types import Provider, NodeState
from libcloud.utils.iso8601 import parse_date
from libcloud.common.cloudsigma import (
    SPECS_TO_SIZE,
    DEFAULT_REGION,
    INSTANCE_TYPES,
    MAX_VIRTIO_UNITS,
    API_ENDPOINTS_1_0,
    API_ENDPOINTS_2_0,
    DEFAULT_API_VERSION,
    MAX_VIRTIO_CONTROLLERS,
)

try:
    import simplejson as json
except Exception:
    import json


__all__ = [
    "CloudSigmaNodeDriver",
    "CloudSigma_1_0_NodeDriver",
    "CloudSigma_2_0_NodeDriver",
    "CloudSigmaError",
    "CloudSigmaNodeSize",
    "CloudSigmaDrive",
    "CloudSigmaTag",
    "CloudSigmaSubscription",
    "CloudSigmaFirewallPolicy",
    "CloudSigmaFirewallPolicyRule",
]


class CloudSigmaNodeDriver(NodeDriver):
    name = "CloudSigma"
    website = "http://www.cloudsigma.com/"

    def __new__(
        cls,
        key,
        secret=None,
        secure=True,
        host=None,
        port=None,
        api_version=DEFAULT_API_VERSION,
        **kwargs,
    ):
        if cls is CloudSigmaNodeDriver:
            if api_version == "1.0":
                cls = CloudSigma_1_0_NodeDriver
            elif api_version == "2.0":
                cls = CloudSigma_2_0_NodeDriver
            else:
                raise NotImplementedError("Unsupported API version: %s" % (api_version))
        return super().__new__(cls)


class CloudSigmaException(Exception):
    def __str__(self):
        # pylint: disable=unsubscriptable-object
        return self.args[0]

    def __repr__(self):
        # pylint: disable=unsubscriptable-object
        return "<CloudSigmaException '%s'>" % (self.args[0])


class CloudSigmaInsufficientFundsException(Exception):
    def __repr__(self):
        # pylint: disable=unsubscriptable-object
        return "<CloudSigmaInsufficientFundsException '%s'>" % (self.args[0])


class CloudSigmaNodeSize(NodeSize):
    def __init__(self, id, name, cpu, ram, disk, bandwidth, price, driver, extra=None):
        self.id = id
        self.name = name
        self.cpu = cpu
        self.ram = ram
        self.disk = disk
        self.bandwidth = bandwidth
        self.price = price
        self.driver = driver
        self.extra = extra or {}

    def __repr__(self):
        return (
            "<NodeSize: id=%s, name=%s, cpu=%s, ram=%s disk=%s "
            "bandwidth=%s price=%s driver=%s ...>"
        ) % (
            self.id,
            self.name,
            self.cpu,
            self.ram,
            self.disk,
            self.bandwidth,
            self.price,
            self.driver.name,
        )


class CloudSigma_1_0_Response(Response):
    def success(self):
        if self.status == httplib.UNAUTHORIZED:
            raise InvalidCredsError()

        return 200 <= self.status <= 299

    def parse_body(self):
        if not self.body:
            return self.body

        return str2dicts(self.body)

    def parse_error(self):
        return "Error: %s" % (self.body.replace("errors:", "").strip())


class CloudSigma_1_0_Connection(ConnectionUserAndKey):
    host = API_ENDPOINTS_1_0[DEFAULT_REGION]["host"]
    responseCls = CloudSigma_1_0_Response

    def add_default_headers(self, headers):
        headers["Accept"] = "application/json"
        headers["Content-Type"] = "application/json"

        headers["Authorization"] = "Basic %s" % (
            base64.b64encode(b("{}:{}".format(self.user_id, self.key))).decode("utf-8")
        )
        return headers


class CloudSigma_1_0_NodeDriver(CloudSigmaNodeDriver):
    type = Provider.CLOUDSIGMA
    name = "CloudSigma (API v1.0)"
    website = "http://www.cloudsigma.com/"
    connectionCls = CloudSigma_1_0_Connection

    IMAGING_TIMEOUT = 20 * 60  # Default timeout (in seconds) for the drive
    # imaging process

    NODE_STATE_MAP = {
        "active": NodeState.RUNNING,
        "stopped": NodeState.TERMINATED,
        "dead": NodeState.TERMINATED,
        "dumped": NodeState.TERMINATED,
    }

    def __init__(
        self,
        key,
        secret=None,
        secure=True,
        host=None,
        port=None,
        region=DEFAULT_REGION,
        **kwargs,
    ):
        if region not in API_ENDPOINTS_1_0:
            raise ValueError("Invalid region: %s" % (region))

        self._host_argument_set = host is not None
        self.api_name = "cloudsigma_%s" % (region)
        super().__init__(
            key=key,
            secret=secret,
            secure=secure,
            host=host,
            port=port,
            region=region,
            **kwargs,
        )

    def reboot_node(self, node):
        """
        Reboot a node.

        Because Cloudsigma API does not provide native reboot call,
        it's emulated using stop and start.

        @inherits: :class:`NodeDriver.reboot_node`
        """
        node = self._get_node(node.id)
        state = node.state

        if state == NodeState.RUNNING:
            stopped = self.ex_stop_node(node)
        else:
            stopped = True

        if not stopped:
            raise CloudSigmaException("Could not stop node with id %s" % (node.id))

        success = self.ex_start_node(node)

        return success

    def destroy_node(self, node):
        """
        Destroy a node (all the drives associated with it are NOT destroyed).

        If a node is still running, it's stopped before it's destroyed.

        @inherits: :class:`NodeDriver.destroy_node`
        """
        node = self._get_node(node.id)
        state = node.state

        # Node cannot be destroyed while running so it must be stopped first
        if state == NodeState.RUNNING:
            stopped = self.ex_stop_node(node)
        else:
            stopped = True

        if not stopped:
            raise CloudSigmaException("Could not stop node with id %s" % (node.id))

        response = self.connection.request(action="/servers/%s/destroy" % (node.id), method="POST")
        return response.status == 204

    def list_images(self, location=None):
        """
        Return a list of available standard images (this call might take up
        to 15 seconds to return).

        @inherits: :class:`NodeDriver.list_images`
        """
        response = self.connection.request(action="/drives/standard/info").object

        images = []
        for value in response:
            if value.get("type"):
                if value["type"] == "disk":
                    image = NodeImage(
                        id=value["drive"],
                        name=value["name"],
                        driver=self.connection.driver,
                        extra={"size": value["size"]},
                    )
                    images.append(image)

        return images

    def list_sizes(self, location=None):
        sizes = []
        for value in INSTANCE_TYPES:
            key = value["id"]
            size = CloudSigmaNodeSize(
                id=value["id"],
                name=value["name"],
                cpu=value["cpu"],
                ram=value["memory"],
                disk=value["disk"],
                bandwidth=value["bandwidth"],
                price=self._get_size_price(size_id=key),
                driver=self.connection.driver,
            )
            sizes.append(size)

        return sizes

    def list_nodes(self):
        response = self.connection.request(action="/servers/info").object

        nodes = []
        for data in response:
            node = self._to_node(data)
            if node:
                nodes.append(node)
        return nodes

    def create_node(
        self,
        name,
        size,
        image,
        smp="auto",
        nic_model="e1000",
        vnc_password=None,
        drive_type="hdd",
    ):
        """
        Creates a CloudSigma instance

        @inherits: :class:`NodeDriver.create_node`

        :keyword    name: String with a name for this new node (required)
        :type       name: ``str``

        :keyword    smp: Number of virtual processors or None to calculate
                         based on the cpu speed.
        :type       smp: ``int``

        :keyword    nic_model: e1000, rtl8139 or virtio (is not specified,
                               e1000 is used)
        :type       nic_model: ``str``

        :keyword    vnc_password: If not set, VNC access is disabled.
        :type       vnc_password: ``bool``

        :keyword    drive_type: Drive type (ssd|hdd). Defaults to hdd.
        :type       drive_type: ``str``
        """
        if nic_model not in ["e1000", "rtl8139", "virtio"]:
            raise CloudSigmaException("Invalid NIC model specified")

        if drive_type not in ["hdd", "ssd"]:
            raise CloudSigmaException(
                'Invalid drive type "%s". Valid types' " are: hdd, ssd" % (drive_type)
            )

        drive_data = {}
        drive_data.update({"name": name, "size": "%sG" % (size.disk), "driveType": drive_type})

        response = self.connection.request(
            action="/drives/%s/clone" % image.id,
            data=dict2str(drive_data),
            method="POST",
        ).object

        if not response:
            raise CloudSigmaException("Drive creation failed")

        drive_uuid = response[0]["drive"]

        response = self.connection.request(action="/drives/%s/info" % (drive_uuid)).object
        imaging_start = time.time()
        while "imaging" in response[0]:
            response = self.connection.request(action="/drives/%s/info" % (drive_uuid)).object
            elapsed_time = time.time() - imaging_start
            timed_out = elapsed_time >= self.IMAGING_TIMEOUT
            if "imaging" in response[0] and timed_out:
                raise CloudSigmaException("Drive imaging timed out")
            time.sleep(1)

        node_data = {}
        node_data.update(
            {
                "name": name,
                "cpu": size.cpu,
                "mem": size.ram,
                "ide:0:0": drive_uuid,
                "boot": "ide:0:0",
                "smp": smp,
            }
        )
        node_data.update({"nic:0:model": nic_model, "nic:0:dhcp": "auto"})

        if vnc_password:
            node_data.update({"vnc:ip": "auto", "vnc:password": vnc_password})

        response = self.connection.request(
            action="/servers/create", data=dict2str(node_data), method="POST"
        ).object

        if not isinstance(response, list):
            response = [response]

        node = self._to_node(response[0])
        if node is None:
            # Insufficient funds, destroy created drive
            self.ex_drive_destroy(drive_uuid)
            raise CloudSigmaInsufficientFundsException("Insufficient funds, node creation failed")

        # Start the node after it has been created
        started = self.ex_start_node(node)

        if started:
            node.state = NodeState.RUNNING

        return node

    def ex_destroy_node_and_drives(self, node):
        """
        Destroy a node and all the drives associated with it.

        :param      node: Node which should be used
        :type       node: :class:`libcloud.compute.base.Node`

        :rtype: ``bool``
        """
        node = self._get_node_info(node)

        drive_uuids = []
        for key, value in node.items():
            if (
                key.startswith("ide:") or key.startswith("scsi") or key.startswith("block")
            ) and not (
                key.endswith(":bytes") or key.endswith(":requests") or key.endswith("media")
            ):
                drive_uuids.append(value)

        node_destroyed = self.destroy_node(self._to_node(node))

        if not node_destroyed:
            return False

        for drive_uuid in drive_uuids:
            self.ex_drive_destroy(drive_uuid)

        return True

    def ex_static_ip_list(self):
        """
        Return a list of available static IP addresses.

        :rtype: ``list`` of ``str``
        """
        response = self.connection.request(action="/resources/ip/list", method="GET")

        if response.status != 200:
            raise CloudSigmaException("Could not retrieve IP list")

        ips = str2list(response.body)
        return ips

    def ex_drives_list(self):
        """
        Return a list of all the available drives.

        :rtype: ``list`` of ``dict``
        """
        response = self.connection.request(action="/drives/info", method="GET")

        result = str2dicts(response.body)
        return result

    def ex_static_ip_create(self):
        """
        Create a new static IP address.p

        :rtype: ``list`` of ``dict``
        """
        response = self.connection.request(action="/resources/ip/create", method="GET")

        result = str2dicts(response.body)
        return result

    def ex_static_ip_destroy(self, ip_address):
        """
        Destroy a static IP address.

        :param      ip_address: IP address which should be used
        :type       ip_address: ``str``

        :rtype: ``bool``
        """
        response = self.connection.request(
            action="/resources/ip/%s/destroy" % (ip_address), method="GET"
        )

        return response.status == 204

    def ex_drive_destroy(self, drive_uuid):
        """
        Destroy a drive with a specified uuid.
        If the drive is currently mounted an exception is thrown.

        :param      drive_uuid: Drive uuid which should be used
        :type       drive_uuid: ``str``

        :rtype: ``bool``
        """
        response = self.connection.request(
            action="/drives/%s/destroy" % (drive_uuid), method="POST"
        )

        return response.status == 204

    def ex_set_node_configuration(self, node, **kwargs):
        """
        Update a node configuration.
        Changing most of the parameters requires node to be stopped.

        :param      node: Node which should be used
        :type       node: :class:`libcloud.compute.base.Node`

        :param      kwargs: keyword arguments
        :type       kwargs: ``dict``

        :rtype: ``bool``
        """
        valid_keys = (
            "^name$",
            "^parent$",
            "^cpu$",
            "^smp$",
            "^mem$",
            "^boot$",
            "^nic:0:model$",
            "^nic:0:dhcp",
            "^nic:1:model$",
            "^nic:1:vlan$",
            "^nic:1:mac$",
            "^vnc:ip$",
            "^vnc:password$",
            "^vnc:tls",
            "^ide:[0-1]:[0-1](:media)?$",
            "^scsi:0:[0-7](:media)?$",
            "^block:[0-7](:media)?$",
        )

        invalid_keys = []
        keys = list(kwargs.keys())
        for key in keys:
            matches = False
            for regex in valid_keys:
                if re.match(regex, key):
                    matches = True
                    break
            if not matches:
                invalid_keys.append(key)

        if invalid_keys:
            raise CloudSigmaException(
                "Invalid configuration key specified: %s" % (",".join(invalid_keys))
            )

        response = self.connection.request(
            action="/servers/%s/set" % (node.id), data=dict2str(kwargs), method="POST"
        )

        return response.status == 200 and response.body != ""

    def ex_start_node(self, node):
        """
        Start a node.

        :param      node: Node which should be used
        :type       node: :class:`libcloud.compute.base.Node`

        :rtype: ``bool``
        """
        response = self.connection.request(action="/servers/%s/start" % (node.id), method="POST")

        return response.status == 200

    def ex_stop_node(self, node):
        # NOTE: This method is here for backward compatibility reasons after
        # this method was promoted to be part of the standard compute API in
        # Libcloud v2.7.0
        return self.stop_node(node=node)

    def stop_node(self, node):
        """
        Stop (shutdown) a node.

        :param      node: Node which should be used
        :type       node: :class:`libcloud.compute.base.Node`

        :rtype: ``bool``
        """
        response = self.connection.request(action="/servers/%s/stop" % (node.id), method="POST")
        return response.status == 204

    def ex_shutdown_node(self, node):
        """
        Stop (shutdown) a node.

        @inherits: :class:`CloudSigmaBaseNodeDriver.ex_stop_node`
        """
        return self.ex_stop_node(node)

    def ex_destroy_drive(self, drive_uuid):
        """
        Destroy a drive.

        :param      drive_uuid: Drive uuid which should be used
        :type       drive_uuid: ``str``

        :rtype: ``bool``
        """
        response = self.connection.request(
            action="/drives/%s/destroy" % (drive_uuid), method="POST"
        )
        return response.status == 204

    def _ex_connection_class_kwargs(self):
        """
        Return the host value based on the user supplied region.
        """
        kwargs = {}
        if not self._host_argument_set:
            kwargs["host"] = API_ENDPOINTS_1_0[self.region]["host"]

        return kwargs

    def _to_node(self, data):
        if data:
            try:
                state = self.NODE_STATE_MAP[data["status"]]
            except KeyError:
                state = NodeState.UNKNOWN

            if "server" not in data:
                # Response does not contain server UUID if the server
                # creation failed because of insufficient funds.
                return None

            public_ips = []
            if "nic:0:dhcp" in data:
                if isinstance(data["nic:0:dhcp"], list):
                    public_ips = data["nic:0:dhcp"]
                else:
                    public_ips = [data["nic:0:dhcp"]]

            extra = {}
            extra_keys = [
                ("cpu", "int"),
                ("smp", "auto"),
                ("mem", "int"),
                ("status", "str"),
            ]
            for key, value_type in extra_keys:
                if key in data:
                    value = data[key]

                    if value_type == "int":
                        value = int(value)
                    elif value_type == "auto":
                        try:
                            value = int(value)
                        except ValueError:
                            pass

                    extra.update({key: value})

            if "vnc:ip" in data and "vnc:password" in data:
                extra.update({"vnc_ip": data["vnc:ip"], "vnc_password": data["vnc:password"]})

            node = Node(
                id=data["server"],
                name=data["name"],
                state=state,
                public_ips=public_ips,
                private_ips=None,
                driver=self.connection.driver,
                extra=extra,
            )

            return node
        return None

    def _get_node(self, node_id):
        nodes = self.list_nodes()
        node = [node for node in nodes if node.id == node.id]

        if not node:
            raise CloudSigmaException("Node with id %s does not exist" % (node_id))

        return node[0]

    def _get_node_info(self, node):
        response = self.connection.request(action="/servers/%s/info" % (node.id))

        result = str2dicts(response.body)
        return result[0]


class CloudSigmaZrhConnection(CloudSigma_1_0_Connection):
    """
    Connection class for the CloudSigma driver for the Zurich end-point
    """

    host = API_ENDPOINTS_1_0["zrh"]["host"]


class CloudSigmaZrhNodeDriver(CloudSigma_1_0_NodeDriver):
    """
    CloudSigma node driver for the Zurich end-point
    """

    connectionCls = CloudSigmaZrhConnection
    api_name = "cloudsigma_zrh"


class CloudSigmaLvsConnection(CloudSigma_1_0_Connection):
    """
    Connection class for the CloudSigma driver for the Las Vegas end-point
    """

    host = API_ENDPOINTS_1_0["lvs"]["host"]


class CloudSigmaLvsNodeDriver(CloudSigma_1_0_NodeDriver):
    """
    CloudSigma node driver for the Las Vegas end-point
    """

    connectionCls = CloudSigmaLvsConnection
    api_name = "cloudsigma_lvs"


class CloudSigmaError(ProviderError):
    """
    Represents CloudSigma API error.
    """

    def __init__(self, http_code, error_type, error_msg, error_point, driver):
        """
        :param http_code: HTTP status code.
        :type http_code: ``int``

        :param error_type: Type of error (validation / notexist / backend /
                           permissions  database / concurrency / billing /
                           payment)
        :type error_type: ``str``

        :param error_msg: A description of the error that occurred.
        :type error_msg: ``str``

        :param error_point: Point at which the error occurred. Can be None.
        :type error_point: ``str`` or ``None``
        """
        super().__init__(http_code=http_code, value=error_msg, driver=driver)
        self.error_type = error_type
        self.error_msg = error_msg
        self.error_point = error_point


class CloudSigmaSubscription:
    """
    Represents CloudSigma subscription.
    """

    def __init__(
        self,
        id,
        resource,
        amount,
        period,
        status,
        price,
        start_time,
        end_time,
        auto_renew,
        subscribed_object=None,
    ):
        """
        :param id: Subscription ID.
        :type id: ``str``

        :param resource: Resource (e.g vlan, ip, etc.).
        :type resource: ``str``

        :param period: Subscription period.
        :type period: ``str``

        :param status: Subscription status (active / inactive).
        :type status: ``str``

        :param price: Subscription price.
        :type price: ``str``

        :param start_time: Start time for this subscription.
        :type start_time: ``datetime.datetime``

        :param end_time: End time for this subscription.
        :type end_time: ``datetime.datetime``

        :param auto_renew: True if the subscription is auto renewed.
        :type auto_renew: ``bool``

        :param subscribed_object: Optional UUID of the subscribed object.
        :type subscribed_object: ``str``
        """
        self.id = id
        self.resource = resource
        self.amount = amount
        self.period = period
        self.status = status
        self.price = price
        self.start_time = start_time
        self.end_time = end_time
        self.auto_renew = auto_renew
        self.subscribed_object = subscribed_object

    def __str__(self):
        return self.__repr__()

    def __repr__(self):
        return (
            "<CloudSigmaSubscription id=%s, resource=%s, amount=%s, "
            "period=%s, object_uuid=%s>"
            % (self.id, self.resource, self.amount, self.period, self.subscribed_object)
        )


class CloudSigmaTag:
    """
    Represents a CloudSigma tag object.
    """

    def __init__(self, id, name, resources=None):
        """
        :param id: Tag ID.
        :type id: ``str``

        :param name: Tag name.
        :type name: ``str``

        :param resource: IDs of resources which are associated with this tag.
        :type resources: ``list`` of ``str``
        """
        self.id = id
        self.name = name
        self.resources = resources if resources else []

    def __str__(self):
        return self.__repr__()

    def __repr__(self):
        return "<CloudSigmaTag id={}, name={}, resources={}>".format(
            self.id,
            self.name,
            repr(self.resources),
        )


class CloudSigmaDrive(NodeImage):
    """
    Represents a CloudSigma drive.
    """

    def __init__(self, id, name, size, media, status, driver, extra=None):
        """
        :param id: Drive ID.
        :type id: ``str``

        :param name: Drive name.
        :type name: ``str``

        :param size: Drive size (in GBs).
        :type size: ``float``

        :param media: Drive media (cdrom / disk).
        :type media: ``str``

        :param status: Drive status (unmounted / mounted).
        :type status: ``str``
        """
        super().__init__(id=id, name=name, driver=driver, extra=extra)
        self.size = size
        self.media = media
        self.status = status

    def __str__(self):
        return self.__repr__()

    def __repr__(self):
        return ("<CloudSigmaSize id=%s, name=%s size=%s, media=%s, " "status=%s>") % (
            self.id,
            self.name,
            self.size,
            self.media,
            self.status,
        )


class CloudSigmaFirewallPolicy:
    """
    Represents a CloudSigma firewall policy.
    """

    def __init__(self, id, name, rules):
        """
        :param id: Policy ID.
        :type id: ``str``

        :param name: Policy name.
        :type name: ``str``

        :param rules: Rules associated with this policy.
        :type rules: ``list`` of :class:`.CloudSigmaFirewallPolicyRule` objects
        """
        self.id = id
        self.name = name
        self.rules = rules if rules else []

    def __str__(self):
        return self.__repr__()

    def __repr__(self):
        return ("<CloudSigmaFirewallPolicy id=%s, name=%s rules=%s>") % (
            self.id,
            self.name,
            repr(self.rules),
        )


class CloudSigmaFirewallPolicyRule:
    """
    Represents a CloudSigma firewall policy rule.
    """

    def __init__(
        self,
        action,
        direction,
        ip_proto=None,
        src_ip=None,
        src_port=None,
        dst_ip=None,
        dst_port=None,
        comment=None,
    ):
        """
        :param action: Action (drop / accept).
        :type action: ``str``

        :param direction: Rule direction (in / out / both)>
        :type direction: ``str``

        :param ip_proto: IP protocol (tcp / udp).
        :type ip_proto: ``str``.

        :param src_ip: Source IP in CIDR notation.
        :type src_ip: ``str``

        :param src_port: Source port or a port range.
        :type src_port: ``str``

        :param dst_ip: Destination IP in CIDR notation.
        :type dst_ip: ``str``

        :param src_port: Destination port or a port range.
        :type src_port: ``str``

        :param comment: Comment associated with the policy.
        :type comment: ``str``
        """
        self.action = action
        self.direction = direction
        self.ip_proto = ip_proto
        self.src_ip = src_ip
        self.src_port = src_port
        self.dst_ip = dst_ip
        self.dst_port = dst_port
        self.comment = comment

    def __str__(self):
        return self.__repr__()

    def __repr__(self):
        return ("<CloudSigmaFirewallPolicyRule action=%s, direction=%s>") % (
            self.action,
            self.direction,
        )


class CloudSigma_2_0_Response(JsonResponse):
    success_status_codes = [
        httplib.OK,
        httplib.ACCEPTED,
        httplib.NO_CONTENT,
        httplib.CREATED,
    ]

    def success(self):
        return self.status in self.success_status_codes

    def parse_error(self):
        if int(self.status) == httplib.UNAUTHORIZED:
            raise InvalidCredsError("Invalid credentials")

        body = self.parse_body()
        errors = self._parse_errors_from_body(body=body)

        if errors:
            # Throw first error
            raise errors[0]

        return body

    def _parse_errors_from_body(self, body):
        """
        Parse errors from the response body.

        :return: List of error objects.
        :rtype: ``list`` of :class:`.CloudSigmaError` objects
        """
        errors = []

        if not isinstance(body, list):
            return None

        for item in body:
            if "error_type" not in item:
                # Unrecognized error
                continue

            error = CloudSigmaError(
                http_code=self.status,
                error_type=item["error_type"],
                error_msg=item["error_message"],
                error_point=item["error_point"],
                driver=self.connection.driver,
            )
            errors.append(error)

        return errors


class CloudSigma_2_0_Connection(ConnectionUserAndKey):
    host = API_ENDPOINTS_2_0[DEFAULT_REGION]["host"]
    responseCls = CloudSigma_2_0_Response
    api_prefix = "/api/2.0"

    def add_default_headers(self, headers):
        headers["Accept"] = "application/json"
        headers["Content-Type"] = "application/json"

        headers["Authorization"] = "Basic %s" % (
            base64.b64encode(b("{}:{}".format(self.user_id, self.key))).decode("utf-8")
        )
        return headers

    def encode_data(self, data):
        data = json.dumps(data)
        return data

    def request(self, action, params=None, data=None, headers=None, method="GET", raw=False):
        params = params or {}
        action = self.api_prefix + action

        if method == "GET":
            params["limit"] = 0  # we want all the items back

        return super().request(
            action=action,
            params=params,
            data=data,
            headers=headers,
            method=method,
            raw=raw,
        )


class CloudSigma_2_0_NodeDriver(CloudSigmaNodeDriver):
    """
    Driver for CloudSigma API v2.0.
    """

    name = "CloudSigma (API v2.0)"
    api_name = "cloudsigma_zrh"
    website = "http://www.cloudsigma.com/"
    connectionCls = CloudSigma_2_0_Connection

    # Default drive transition timeout in seconds
    DRIVE_TRANSITION_TIMEOUT = 500

    # How long to sleep between different polling periods while waiting for
    # drive transition
    DRIVE_TRANSITION_SLEEP_INTERVAL = 5

    NODE_STATE_MAP = {
        "starting": NodeState.PENDING,
        "stopping": NodeState.PENDING,
        "unavailable": NodeState.ERROR,
        "running": NodeState.RUNNING,
        "stopped": NodeState.STOPPED,
        "paused": NodeState.PAUSED,
    }

    def __init__(
        self,
        key,
        secret,
        secure=True,
        host=None,
        port=None,
        region=DEFAULT_REGION,
        **kwargs,
    ):
        if region not in API_ENDPOINTS_2_0:
            raise ValueError("Invalid region: %s" % (region))

        if not secure:
            # CloudSigma drive uses Basic Auth authentication and we don't want
            # to allow user to accidentally send credentials over the wire in
            # plain-text
            raise ValueError("CloudSigma driver only supports a " "secure connection")

        self._host_argument_set = host is not None
        super().__init__(
            key=key,
            secret=secret,
            secure=secure,
            host=host,
            port=port,
            region=region,
            **kwargs,
        )

    def list_nodes(self, ex_tag=None):
        """
        List available nodes.

        :param ex_tag: If specified, only return servers tagged with the
                       provided tag.
        :type ex_tag: :class:`CloudSigmaTag`
        """
        if ex_tag:
            action = "/tags/%s/servers/detail/" % (ex_tag.id)
        else:
            action = "/servers/detail/"

        response = self.connection.request(action=action, method="GET").object
        nodes = [self._to_node(data=item) for item in response["objects"]]
        return nodes

    def list_sizes(self):
        """
        List available sizes.
        """
        sizes = []
        for value in INSTANCE_TYPES:
            key = value["id"]
            size = CloudSigmaNodeSize(
                id=value["id"],
                name=value["name"],
                cpu=value["cpu"],
                ram=value["memory"],
                disk=value["disk"],
                bandwidth=value["bandwidth"],
                price=self._get_size_price(size_id=key),
                driver=self.connection.driver,
            )
            sizes.append(size)

        return sizes

    def list_images(self):
        """
        Return a list of available pre-installed library drives.

        Note: If you want to list all the available library drives (both
        pre-installed and installation CDs), use :meth:`ex_list_library_drives`
        method.
        """
        response = self.connection.request(action="/libdrives/").object
        images = [self._to_image(data=item) for item in response["objects"]]

        # We filter out non pre-installed library drives by default because
        # they can't be used directly following a default Libcloud server
        # creation flow.
        images = [image for image in images if image.extra["image_type"] == "preinst"]
        return images

    def create_node(
        self,
        name,
        size,
        image,
        ex_metadata=None,
        ex_vnc_password=None,
        ex_avoid=None,
        ex_vlan=None,
        public_keys=None,
    ):
        """
        Create a new server.

        Server creation consists multiple steps depending on the type of the
        image used.

        1. Installation CD:

            1. Create a server and attach installation cd
            2. Start a server

        2. Pre-installed image:

            1. Clone provided library drive so we can use it
            2. Resize cloned drive to the desired size
            3. Create a server and attach cloned drive
            4. Start a server

        :param ex_metadata: Key / value pairs to associate with the
                            created node. (optional)
        :type ex_metadata: ``dict``

        :param ex_vnc_password: Password to use for VNC access. If not
                                provided, random password is generated.
        :type ex_vnc_password: ``str``

        :param ex_avoid: A list of server UUIDs to avoid when starting this
                         node. (optional)
        :type ex_avoid: ``list``

        :param ex_vlan: Optional UUID of a VLAN network to use. If specified,
                        server will have two nics assigned - 1 with a public ip
                        and 1 with the provided VLAN.
        :type ex_vlan: ``str``

        :param public_keys: Optional list of SSH key UUIDs
        :type public_keys: ``list`` of ``str``
        """
        is_installation_cd = self._is_installation_cd(image=image)

        if ex_vnc_password:
            vnc_password = ex_vnc_password
        else:
            # VNC password is not provided, generate a random one.
            vnc_password = get_secure_random_string(size=12)

        drive_name = "%s-drive" % (name)

        drive_size = size.disk
        if not is_installation_cd:
            # 1. Clone library drive so we can use it
            drive = self.ex_clone_drive(drive=image, name=drive_name)

            # Wait for drive clone to finish
            drive = self._wait_for_drive_state_transition(drive=drive, state="unmounted")

            # 2. Resize drive to the desired disk size if the desired disk size
            # is larger than the cloned drive size.
            if drive_size > drive.size:
                drive = self.ex_resize_drive(drive=drive, size=drive_size)

            # Wait for drive resize to finish
            drive = self._wait_for_drive_state_transition(drive=drive, state="unmounted")
        else:
            # No need to clone installation CDs
            drive = image

        # 3. Create server and attach cloned drive
        # ide 0:0
        data = {}
        data["name"] = name
        # cloudsigma uses MHz to measure cpu cores,
        # where 1 cpu core equals 2000MHz
        data["cpu"] = size.cpu * 2000
        data["mem"] = size.ram * 1024 * 1024
        data["vnc_password"] = vnc_password

        if public_keys:
            data["pubkeys"] = public_keys

        if ex_metadata:
            data["meta"] = ex_metadata

        # Assign 1 public interface (DHCP) to the node
        nic = {"boot_order": None, "ip_v4_conf": {"conf": "dhcp"}, "ip_v6_conf": None}

        nics = [nic]

        if ex_vlan:
            # Assign another interface for VLAN
            nic = {
                "boot_order": None,
                "ip_v4_conf": None,
                "ip_v6_conf": None,
                "vlan": ex_vlan,
            }
            nics.append(nic)

        # Need to use IDE for installation CDs
        if is_installation_cd:
            device_type = "ide"
        else:
            device_type = "virtio"

        drive = {
            "boot_order": 1,
            "dev_channel": "0:0",
            "device": device_type,
            "drive": drive.id,
        }

        drives = [drive]

        data["nics"] = nics
        data["drives"] = drives

        action = "/servers/"
        response = self.connection.request(action=action, method="POST", data=data)
        node = self._to_node(response.object["objects"][0])

        # 4. Start server
        self.ex_start_node(node=node, ex_avoid=ex_avoid)

        return node

    def destroy_node(self, node, ex_delete_drives=False):
        """
        Destroy the node and all the associated drives.

        :return: ``True`` on success, ``False`` otherwise.
        :rtype: ``bool``
        """
        action = "/servers/%s/" % (node.id)
        if ex_delete_drives is True:
            params = {"recurse": "all_drives"}
        else:
            params = None
        response = self.connection.request(action=action, method="DELETE", params=params)
        return response.status == httplib.NO_CONTENT

    def reboot_node(self, node):
        """
        Reboot a node.

        Because Cloudsigma API does not provide native reboot call,
        it's emulated using stop and start.

        :param node: Node to reboot.
        :type node: :class:`libcloud.compute.base.Node`
        """
        state = node.state

        if state == NodeState.RUNNING:
            stopped = self.stop_node(node)
        else:
            stopped = True

        if not stopped:
            raise CloudSigmaException("Could not stop node with id %s" % (node.id))

        success = False
        for _ in range(5):
            try:
                success = self.start_node(node)
            except CloudSigmaError:
                time.sleep(1)
                continue
            else:
                break

        return success

    # Server extension methods

    def ex_edit_node(self, node, params):
        """
        Edit a node.

        :param node: Node to edit.
        :type node: :class:`libcloud.compute.base.Node`

        :param params: Node parameters to update.
        :type params: ``dict``

        :return Edited node.
        :rtype: :class:`libcloud.compute.base.Node`
        """
        data = {}

        # name, cpu, mem and vnc_password attributes must always be present so
        # we just copy them from the to-be-edited node
        data["name"] = node.name
        data["cpu"] = node.extra["cpus"]
        data["mem"] = node.extra["memory"]
        data["vnc_password"] = node.extra["vnc_password"]

        nics = copy.deepcopy(node.extra.get("nics", []))

        data["nics"] = nics

        data.update(params)

        action = "/servers/%s/" % (node.id)
        response = self.connection.request(action=action, method="PUT", data=data).object
        node = self._to_node(data=response)
        return node

    def start_node(self, node, ex_avoid=None):
        """
        Start a node.

        :param node: Node to start.
        :type node: :class:`libcloud.compute.base.Node`

        :param ex_avoid: A list of other server uuids to avoid when
                         starting this node. If provided, node will
                         attempt to be started on a different
                         physical infrastructure from other servers
                         specified using this argument. (optional)
        :type ex_avoid: ``list``
        """
        params = {}

        if ex_avoid:
            params["avoid"] = ",".join(ex_avoid)

        path = "/servers/%s/action/" % (node.id)
        response = self._perform_action(path=path, action="start", params=params, method="POST")
        return response.status == httplib.ACCEPTED

    def stop_node(self, node):
        path = "/servers/%s/action/" % (node.id)
        response = self._perform_action(path=path, action="stop", method="POST")
        return response.status == httplib.ACCEPTED

    def ex_start_node(self, node, ex_avoid=None):
        # NOTE: This method is here for backward compatibility reasons after
        # this method was promoted to be part of the standard compute API in
        # Libcloud v2.7.0
        return self.start_node(node=node, ex_avoid=ex_avoid)

    def ex_stop_node(self, node):
        # NOTE: This method is here for backward compatibility reasons after
        # this method was promoted to be part of the standard compute API in
        # Libcloud v2.7.0
        """
        Stop a node.
        """
        return self.stop_node(node=node)

    def ex_clone_node(self, node, name=None, random_vnc_password=None):
        """
        Clone the provided node.

        :param name: Optional name for the cloned node.
        :type name: ``str``
        :param random_vnc_password: If True, a new random VNC password will be
                                    generated for the cloned node. Otherwise
                                    password from the cloned node will be
                                    reused.
        :type random_vnc_password: ``bool``

        :return: Cloned node.
        :rtype: :class:`libcloud.compute.base.Node`
        """
        data = {}

        data["name"] = name
        data["random_vnc_password"] = random_vnc_password

        path = "/servers/%s/action/" % (node.id)
        response = self._perform_action(path=path, action="clone", method="POST", data=data).object
        node = self._to_node(data=response)
        return node

    def ex_get_node(self, node_id, return_json=False):
        action = "/servers/%s/" % (node_id)
        response = self.connection.request(action=action).object
        if return_json is True:
            return response
        return self._to_node(response)

    def ex_open_vnc_tunnel(self, node):
        """
        Open a VNC tunnel to the provided node and return the VNC url.

        :param node: Node to open the VNC tunnel to.
        :type node: :class:`libcloud.compute.base.Node`

        :return: URL of the opened VNC tunnel.
        :rtype: ``str``
        """
        path = "/servers/%s/action/" % (node.id)
        response = self._perform_action(path=path, action="open_vnc", method="POST").object
        vnc_url = response["vnc_url"]
        return vnc_url

    def ex_close_vnc_tunnel(self, node):
        """
        Close a VNC server to the provided node.

        :param node: Node to close the VNC tunnel to.
        :type node: :class:`libcloud.compute.base.Node`

        :return: ``True`` on success, ``False`` otherwise.
        :rtype: ``bool``
        """
        path = "/servers/%s/action/" % (node.id)
        response = self._perform_action(path=path, action="close_vnc", method="POST")
        return response.status == httplib.ACCEPTED

    # Drive extension methods

    def ex_list_library_drives(self):
        """
        Return a list of all the available library drives (pre-installed and
        installation CDs).

        :rtype: ``list`` of :class:`.CloudSigmaDrive` objects
        """
        response = self.connection.request(action="/libdrives/").object
        drives = [self._to_drive(data=item) for item in response["objects"]]
        return drives

    def ex_list_user_drives(self):
        """
        Return a list of all the available user's drives.

        :rtype: ``list`` of :class:`.CloudSigmaDrive` objects
        """
        response = self.connection.request(action="/drives/detail/").object
        drives = [self._to_drive(data=item) for item in response["objects"]]
        return drives

    def list_volumes(self):
        return self.ex_list_user_drives()

    def ex_create_drive(self, name, size, media="disk", ex_avoid=None):
        """
        Create a new drive.

        :param name: Drive name.
        :type name: ``str``

        :param size: Drive size in GBs.
        :type size: ``int``

        :param media: Drive media type (cdrom, disk).
        :type media: ``str``

        :param ex_avoid: A list of other drive uuids to avoid when
                         creating this drive. If provided, drive will
                         attempt to be created on a different
                         physical infrastructure from other drives
                         specified using this argument. (optional)
        :type ex_avoid: ``list``

        :return: Created drive object.
        :rtype: :class:`.CloudSigmaDrive`
        """
        params = {}
        data = {"name": name, "size": size * 1024 * 1024 * 1024, "media": media}

        if ex_avoid:
            params["avoid"] = ",".join(ex_avoid)

        action = "/drives/"
        response = self.connection.request(
            action=action, method="POST", params=params, data=data
        ).object
        drive = self._to_drive(data=response["objects"][0])
        return drive

    def create_volume(self, name, size, media="disk", ex_avoid=None):
        return self.ex_create_drive(name=name, size=size, media=media, ex_avoid=ex_avoid)

    def ex_clone_drive(self, drive, name=None, ex_avoid=None):
        """
        Clone a library or a standard drive.

        :param drive: Drive to clone.
        :type drive: :class:`libcloud.compute.base.NodeImage` or
                     :class:`.CloudSigmaDrive`

        :param name: Optional name for the cloned drive.
        :type name: ``str``

        :param ex_avoid: A list of other drive uuids to avoid when
                         creating this drive. If provided, drive will
                         attempt to be created on a different
                         physical infrastructure from other drives
                         specified using this argument. (optional)
        :type ex_avoid: ``list``

        :return: New cloned drive.
        :rtype: :class:`.CloudSigmaDrive`
        """
        params = {}
        data = {}

        if ex_avoid:
            params["avoid"] = ",".join(ex_avoid)

        if name:
            data["name"] = name

        path = "/drives/%s/action/" % (drive.id)
        response = self._perform_action(
            path=path, action="clone", params=params, data=data, method="POST"
        )
        drive = self._to_drive(data=response.object["objects"][0])
        return drive

    def ex_resize_drive(self, drive, size):
        """
        Resize a drive.

        :param drive: Drive to resize.

        :param size: New drive size in GBs.
        :type size: ``int``

        :return: Drive object which is being resized.
        :rtype: :class:`.CloudSigmaDrive`
        """
        path = "/drives/%s/action/" % (drive.id)
        data = {"name": drive.name, "size": size * 1024 * 1024 * 1024, "media": "disk"}
        response = self._perform_action(path=path, action="resize", method="POST", data=data)

        drive = self._to_drive(data=response.object["objects"][0])
        return drive

    def ex_attach_drive(self, node, drive):
        """
        Attach drive to node

        :param node: Node to attach the drive to.
        :type node: :class:`libcloud.compute.base.Node`

        :param drive: Drive to attach.
        :type drive: :class:`.CloudSigmaDrive`

        :return: ``True`` on success, ``False`` otherwise.
        :rtype: ``bool``
        """
        data = self.ex_get_node(node.id, return_json=True)
        # find the first available device channel to attach the drive
        # device channel format is: {controller}:{unit}
        # total of 920 virtio drives are supported
        # 0:0, …, 0:3, …, 1:0, …, 1:3, …
        # https://cloudsigma-docs.readthedocs.io/en/2.14.3/servers_kvm.html?highlight=dev%20channel#device-channel
        dev_channels = [item["dev_channel"] for item in data["drives"]]
        dev_channel = None
        for controller in range(MAX_VIRTIO_CONTROLLERS):
            for unit in range(MAX_VIRTIO_UNITS):
                if "{}:{}".format(controller, unit) not in dev_channels:
                    dev_channel = "{}:{}".format(controller, unit)
                    break
            if dev_channel:
                break
        else:
            raise CloudSigmaException("Could not attach drive to %s" % (node.id))

        item = {
            "boot_order": None,
            "dev_channel": dev_channel,
            "device": "virtio",
            "drive": str(drive.id),
        }
        data["drives"].append(item)
        action = "/servers/%s/" % (node.id)
        response = self.connection.request(action=action, data=data, method="PUT")
        return response.status == 200

    def attach_volume(self, node, volume):
        return self.ex_attach_drive(node=node, drive=volume)

    def ex_detach_drive(self, node, drive):
        data = self.ex_get_node(node.id, return_json=True)
        data["drives"] = [item for item in data["drives"] if item["drive"]["uuid"] != drive.id]
        action = "/servers/%s/" % (node.id)
        response = self.connection.request(action=action, data=data, method="PUT")
        return response.status == 200

    def detach_volume(self, node, volume):
        return self.ex_detach_drive(node=node, drive=volume)

    def ex_get_drive(self, drive_id):
        """
        Retrieve information about a single drive.

        :param drive_id: ID of the drive to retrieve.
        :type drive_id: ``str``

        :return: Drive object.
        :rtype: :class:`.CloudSigmaDrive`
        """
        action = "/drives/%s/" % (drive_id)
        response = self.connection.request(action=action).object
        drive = self._to_drive(data=response)
        return drive

    def ex_destroy_drive(self, drive):
        action = "/drives/%s/" % (drive.id)
        response = self.connection.request(action=action, method="DELETE")
        return response.status == httplib.NO_CONTENT

    def destroy_volume(self, drive):
        return self.ex_destroy_drive(drive=drive)

    # Firewall policies extension methods

    def ex_list_firewall_policies(self):
        """
        List firewall policies.

        :rtype: ``list`` of :class:`.CloudSigmaFirewallPolicy`
        """
        action = "/fwpolicies/detail/"
        response = self.connection.request(action=action, method="GET").object
        policies = [self._to_firewall_policy(data=item) for item in response["objects"]]
        return policies

    def ex_create_firewall_policy(self, name, rules=None):
        """
        Create a firewall policy.

        :param name: Policy name.
        :type name: ``str``

        :param rules: List of firewall policy rules to associate with this
                      policy. (optional)
        :type rules: ``list`` of ``dict``

        :return: Created firewall policy object.
        :rtype: :class:`.CloudSigmaFirewallPolicy`
        """
        data = {}
        obj = {}
        obj["name"] = name

        if rules:
            obj["rules"] = rules

        data["objects"] = [obj]

        action = "/fwpolicies/"
        response = self.connection.request(action=action, method="POST", data=data).object
        policy = self._to_firewall_policy(data=response["objects"][0])
        return policy

    def ex_attach_firewall_policy(self, policy, node, nic_mac=None):
        """
        Attach firewall policy to a public NIC interface on the server.

        :param policy: Firewall policy to attach.
        :type policy: :class:`.CloudSigmaFirewallPolicy`

        :param node: Node to attach policy to.
        :type node: :class:`libcloud.compute.base.Node`

        :param nic_mac: Optional MAC address of the NIC to add the policy to.
                        If not specified, first public interface is used
                        instead.
        :type nic_mac: ``str``

        :return: Node object to which the policy was attached to.
        :rtype: :class:`libcloud.compute.base.Node`
        """
        nics = copy.deepcopy(node.extra.get("nics", []))

        if nic_mac:
            nic = [n for n in nics if n["mac"] == nic_mac]
        else:
            nic = nics

        if len(nic) == 0:
            raise ValueError("Cannot find the NIC interface to attach " "a policy to")

        nic = nic[0]
        nic["firewall_policy"] = policy.id

        params = {"nics": nics}
        node = self.ex_edit_node(node=node, params=params)
        return node

    def ex_delete_firewall_policy(self, policy):
        """
        Delete a firewall policy.

        :param policy: Policy to delete to.
        :type policy: :class:`.CloudSigmaFirewallPolicy`

        :return: ``True`` on success, ``False`` otherwise.
        :rtype: ``bool``
        """
        action = "/fwpolicies/%s/" % (policy.id)
        response = self.connection.request(action=action, method="DELETE")
        return response.status == httplib.NO_CONTENT

    # Availability groups extension methods

    def ex_list_servers_availability_groups(self):
        """
        Return which running servers share the same physical compute host.

        :return: A list of server UUIDs which share the same physical compute
                 host. Servers which share the same host will be stored under
                 the same list index.
        :rtype: ``list`` of ``list``
        """
        action = "/servers/availability_groups/"
        response = self.connection.request(action=action, method="GET")
        return response.object

    def ex_list_drives_availability_groups(self):
        """
        Return which drives share the same physical storage host.

        :return: A list of drive UUIDs which share the same physical storage
                 host. Drives which share the same host will be stored under
                 the same list index.
        :rtype: ``list`` of ``list``
        """
        action = "/drives/availability_groups/"
        response = self.connection.request(action=action, method="GET")
        return response.object

    # Tag extension methods

    def ex_list_tags(self):
        """
        List all the available tags.

        :rtype: ``list`` of :class:`.CloudSigmaTag` objects
        """
        action = "/tags/detail/"
        response = self.connection.request(action=action, method="GET").object
        tags = [self._to_tag(data=item) for item in response["objects"]]

        return tags

    def ex_get_tag(self, tag_id):
        """
        Retrieve a single tag.

        :param tag_id: ID of the tag to retrieve.
        :type tag_id: ``str``

        :rtype: ``list`` of :class:`.CloudSigmaTag` objects
        """
        action = "/tags/%s/" % (tag_id)
        response = self.connection.request(action=action, method="GET").object
        tag = self._to_tag(data=response)
        return tag

    def ex_create_tag(self, name, resource_uuids=None):
        """
        Create a tag.

        :param name: Tag name.
        :type name: ``str``

        :param resource_uuids: Optional list of resource UUIDs to assign this
                               tag go.
        :type resource_uuids: ``list`` of ``str``

        :return: Created tag object.
        :rtype: :class:`.CloudSigmaTag`
        """
        data = {}
        data["objects"] = [{"name": name}]

        if resource_uuids:
            data["resources"] = resource_uuids

        action = "/tags/"
        response = self.connection.request(action=action, method="POST", data=data).object
        tag = self._to_tag(data=response["objects"][0])
        return tag

    def ex_tag_resource(self, resource, tag):
        """
        Associate tag with the provided resource.

        :param resource: Resource to associate a tag with.
        :type resource: :class:`libcloud.compute.base.Node` or
                        :class:`.CloudSigmaDrive`

        :param tag: Tag to associate with the resources.
        :type tag: :class:`.CloudSigmaTag`

        :return: Updated tag object.
        :rtype: :class:`.CloudSigmaTag`
        """
        if not hasattr(resource, "id"):
            raise ValueError("Resource doesn't have id attribute")

        return self.ex_tag_resources(resources=[resource], tag=tag)

    def ex_tag_resources(self, resources, tag):
        """
        Associate tag with the provided resources.

        :param resources: Resources to associate a tag with.
        :type resources: ``list`` of :class:`libcloud.compute.base.Node` or
                        :class:`.CloudSigmaDrive`

        :param tag: Tag to associate with the resources.
        :type tag: :class:`.CloudSigmaTag`

        :return: Updated tag object.
        :rtype: :class:`.CloudSigmaTag`
        """

        resources = tag.resources[:]

        for resource in resources:
            if not hasattr(resource, "id"):
                raise ValueError("Resource doesn't have id attribute")

            resources.append(resource.id)

        resources = list(set(resources))

        data = {"name": tag.name, "resources": resources}

        action = "/tags/%s/" % (tag.id)
        response = self.connection.request(action=action, method="PUT", data=data).object
        tag = self._to_tag(data=response)
        return tag

    def ex_delete_tag(self, tag):
        """
        Delete a tag.

        :param tag: Tag to delete.
        :type tag: :class:`.CloudSigmaTag`

        :return: ``True`` on success, ``False`` otherwise.
        :rtype: ``bool``
        """
        action = "/tags/%s/" % (tag.id)
        response = self.connection.request(action=action, method="DELETE")
        return response.status == httplib.NO_CONTENT

    # Account extension methods

    def ex_get_balance(self):
        """
        Retrieve account balance information.

        :return: Dictionary with two items ("balance" and "currency").
        :rtype: ``dict``
        """
        action = "/balance/"
        response = self.connection.request(action=action, method="GET")
        return response.object

    def ex_get_pricing(self):
        """
        Retrieve pricing information that are applicable to the cloud.

        :return: Dictionary with pricing information.
        :rtype: ``dict``
        """
        action = "/pricing/"
        response = self.connection.request(action=action, method="GET")
        return response.object

    def ex_get_usage(self):
        """
        Retrieve account current usage information.

        :return: Dictionary with two items ("balance" and "usage").
        :rtype: ``dict``
        """
        action = "/currentusage/"
        response = self.connection.request(action=action, method="GET")
        return response.object

    def ex_list_subscriptions(self, status="all", resources=None):
        """
        List subscriptions for this account.

        :param status: Only return subscriptions with the provided status
                       (optional).
        :type status: ``str``
        :param resources: Only return subscriptions for the provided resources
                          (optional).
        :type resources: ``list``

        :rtype: ``list``
        """
        params = {}

        if status:
            params["status"] = status

        if resources:
            params["resource"] = ",".join(resources)

        response = self.connection.request(action="/subscriptions/", params=params).object
        subscriptions = self._to_subscriptions(data=response)
        return subscriptions

    def ex_toggle_subscription_auto_renew(self, subscription):
        """
        Toggle subscription auto renew status.

        :param subscription: Subscription to toggle the auto renew flag for.
        :type subscription: :class:`.CloudSigmaSubscription`

        :return: ``True`` on success, ``False`` otherwise.
        :rtype: ``bool``
        """
        path = "/subscriptions/%s/action/" % (subscription.id)
        response = self._perform_action(path=path, action="auto_renew", method="POST")
        return response.status == httplib.OK

    def ex_create_subscription(self, amount, period, resource, auto_renew=False):
        """
        Create a new subscription.

        :param amount: Subscription amount. For example, in dssd case this
                       would be disk size in gigabytes.
        :type amount: ``int``

        :param period: Subscription period. For example: 30 days, 1 week, 1
                                            month, ...
        :type period: ``str``

        :param resource: Resource the purchase the subscription for.
        :type resource: ``str``

        :param auto_renew: True to automatically renew the subscription.
        :type auto_renew: ``bool``
        """
        data = [
            {
                "amount": amount,
                "period": period,
                "auto_renew": auto_renew,
                "resource": resource,
            }
        ]

        response = self.connection.request(action="/subscriptions/", data=data, method="POST")
        data = response.object["objects"][0]
        subscription = self._to_subscription(data=data)
        return subscription

    # Misc extension methods

    def ex_list_capabilities(self):
        """
        Retrieve all the basic and sensible limits of the API.

        :rtype: ``dict``
        """
        action = "/capabilities/"
        response = self.connection.request(action=action, method="GET")
        capabilities = response.object
        return capabilities

    def list_key_pairs(self):
        """
        List all the available key pair objects.

        :rtype: ``list`` of :class:`KeyPair` objects
        """
        action = "/keypairs"
        response = self.connection.request(action=action, method="GET").object

        keys = [self._to_key_pair(data=item) for item in response["objects"]]

        return keys

    def get_key_pair(self, key_uuid):
        """
        Retrieve a single key pair.

        :param name: The uuid of the key pair to retrieve.
        :type name: ``str``

        :rtype: :class:`.KeyPair`
        """
        action = "/keypairs/%s/" % (key_uuid)
        response = self.connection.request(action=action, method="GET").object

        return self._to_key_pair(response)

    def create_key_pair(self, name):
        """
        Create a new SSH key.

        :param name: Key pair name.
        :type name: ``str``
        """

        action = "/keypairs/"
        data = {"objects": [{"name": name}]}
        response = self.connection.request(action=action, method="POST", data=data).object
        return self._to_key_pair(response["objects"][0])

    def import_key_pair_from_string(self, name, key_material):
        """
        Import a new public key from string.

        :param name: Key pair name.
        :type name: ``str``

        :param key_material: Public key material.
        :type key_material: ``str``

        :rtype: :class:`.KeyPair` object
        """
        action = "/keypairs/"
        data = {"objects": [{"name": name, "public_key": key_material.replace("\n", "")}]}
        response = self.connection.request(action=action, method="POST", data=data).object
        return self._to_key_pair(response["objects"][0])

    def delete_key_pair(self, key_pair):
        """
        Delete an existing key pair.

        :param key_pair: Key pair object
        :type key_pair: :class:`.KeyPair`

        :rtype: ``bool``
        """
        action = "/keypairs/%s/" % (key_pair.extra["uuid"])
        response = self.connection.request(action=action, method="DELETE")
        return response.status == 204

    def _parse_ips_from_nic(self, nic):
        """
        Parse private and public IP addresses from the provided network
        interface object.

        :param nic: NIC object.
        :type nic: ``dict``

        :return: (public_ips, private_ips) tuple.
        :rtype: ``tuple``
        """
        public_ips, private_ips = [], []

        ipv4_conf = nic["ip_v4_conf"]
        ipv6_conf = nic["ip_v6_conf"]

        ip_v4 = ipv4_conf["ip"] if ipv4_conf else None
        ip_v6 = ipv6_conf["ip"] if ipv6_conf else None

        ipv4 = ip_v4["uuid"] if ip_v4 else None
        ipv6 = ip_v4["uuid"] if ip_v6 else None

        ips = []

        if ipv4:
            ips.append(ipv4)

        if ipv6:
            ips.append(ipv6)

        runtime = nic["runtime"]

        ip_v4 = runtime["ip_v4"] if nic["runtime"] else None
        ip_v6 = runtime["ip_v6"] if nic["runtime"] else None

        ipv4 = ip_v4["uuid"] if ip_v4 else None
        ipv6 = ip_v4["uuid"] if ip_v6 else None

        if ipv4:
            ips.append(ipv4)

        if ipv6:
            ips.append(ipv6)

        ips = set(ips)

        for ip in ips:
            if is_private_subnet(ip):
                private_ips.append(ip)
            else:
                public_ips.append(ip)

        return public_ips, private_ips

    def _to_node(self, data):
        id = data["uuid"]
        name = data["name"]
        state = self.NODE_STATE_MAP.get(data["status"], NodeState.UNKNOWN)

        public_ips = []
        private_ips = []
        extra = {
            "cpus": data["cpu"] / 2000,
            "memory": data["mem"] / 1024 / 1024,
            "nics": data["nics"],
            "vnc_password": data["vnc_password"],
            "meta": data["meta"],
            "runtime": data["runtime"],
            "drives": data["drives"],
        }
        # find image name and boot drive size
        image = None
        drive_size = 0
        for item in extra["drives"]:
            if item["boot_order"] == 1:
                drive = self.ex_get_drive(item["drive"]["uuid"])
                drive_size = drive.size
                image = "{} {}".format(
                    drive.extra.get("distribution", ""), drive.extra.get("version", "")
                )
                break
        # try to find if node size is from example sizes given by CloudSigma
        try:
            kwargs = SPECS_TO_SIZE[(extra["cpus"], extra["memory"], drive_size)]
            size = CloudSigmaNodeSize(**kwargs, driver=self)
        except KeyError:
            id_to_hash = str(extra["cpus"]) + str(extra["memory"]) + str(drive_size)
            size_id = hashlib.md5(id_to_hash.encode("utf-8")).hexdigest()
            size_name = "custom, {} CPUs, {}MB RAM, {}GB disk".format(
                extra["cpus"], extra["memory"], drive_size
            )  # noqa
            size = CloudSigmaNodeSize(
                id=size_id,
                name=size_name,
                cpu=extra["cpus"],
                ram=extra["memory"],
                disk=drive_size,
                bandwidth=None,
                price=0,
                driver=self,
            )

        for nic in data["nics"]:
            _public_ips, _private_ips = self._parse_ips_from_nic(nic=nic)

            public_ips.extend(_public_ips)
            private_ips.extend(_private_ips)

        node = Node(
            id=id,
            name=name,
            state=state,
            public_ips=public_ips,
            image=image,
            private_ips=private_ips,
            driver=self,
            size=size,
            extra=extra,
        )
        return node

    def _to_image(self, data):
        extra_keys = [
            "description",
            "arch",
            "image_type",
            "os",
            "licenses",
            "media",
            "meta",
        ]

        id = data["uuid"]
        name = data["name"]
        extra = self._extract_values(obj=data, keys=extra_keys)

        image = NodeImage(id=id, name=name, driver=self, extra=extra)
        return image

    def _to_drive(self, data):
        id = data["uuid"]
        name = data["name"]
        size = data["size"] / 1024 / 1024 / 1024
        media = data["media"]
        status = data["status"]
        extra = {
            "mounted_on": data.get("mounted_on", []),
            "storage_type": data.get("storage_type", ""),
            "distribution": data["meta"].get("distribution", ""),
            "version": data["meta"].get("version", ""),
            "os": data["meta"].get("os", ""),
            "paid": data["meta"].get("paid", ""),
            "architecture": data["meta"].get("arch", ""),
            "created_at": data["meta"].get("created_at", ""),
        }

        drive = CloudSigmaDrive(
            id=id,
            name=name,
            size=size,
            media=media,
            status=status,
            driver=self,
            extra=extra,
        )

        return drive

    def _to_tag(self, data):
        resources = data["resources"]
        resources = [resource["uuid"] for resource in resources]

        tag = CloudSigmaTag(id=data["uuid"], name=data["name"], resources=resources)
        return tag

    def _to_subscriptions(self, data):
        subscriptions = []

        for item in data["objects"]:
            subscription = self._to_subscription(data=item)
            subscriptions.append(subscription)

        return subscriptions

    def _to_subscription(self, data):
        if data.get("start_time", None):
            start_time = parse_date(data["start_time"])
        else:
            start_time = None

        if data.get("end_time", None):
            end_time = parse_date(data["end_time"])
        else:
            end_time = None

        obj_uuid = data["subscribed_object"]

        subscription = CloudSigmaSubscription(
            id=data["id"],
            resource=data["resource"],
            amount=int(data["amount"]),
            period=data["period"],
            status=data["status"],
            price=data["price"],
            start_time=start_time,
            end_time=end_time,
            auto_renew=data["auto_renew"],
            subscribed_object=obj_uuid,
        )
        return subscription

    def _to_firewall_policy(self, data):
        rules = []

        for item in data.get("rules", []):
            rule = CloudSigmaFirewallPolicyRule(
                action=item["action"],
                direction=item["direction"],
                ip_proto=item["ip_proto"],
                src_ip=item["src_ip"],
                src_port=item["src_port"],
                dst_ip=item["dst_ip"],
                dst_port=item["dst_port"],
                comment=item["comment"],
            )
            rules.append(rule)

        policy = CloudSigmaFirewallPolicy(id=data["uuid"], name=data["name"], rules=rules)
        return policy

    def _to_key_pair(self, data):
        extra = {
            "uuid": data["uuid"],
            "tags": data["tags"],
            "resource_uri": data["resource_uri"],
            "permissions": data["permissions"],
            "meta": data["meta"],
        }
        return KeyPair(
            name=data["name"],
            public_key=data["public_key"],
            fingerprint=data["fingerprint"],
            driver=self,
            private_key=data["private_key"],
            extra=extra,
        )

    def _perform_action(self, path, action, method="POST", params=None, data=None):
        """
        Perform API action and return response object.
        """
        if params:
            params = params.copy()
        else:
            params = {}

        params["do"] = action
        response = self.connection.request(action=path, method=method, params=params, data=data)
        return response

    def _is_installation_cd(self, image):
        """
        Detect if the provided image is an installation CD.

        :rtype: ``bool``
        """
        if isinstance(image, CloudSigmaDrive) and image.media == "cdrom":
            return True

        return False

    def _extract_values(self, obj, keys):
        """
        Extract values from a dictionary and return a new dictionary with
        extracted values.

        :param obj: Dictionary to extract values from.
        :type obj: ``dict``

        :param keys: Keys to extract.
        :type keys: ``list``

        :return: Dictionary with extracted values.
        :rtype: ``dict``
        """
        result = {}

        for key in keys:
            result[key] = obj[key]

        return result

    def _wait_for_drive_state_transition(self, drive, state, timeout=DRIVE_TRANSITION_TIMEOUT):
        """
        Wait for a drive to transition to the provided state.

        Note: This function blocks and periodically calls "GET drive" endpoint
        to check if the drive has already transitioned to the desired state.

        :param drive: Drive to wait for.
        :type drive: :class:`.CloudSigmaDrive`

        :param state: Desired drive state.
        :type state: ``str``

        :param timeout: How long to wait for the transition (in seconds) before
                        timing out.
        :type timeout: ``int``

        :return: Drive object.
        :rtype: :class:`.CloudSigmaDrive`
        """

        start_time = time.time()

        while drive.status != state:
            drive = self.ex_get_drive(drive_id=drive.id)

            if drive.status == state:
                break

            current_time = time.time()
            delta = current_time - start_time

            if delta >= timeout:
                msg = "Timed out while waiting for drive transition " "(timeout=%s seconds)" % (
                    timeout
                )
                raise Exception(msg)

            time.sleep(self.DRIVE_TRANSITION_SLEEP_INTERVAL)

        return drive

    def _ex_connection_class_kwargs(self):
        """
        Return the host value based on the user supplied region.
        """
        kwargs = {}

        if not self._host_argument_set:
            kwargs["host"] = API_ENDPOINTS_2_0[self.region]["host"]

        return kwargs