uncloud-mravi/ucloud/api/main.py

import json
import pynetbox
import logging

from uuid import uuid4
from os.path import join as join_path

from flask import Flask, request
from flask_restful import Resource, Api
from werkzeug.exceptions import HTTPException

from ucloud.common import counters
from ucloud.common.vm import VMStatus
from ucloud.common.request import RequestEntry, RequestType
from ucloud.settings import settings
from ucloud.shared import shared

from . import schemas
from .helper import generate_mac, mac2ipv6


def get_parent(obj, attr):
    parent = getattr(obj, attr)
    child = parent
    while parent is not None:
        child = parent
        parent = getattr(parent, attr)
    return child


logger = logging.getLogger(__name__)

app = Flask(__name__)
api = Api(app)
app.logger.handlers.clear()


@app.errorhandler(Exception)
def handle_exception(e):
    app.logger.error(e)
    # pass through HTTP errors
    if isinstance(e, HTTPException):
        return e

    # now you're handling non-HTTP exceptions only
    return {"message": "Server Error"}, 500


class CreateVM(Resource):
    """API Request to Handle Creation of VM"""

    @staticmethod
    def post():
        data = request.json
        validator = schemas.CreateVMSchema(data)
        if validator.is_valid():
            vm_uuid = uuid4().hex
            vm_key = join_path(settings["etcd"]["vm_prefix"], vm_uuid)
            specs = {
                "cpu": validator.specs["cpu"],
                "ram": validator.specs["ram"],
                "os-ssd": validator.specs["os-ssd"],
                "hdd": validator.specs["hdd"],
            }
            macs = [generate_mac() for _ in range(len(data["network"]))]
            tap_ids = [
                counters.increment_etcd_counter(
                    shared.etcd_client, "/v1/counter/tap"
                )
                for _ in range(len(data["network"]))
            ]
            vm_entry = {
                "name": data["vm_name"],
                "owner": data["name"],
                "owner_realm": data["realm"],
                "specs": specs,
                "hostname": "",
                "status": VMStatus.stopped,
                "image_uuid": validator.image_uuid,
                "log": [],
                "vnc_socket": "",
                "network": list(zip(data["network"], macs, tap_ids)),
                "metadata": {"ssh-keys": []},
                "in_migration": False,
            }
            shared.etcd_client.put(vm_key, vm_entry, value_in_json=True)

            # Create ScheduleVM Request
            r = RequestEntry.from_scratch(
                type=RequestType.ScheduleVM,
                uuid=vm_uuid,
                request_prefix=settings["etcd"]["request_prefix"],
            )
            shared.request_pool.put(r)

            return {"message": "VM Creation Queued"}, 200
        return validator.get_errors(), 400


class VmStatus(Resource):
    @staticmethod
    def get():
        data = request.json
        validator = schemas.VMStatusSchema(data)
        if validator.is_valid():
            vm = shared.vm_pool.get(
                join_path(settings["etcd"]["vm_prefix"], data["uuid"])
            )
            vm_value = vm.value.copy()
            vm_value["ip"] = []
            for network_mac_and_tap in vm.network:
                network_name, mac, tap = network_mac_and_tap
                network = shared.etcd_client.get(
                    join_path(
                        settings["etcd"]["network_prefix"],
                        data["name"],
                        network_name,
                    ),
                    value_in_json=True,
                )
                ipv6_addr = (
                    network.value.get("ipv6").split("::")[0] + "::"
                )
                vm_value["ip"].append(mac2ipv6(mac, ipv6_addr))
            vm.value = vm_value
            return vm.value
        else:
            return validator.get_errors(), 400


