libcloud/compute/drivers/scaleway.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.
"""
Scaleway Driver
"""

import copy

from libcloud.utils.py3 import httplib
from libcloud.common.base import JsonResponse, ConnectionUserAndKey
from libcloud.common.types import ProviderError
from libcloud.compute.base import (
    Node,
    KeyPair,
    NodeSize,
    NodeImage,
    NodeDriver,
    NodeLocation,
    StorageVolume,
    VolumeSnapshot,
)
from libcloud.compute.types import NodeState, VolumeSnapshotState
from libcloud.utils.iso8601 import parse_date
from libcloud.compute.providers import Provider

try:
    import simplejson as json
except ImportError:
    import json


__all__ = ["ScalewayResponse", "ScalewayConnection", "ScalewayNodeDriver"]

SCALEWAY_API_HOSTS = {
    "default": "cp-par1.scaleway.com",
    "account": "account.scaleway.com",
    "par1": "cp-par1.scaleway.com",
    "ams1": "cp-ams1.scaleway.com",
}

# The API doesn't give location info, so we provide it ourselves, instead.
SCALEWAY_LOCATION_DATA = [
    {"id": "par1", "name": "Paris 1", "country": "FR"},
    {"id": "ams1", "name": "Amsterdam 1", "country": "NL"},
]


class ScalewayResponse(JsonResponse):
    valid_response_codes = [
        httplib.OK,
        httplib.ACCEPTED,
        httplib.CREATED,
        httplib.NO_CONTENT,
    ]

    def parse_error(self):
        return super().parse_error()["message"]

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


class ScalewayConnection(ConnectionUserAndKey):
    """
    Connection class for the Scaleway driver.
    """

    host = SCALEWAY_API_HOSTS["default"]
    allow_insecure = False
    responseCls = ScalewayResponse

    def request(
        self,
        action,
        params=None,
        data=None,
        headers=None,
        method="GET",
        raw=False,
        stream=False,
        region=None,
    ):
        if region:
            old_host = self.host
            self.host = SCALEWAY_API_HOSTS[
                region.id if isinstance(region, NodeLocation) else region
            ]
            if not self.host == old_host:
                self.connect()

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

    def _request_paged(
        self,
        action,
        params=None,
        data=None,
        headers=None,
        method="GET",
        raw=False,
        stream=False,
        region=None,
    ):
        if params is None:
            params = {}

        if isinstance(params, dict):
            params["per_page"] = 100
        elif isinstance(params, list):
            params.append(("per_page", 100))  # pylint: disable=no-member

        results = self.request(action, params, data, headers, method, raw, stream, region).object

        links = self.connection.getresponse().links
        while links and "next" in links:
            next = self.request(
                links["next"]["url"],
                data=data,
                headers=headers,
                method=method,
                raw=raw,
                stream=stream,
            ).object
            links = self.connection.getresponse().links
            merged = {root: child + next[root] for root, child in list(results.items())}
            results = merged

        return results

    def add_default_headers(self, headers):
        """
        Add headers that are necessary for every request
        """
        headers["X-Auth-Token"] = self.key
        headers["Content-Type"] = "application/json"
        return headers


def _to_lib_size(size):
    return int(size / 1000 / 1000 / 1000)


def _to_api_size(size):
    return int(size * 1000 * 1000 * 1000)


