uncloud/uncloud/api/main.py

import json
import pynetbox
import logging
import argparse

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 uncloud.common import counters
from uncloud.common.vm import VMStatus
from uncloud.common.request import RequestEntry, RequestType
from uncloud.common.settings import settings
from uncloud.shared import shared
from . import schemas
from .helper import generate_mac, mac2ipv6
from uncloud import UncloudException

logger = logging.getLogger(__name__)

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

arg_parser = argparse.ArgumentParser('api', add_help=False)
arg_parser.add_argument('--port', '-p')


@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, settings['etcd']['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 post():
        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 post():
        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 post():
        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 = [f for f in files if f.value['owner'] == data['name']]
            for file in user_files:
                file_uuid = file.key.split('/')[-1]
                file = file.value
                file['uuid'] = file_uuid

                file.pop('sha512sum', None)
                file.pop('owner', None)

                return_files.append(file)
            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 post():
        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 post():
        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, settings['etcd']['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 post():
        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(debug=False, port=None):
    try:
        image_stores = list(
            shared.etcd_client.get_prefix(
                settings['etcd']['image_store_prefix'], value_in_json=True
            )
        )
    except KeyError:
        image_stores = False

    # Do not inject default values that might be very wrong
    # fail when required, not before
    #
    # if not image_stores:
    #     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),
    #     )

    try:
        app.run(host='::',
                port=port,
                debug=debug)
    except OSError as e:
        raise UncloudException('Failed to start Flask: {}'.format(e))


if __name__ == '__main__':
    main()