class CreateImage(Resource):
    @staticmethod
    def post():
        data = request.json
        validator = schemas.CreateImageSchema(data)
        if validator.is_valid():
            file_entry = shared.etcd_client.get(
                join_path(settings["etcd"]["file_prefix"], data["uuid"])
            )
            file_entry_value = json.loads(file_entry.value)

            image_entry_json = {
                "status": "TO_BE_CREATED",
                "owner": file_entry_value["owner"],
                "filename": file_entry_value["filename"],
                "name": data["name"],
                "store_name": data["image_store"],
                "visibility": "public",
            }
            shared.etcd_client.put(
                join_path(
                    settings["etcd"]["image_prefix"], data["uuid"]
                ),
                json.dumps(image_entry_json),
            )

            return {"message": "Image queued for creation."}
        return validator.get_errors(), 400


class ListPublicImages(Resource):
    @staticmethod
    def get():
        images = shared.etcd_client.get_prefix(
            settings["etcd"]["image_prefix"], value_in_json=True
        )
        r = {"images": []}
        for image in images:
            image_key = "{}:{}".format(
                image.value["store_name"], image.value["name"]
            )
            r["images"].append(
                {"name": image_key, "status": image.value["status"]}
            )
        return r, 200


class VMAction(Resource):
    @staticmethod
    def post():
        data = request.json
        validator = schemas.VmActionSchema(data)

        if validator.is_valid():
            vm_entry = shared.vm_pool.get(
                join_path(settings["etcd"]["vm_prefix"], data["uuid"])
            )
            action = data["action"]

            if action == "start":
                action = "schedule"

            if action == "delete" and vm_entry.hostname == "":
                if shared.storage_handler.is_vm_image_exists(
                    vm_entry.uuid
                ):
                    r_status = shared.storage_handler.delete_vm_image(
                        vm_entry.uuid
                    )
                    if r_status:
                        shared.etcd_client.client.delete(vm_entry.key)
                        return {"message": "VM successfully deleted"}
                    else:
                        logger.error(
                            "Some Error Occurred while deleting VM"
                        )
                        return {"message": "VM deletion unsuccessfull"}
                else:
                    shared.etcd_client.client.delete(vm_entry.key)
                    return {"message": "VM successfully deleted"}

            r = RequestEntry.from_scratch(
                type="{}VM".format(action.title()),
                uuid=data["uuid"],
                hostname=vm_entry.hostname,
                request_prefix=settings["etcd"]["request_prefix"],
            )
            shared.request_pool.put(r)
            return (
                {"message": "VM {} Queued".format(action.title())},
                200,
            )
        else:
            return validator.get_errors(), 400


class VMMigration(Resource):
    @staticmethod
    def post():
        data = request.json
        validator = schemas.VmMigrationSchema(data)

        if validator.is_valid():
            vm = shared.vm_pool.get(data["uuid"])
            r = RequestEntry.from_scratch(
                type=RequestType.InitVMMigration,
                uuid=vm.uuid,
                hostname=join_path(
                    settings["etcd"]["host_prefix"],
                    validator.destination.value,
                ),
                request_prefix=settings["etcd"]["request_prefix"],
            )

            shared.request_pool.put(r)
            return (
                {"message": "VM Migration Initialization Queued"},
                200,
            )
        else:
            return validator.get_errors(), 400


class ListUserVM(Resource):
    @staticmethod
    def get():
        data = request.json
        validator = schemas.OTPSchema(data)

        if validator.is_valid():
            vms = shared.etcd_client.get_prefix(
                settings["etcd"]["vm_prefix"], value_in_json=True
            )
            return_vms = []
            user_vms = filter(
                lambda v: v.value["owner"] == data["name"], vms
            )
            for vm in user_vms:
                return_vms.append(
                    {
                        "name": vm.value["name"],
                        "vm_uuid": vm.key.split("/")[-1],
                        "specs": vm.value["specs"],
                        "status": vm.value["status"],
                        "hostname": vm.value["hostname"],
                        "vnc_socket": vm.value.get("vnc_socket", None),
                    }
                )
            if return_vms:
                return {"message": return_vms}, 200
            return {"message": "No VM found"}, 404

        else:
            return validator.get_errors(), 400