class ScalewayNodeDriver(NodeDriver):
    """
    Scaleway Node Driver Class

    This is the primary driver for interacting with Scaleway.  It contains all
    of the standard libcloud methods that Scaleway's API supports.
    """

    type = Provider.SCALEWAY
    connectionCls = ScalewayConnection
    name = "Scaleway"
    website = "https://www.scaleway.com/"

    SNAPSHOT_STATE_MAP = {
        "snapshotting": VolumeSnapshotState.CREATING,
        "available": VolumeSnapshotState.AVAILABLE,
        "error": VolumeSnapshotState.ERROR,
    }

    def list_locations(self):
        """
        List data centers available.

        :return: list of node location objects
        :rtype: ``list`` of :class:`.NodeLocation`
        """
        return [
            NodeLocation(driver=self, **copy.deepcopy(location))
            for location in SCALEWAY_LOCATION_DATA
        ]

    def list_sizes(self, region=None):
        """
        List available VM sizes.

        :param region: The region in which to list sizes
        (if None, use default region specified in __init__)
        :type region: :class:`.NodeLocation`

        :return: list of node size objects
        :rtype: ``list`` of :class:`.NodeSize`
        """
        response = self.connection._request_paged("/products/servers", region=region)
        sizes = response["servers"]

        response = self.connection._request_paged("/products/servers/availability", region=region)
        availability = response["servers"]

        return sorted(
            (self._to_size(name, sizes[name], availability[name]) for name in sizes),
            key=lambda x: x.name,
        )

    def _to_size(self, name, size, availability):
        min_disk = (
            _to_lib_size(size["volumes_constraint"]["min_size"] or 0)
            if size["volumes_constraint"]
            else 25
        )
        max_disk = (
            _to_lib_size(size["volumes_constraint"]["max_size"] or 0)
            if size["volumes_constraint"]
            else min_disk
        )

        extra = {
            "cores": size["ncpus"],
            "monthly": size["monthly_price"],
            "arch": size["arch"],
            "baremetal": size["baremetal"],
            "availability": availability["availability"],
            "max_disk": max_disk,
            "internal_bandwidth": int(
                (size["network"]["sum_internal_bandwidth"] or 0) / (1024 * 1024)
            ),
            "ipv6": size["network"]["ipv6_support"],
            "alt_names": size["alt_names"],
        }

        return NodeSize(
            id=name,
            name=name,
            ram=int((size["ram"] or 0) / (1024 * 1024)),
            disk=min_disk,
            bandwidth=int((size["network"]["sum_internet_bandwidth"] or 0) / (1024 * 1024)),
            price=size["hourly_price"],
            driver=self,
            extra=extra,
        )

    def list_images(self, region=None):
        """
        List available VM images.

        :param region: The region in which to list images
        (if None, use default region specified in __init__)
        :type region: :class:`.NodeLocation`

        :return: list of image objects
        :rtype: ``list`` of :class:`.NodeImage`
        """
        response = self.connection._request_paged("/images", region=region)
        images = response["images"]
        return [self._to_image(image) for image in images]

    def create_image(self, node, name, region=None):
        """
        Create a VM image from an existing node's root volume.

        :param node: The node from which to create the image
        :type node: :class:`.Node`

        :param name: The name to give the image
        :type name: ``str``

        :param region: The region in which to create the image
        (if None, use default region specified in __init__)
        :type region: :class:`.NodeLocation`

        :return: the newly created image object
        :rtype: :class:`.NodeImage`
        """
        data = {
            "organization": self.key,
            "name": name,
            "arch": node.extra["arch"],
            "root_volume": node.extra["volumes"]["0"]["id"],
        }
        response = self.connection.request(
            "/images", data=json.dumps(data), region=region, method="POST"
        )
        image = response.object["image"]
        return self._to_image(image)

    def delete_image(self, node_image, region=None):
        """
        Delete a VM image.

        :param node_image: The image to delete
        :type node_image: :class:`.NodeImage`

        :param region: The region in which to find/delete the image
        (if None, use default region specified in __init__)
        :type region: :class:`.NodeLocation`

        :return: True if the image was deleted, otherwise False
        :rtype: ``bool``
        """
        return self.connection.request(
            "/images/%s" % node_image.id, region=region, method="DELETE"
        ).success()

    def get_image(self, image_id, region=None):
        """
        Retrieve a specific VM image.

        :param image_id: The id of the image to retrieve
        :type image_id: ``int``

        :param region: The region in which to create the image
        (if None, use default region specified in __init__)
        :type region: :class:`.NodeLocation`

        :return: the requested image object
        :rtype: :class:`.NodeImage`
        """
        response = self.connection.request("/images/%s" % image_id, region=region)
        image = response.object["image"]
        return self._to_image(image)

    def _to_image(self, image):
        extra = {
            "arch": image["arch"],
            "size": _to_lib_size(image.get("root_volume", {}).get("size", 0)) or 50,
            "creation_date": parse_date(image["creation_date"]),
            "modification_date": parse_date(image["modification_date"]),
            "organization": image["organization"],
        }
        return NodeImage(id=image["id"], name=image["name"], driver=self, extra=extra)

    def list_nodes(self, region=None):
        """
        List all nodes.

        :param region: The region in which to look for nodes
        (if None, use default region specified in __init__)
        :type region: :class:`.NodeLocation`

        :return: list of node objects
        :rtype: ``list`` of :class:`.Node`
        """
        response = self.connection._request_paged("/servers", region=region)
        servers = response["servers"]
        return [self._to_node(server) for server in servers]

    def _to_node(self, server):
        public_ip = server["public_ip"]
        private_ip = server["private_ip"]
        location = server["location"] or {}
        return Node(
            id=server["id"],
            name=server["name"],
            state=NodeState.fromstring(server["state"]),
            public_ips=[public_ip["address"]] if public_ip else [],
            private_ips=[private_ip] if private_ip else [],
            driver=self,
            extra={
                "volumes": server["volumes"],
                "tags": server["tags"],
                "arch": server["arch"],
                "organization": server["organization"],
                "region": location.get("zone_id", "par1"),
            },
            created_at=parse_date(server["creation_date"]),
        )

    def create_node(self, name, size, image, ex_volumes=None, ex_tags=None, region=None):
        """
        Create a new node.

        :param name: The name to give the node
        :type name: ``str``

        :param size: The size of node to create
        :type size: :class:`.NodeSize`

        :param image: The image to create the node with
        :type image: :class:`.NodeImage`

        :param ex_volumes: Additional volumes to create the node with
        :type ex_volumes: ``dict`` of :class:`.StorageVolume`s

        :param ex_tags: Tags to assign to the node
        :type ex_tags: ``list`` of ``str``

        :param region: The region in which to create the node
        (if None, use default region specified in __init__)
        :type region: :class:`.NodeLocation`

        :return: the newly created node object
        :rtype: :class:`.Node`
        """
        data = {
            "name": name,
            "organization": self.key,
            "image": image.id,
            "volumes": ex_volumes or {},
            "commercial_type": size.id,
            "tags": ex_tags or [],
        }

        allocate_space = image.extra.get("size", 50)
        for volume in data["volumes"]:
            allocate_space += _to_lib_size(volume["size"])

        while allocate_space < size.disk:
            if size.disk - allocate_space > 150:
                bump = 150
            else:
                bump = size.disk - allocate_space

            vol_num = len(data["volumes"]) + 1
            data["volumes"][str(vol_num)] = {
                "name": "%s-%d" % (name, vol_num),
                "organization": self.key,
                "size": _to_api_size(bump),
                "volume_type": "l_ssd",
            }
            allocate_space += bump

        if allocate_space > size.extra.get("max_disk", size.disk):
            range = (
                "of %dGB" % size.disk
                if size.extra.get("max_disk", size.disk) == size.disk
                else "between %dGB and %dGB" % (size.extra.get("max_disk", size.disk), size.disk)
            )
            raise ProviderError(
                value=(
                    "%s only supports a total volume size %s; tried %dGB"
                    % (size.id, range, allocate_space)
                ),
                http_code=400,
                driver=self,
            )

        response = self.connection.request(
            "/servers", data=json.dumps(data), region=region, method="POST"
        )
        server = response.object["server"]
        node = self._to_node(server)
        node.extra["region"] = (region.id if isinstance(region, NodeLocation) else region) or "par1"

        # Scaleway doesn't start servers by default, let's do it
        self._action(node.id, "poweron")

        return node

    def _action(self, server_id, action, region=None):
        return self.connection.request(
            "/servers/%s/action" % server_id,
            region=region,
            data=json.dumps({"action": action}),
            method="POST",
        ).success()

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

        :param node: The node to be rebooted
        :type node: :class:`Node`

        :return: True if the reboot was successful, otherwise False
        :rtype: ``bool``
        """
        return self._action(node.id, "reboot")

    def destroy_node(self, node):
        """
        Destroy a node.

        :param node: The node to be destroyed
        :type node: :class:`Node`

        :return: True if the destroy was successful, otherwise False
        :rtype: ``bool``
        """
        return self._action(node.id, "terminate")

    def list_volumes(self, region=None):
        """
        Return a list of volumes.

        :param region: The region in which to look for volumes
        (if None, use default region specified in __init__)
        :type region: :class:`.NodeLocation`

        :return: A list of volume objects.
        :rtype: ``list`` of :class:`StorageVolume`
        """
        response = self.connection._request_paged("/volumes", region=region)
        volumes = response["volumes"]
        return [self._to_volume(volume) for volume in volumes]

    def _to_volume(self, volume):
        extra = {
            "organization": volume["organization"],
            "volume_type": volume["volume_type"],
            "creation_date": parse_date(volume["creation_date"]),
            "modification_date": parse_date(volume["modification_date"]),
        }
        return StorageVolume(
            id=volume["id"],
            name=volume["name"],
            size=_to_lib_size(volume["size"]),
            driver=self,
            extra=extra,
        )

    def list_volume_snapshots(self, volume, region=None):
        """
        List snapshots for a storage volume.

        @inherits :class:`NodeDriver.list_volume_snapshots`

        :param region: The region in which to look for snapshots
        (if None, use default region specified in __init__)
        :type region: :class:`.NodeLocation`
        """
        response = self.connection._request_paged("/snapshots", region=region)
        snapshots = filter(lambda s: s["base_volume"]["id"] == volume.id, response["snapshots"])
        return [self._to_snapshot(snapshot) for snapshot in snapshots]

    def _to_snapshot(self, snapshot):
        state = self.SNAPSHOT_STATE_MAP.get(snapshot["state"], VolumeSnapshotState.UNKNOWN)
        extra = {
            "organization": snapshot["organization"],
            "volume_type": snapshot["volume_type"],
        }
        return VolumeSnapshot(
            id=snapshot["id"],
            driver=self,
            size=_to_lib_size(snapshot["size"]),
            created=parse_date(snapshot["creation_date"]),
            state=state,
            extra=extra,
        )

    def create_volume(self, size, name, region=None):
        """
        Create a new volume.

        :param size: Size of volume in gigabytes.
        :type size: ``int``

        :param name: Name of the volume to be created.
        :type name: ``str``

        :param region: The region in which to create the volume
        (if None, use default region specified in __init__)
        :type region: :class:`.NodeLocation`

        :return: The newly created volume.
        :rtype: :class:`StorageVolume`
        """
        data = {
            "name": name,
            "organization": self.key,
            "volume_type": "l_ssd",
            "size": _to_api_size(size),
        }
        response = self.connection.request(
            "/volumes", region=region, data=json.dumps(data), method="POST"
        )
        volume = response.object["volume"]
        return self._to_volume(volume)

    def create_volume_snapshot(self, volume, name, region=None):
        """
        Create snapshot from volume.

        :param volume: The volume to create a snapshot from
        :type volume: :class`StorageVolume`

        :param name: The name to give the snapshot
        :type name: ``str``

        :param region: The region in which to create the snapshot
        (if None, use default region specified in __init__)
        :type region: :class:`.NodeLocation`

        :return: The newly created snapshot.
        :rtype: :class:`VolumeSnapshot`
        """
        data = {"name": name, "organization": self.key, "volume_id": volume.id}
        response = self.connection.request(
            "/snapshots", region=region, data=json.dumps(data), method="POST"
        )
        snapshot = response.object["snapshot"]
        return self._to_snapshot(snapshot)

    def destroy_volume(self, volume, region=None):
        """
        Destroys a storage volume.

        :param volume: Volume to be destroyed
        :type volume: :class:`StorageVolume`

        :param region: The region in which to look for the volume
        (if None, use default region specified in __init__)
        :type region: :class:`.NodeLocation`

        :return: True if the destroy was successful, otherwise False
        :rtype: ``bool``
        """
        return self.connection.request(
            "/volumes/%s" % volume.id, region=region, method="DELETE"
        ).success()

    def destroy_volume_snapshot(self, snapshot, region=None):
        """
        Dostroy a volume snapshot

        :param snapshot: volume snapshot to destroy
        :type snapshot: class:`VolumeSnapshot`

        :param region: The region in which to look for the snapshot
        (if None, use default region specified in __init__)
        :type region: :class:`.NodeLocation`

        :return: True if the destroy was successful, otherwise False
        :rtype: ``bool``
        """
        return self.connection.request(
            "/snapshots/%s" % snapshot.id, region=region, method="DELETE"
        ).success()

    def list_key_pairs(self):
        """
        List all the available SSH keys.

        :return: Available SSH keys.
        :rtype: ``list`` of :class:`KeyPair`
        """
        response = self.connection.request("/users/%s" % (self._get_user_id()), region="account")
        keys = response.object["user"]["ssh_public_keys"]
        return [
            KeyPair(
                name=" ".join(key["key"].split(" ")[2:]),
                public_key=" ".join(key["key"].split(" ")[:2]),
                fingerprint=key["fingerprint"],
                driver=self,
            )
            for key in keys
        ]

    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``

        :return: Imported key pair object.
        :rtype: :class:`KeyPair`
        """
        new_key = KeyPair(
            name=name,
            public_key=" ".join(key_material.split(" ")[:2]),
            fingerprint=None,
            driver=self,
        )
        keys = [key for key in self.list_key_pairs() if not key.name == name]
        keys.append(new_key)
        return self._save_keys(keys)

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

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

        :return:   True of False based on success of Keypair deletion
        :rtype:    ``bool``
        """
        keys = [key for key in self.list_key_pairs() if not key.name == key_pair.name]
        return self._save_keys(keys)

    def _get_user_id(self):
        response = self.connection.request("/tokens/%s" % self.secret, region="account")
        return response.object["token"]["user_id"]

    def _save_keys(self, keys):
        data = {
            "ssh_public_keys": [{"key": "{} {}".format(key.public_key, key.name)} for key in keys]
        }
        response = self.connection.request(
            "/users/%s" % (self._get_user_id()),
            region="account",
            method="PATCH",
            data=json.dumps(data),
        )
        return response.success()