class ListUserFiles(Resource):
    @staticmethod
    def get():
        data = request.json
        validator = schemas.OTPSchema(data)

        if validator.is_valid():
            files = shared.etcd_client.get_prefix(
                settings["etcd"]["file_prefix"], value_in_json=True
            )
            return_files = []
            user_files = list(
                filter(
                    lambda f: f.value["owner"] == data["name"], files
                )
            )
            for file in user_files:
                return_files.append(
                    {
                        "filename": file.value["filename"],
                        "uuid": file.key.split("/")[-1],
                    }
                )
            return {"message": return_files}, 200
        else:
            return validator.get_errors(), 400


class CreateHost(Resource):
    @staticmethod
    def post():
        data = request.json
        validator = schemas.CreateHostSchema(data)
        if validator.is_valid():
            host_key = join_path(
                settings["etcd"]["host_prefix"], uuid4().hex
            )
            host_entry = {
                "specs": data["specs"],
                "hostname": data["hostname"],
                "status": "DEAD",
                "last_heartbeat": "",
            }
            shared.etcd_client.put(
                host_key, host_entry, value_in_json=True
            )

            return {"message": "Host Created"}, 200

        return validator.get_errors(), 400


class ListHost(Resource):
    @staticmethod
    def get():
        hosts = shared.host_pool.hosts
        r = {
            host.key: {
                "status": host.status,
                "specs": host.specs,
                "hostname": host.hostname,
            }
            for host in hosts
        }
        return r, 200


class GetSSHKeys(Resource):
    @staticmethod
    def get():
        data = request.json
        validator = schemas.GetSSHSchema(data)
        if validator.is_valid():
            if not validator.key_name.value:

                # {user_prefix}/{realm}/{name}/key/
                etcd_key = join_path(
                    settings["etcd"]["user_prefix"],
                    data["realm"],
                    data["name"],
                    "key",
                )
                etcd_entry = shared.etcd_client.get_prefix(
                    etcd_key, value_in_json=True
                )

                keys = {
                    key.key.split("/")[-1]: key.value
                    for key in etcd_entry
                }
                return {"keys": keys}
            else:

                # {user_prefix}/{realm}/{name}/key/{key_name}
                etcd_key = join_path(
                    settings["etcd"]["user_prefix"],
                    data["realm"],
                    data["name"],
                    "key",
                    data["key_name"],
                )
                etcd_entry = shared.etcd_client.get(
                    etcd_key, value_in_json=True
                )

                if etcd_entry:
                    return {
                        "keys": {
                            etcd_entry.key.split("/")[
                                -1
                            ]: etcd_entry.value
                        }
                    }
                else:
                    return {"keys": {}}
        else:
            return validator.get_errors(), 400


class AddSSHKey(Resource):
    @staticmethod
    def post():
        data = request.json
        validator = schemas.AddSSHSchema(data)
        if validator.is_valid():

            # {user_prefix}/{realm}/{name}/key/{key_name}
            etcd_key = join_path(
                settings["etcd"]["user_prefix"],
                data["realm"],
                data["name"],
                "key",
                data["key_name"],
            )
            etcd_entry = shared.etcd_client.get(
                etcd_key, value_in_json=True
            )
            if etcd_entry:
                return {
                    "message": "Key with name '{}' already exists".format(
                        data["key_name"]
                    )
                }
            else:
                # Key Not Found. It implies user' haven't added any key yet.
                shared.etcd_client.put(
                    etcd_key, data["key"], value_in_json=True
                )
                return {"message": "Key added successfully"}
        else:
            return validator.get_errors(), 400


class RemoveSSHKey(Resource):
    @staticmethod
    def get():
        data = request.json
        validator = schemas.RemoveSSHSchema(data)
        if validator.is_valid():

            # {user_prefix}/{realm}/{name}/key/{key_name}
            etcd_key = join_path(
                settings["etcd"]["user_prefix"],
                data["realm"],
                data["name"],
                "key",
                data["key_name"],
            )
            etcd_entry = shared.etcd_client.get(
                etcd_key, value_in_json=True
            )
            if etcd_entry:
                shared.etcd_client.client.delete(etcd_key)
                return {"message": "Key successfully removed."}
            else:
                return {
                    "message": "No Key with name '{}' Exists at all.".format(
                        data["key_name"]
                    )
                }
        else:
            return validator.get_errors(), 400


class CreateNetwork(Resource):
    @staticmethod
    def post():
        data = request.json
        validator = schemas.CreateNetwork(data)

        if validator.is_valid():

            network_entry = {
                "id": counters.increment_etcd_counter(
                    shared.etcd_client, "/v1/counter/vxlan"
                ),
                "type": data["type"],
            }
            if validator.user.value:
                try:
                    nb = pynetbox.api(
                        url=settings["netbox"]["url"],
                        token=settings["netbox"]["token"],
                    )
                    nb_prefix = nb.ipam.prefixes.get(
                        prefix=settings["network"]["prefix"]
                    )
                    prefix = nb_prefix.available_prefixes.create(
                        data={
                            "prefix_length": int(
                                settings["network"]["prefix_length"]
                            ),
                            "description": '{}\'s network "{}"'.format(
                                data["name"], data["network_name"]
                            ),
                            "is_pool": True,
                        }
                    )
                except Exception as err:
                    app.logger.error(err)
                    return {
                        "message": "Error occured while creating network."
                    }
                else:
                    network_entry["ipv6"] = prefix["prefix"]
            else:
                network_entry["ipv6"] = "fd00::/64"

            network_key = join_path(
                settings["etcd"]["network_prefix"],
                data["name"],
                data["network_name"],
            )
            shared.etcd_client.put(
                network_key, network_entry, value_in_json=True
            )
            return {"message": "Network successfully added."}
        else:
            return validator.get_errors(), 400


class ListUserNetwork(Resource):
    @staticmethod
    def get():
        data = request.json
        validator = schemas.OTPSchema(data)

        if validator.is_valid():
            prefix = join_path(
                settings["etcd"]["network_prefix"], data["name"]
            )
            networks = shared.etcd_client.get_prefix(
                prefix, value_in_json=True
            )
            user_networks = []
            for net in networks:
                net.value["name"] = net.key.split("/")[-1]
                user_networks.append(net.value)
            return {"networks": user_networks}, 200
        else:
            return validator.get_errors(), 400


api.add_resource(CreateVM, "/vm/create")
api.add_resource(VmStatus, "/vm/status")

api.add_resource(VMAction, "/vm/action")
api.add_resource(VMMigration, "/vm/migrate")

api.add_resource(CreateImage, "/image/create")
api.add_resource(ListPublicImages, "/image/list-public")

api.add_resource(ListUserVM, "/user/vms")
api.add_resource(ListUserFiles, "/user/files")
api.add_resource(ListUserNetwork, "/user/networks")

api.add_resource(AddSSHKey, "/user/add-ssh")
api.add_resource(RemoveSSHKey, "/user/remove-ssh")
api.add_resource(GetSSHKeys, "/user/get-ssh")

api.add_resource(CreateHost, "/host/create")
api.add_resource(ListHost, "/host/list")

api.add_resource(CreateNetwork, "/network/create")


def main():
    image_stores = list(
        shared.etcd_client.get_prefix(
            settings["etcd"]["image_store_prefix"], value_in_json=True
        )
    )
    if len(image_stores) == 0:
        data = {
            "is_public": True,
            "type": "ceph",
            "name": "images",
            "description": "first ever public image-store",
            "attributes": {"list": [], "key": [], "pool": "images"},
        }

        shared.etcd_client.put(
            join_path(
                settings["etcd"]["image_store_prefix"], uuid4().hex
            ),
            json.dumps(data),
        )

    app.run(host="::", debug=True)


if __name__ == "__main__":
    main()