import json import pynetbox from uuid import uuid4 from os.path import join as join_path from flask import Flask, request from flask_restful import Resource, Api from ucloud.common import counters from ucloud.common.vm import VMStatus from ucloud.common.request import RequestEntry, RequestType from ucloud.config import (etcd_client, request_pool, vm_pool, host_pool, env_vars, image_storage_handler) from . import schemas from .helper import generate_mac, mac2ipv6 from . import logger app = Flask(__name__) api = Api(app) 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(env_vars.get("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(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": []}, } 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=env_vars.get("REQUEST_PREFIX") ) 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 = vm_pool.get( join_path(env_vars.get("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 = etcd_client.get( join_path( env_vars.get("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 = etcd_client.get( join_path(env_vars.get("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", } etcd_client.put( join_path(env_vars.get("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 = etcd_client.get_prefix( env_vars.get("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 = vm_pool.get( join_path(env_vars.get("VM_PREFIX"), data["uuid"]) ) action = data["action"] if action == "start": action = "schedule" if action == "delete" and vm_entry.hostname == "": if image_storage_handler.is_vm_image_exists(vm_entry.uuid): r_status = image_storage_handler.delete_vm_image(vm_entry.uuid) if r_status: 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: 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=env_vars.get("REQUEST_PREFIX") ) 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 = vm_pool.get(data["uuid"]) r = RequestEntry.from_scratch( type=RequestType.ScheduleVM, uuid=vm.uuid, destination=join_path( env_vars.get("HOST_PREFIX"), validator.destination.value ), migration=True, request_prefix=env_vars.get("REQUEST_PREFIX") ) 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 = etcd_client.get_prefix( env_vars.get("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"], # "mac": vm.value["mac"], "vnc_socket": None if vm.value.get("vnc_socket", None) is None else vm.value["vnc_socket"], } ) 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 = etcd_client.get_prefix( env_vars.get("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(env_vars.get("HOST_PREFIX"), uuid4().hex) host_entry = { "specs": data["specs"], "hostname": data["hostname"], "status": "DEAD", "last_heartbeat": "", } 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 = 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( env_vars.get('USER_PREFIX'), data["realm"], data["name"], "key", ) etcd_entry = 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( env_vars.get('USER_PREFIX'), data["realm"], data["name"], "key", data["key_name"], ) etcd_entry = 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( env_vars.get("USER_PREFIX"), data["realm"], data["name"], "key", data["key_name"], ) etcd_entry = 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. 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( env_vars.get("USER_PREFIX"), data["realm"], data["name"], "key", data["key_name"], ) etcd_entry = etcd_client.get(etcd_key, value_in_json=True) if etcd_entry: 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( etcd_client, "/v1/counter/vxlan" ), "type": data["type"], } if validator.user.value: nb = pynetbox.api( url=env_vars.get("NETBOX_URL"), token=env_vars.get("NETBOX_TOKEN"), ) nb_prefix = nb.ipam.prefixes.get( prefix=env_vars.get("PREFIX") ) prefix = nb_prefix.available_prefixes.create( data={ "prefix_length": env_vars.get( "PREFIX_LENGTH", cast=int ), "description": '{}\'s network "{}"'.format( data["name"], data["network_name"] ), "is_pool": True, } ) network_entry["ipv6"] = prefix["prefix"] else: network_entry["ipv6"] = "fd00::/64" network_key = join_path( env_vars.get("NETWORK_PREFIX"), data["name"], data["network_name"], ) 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( env_vars.get("NETWORK_PREFIX"), data["name"] ) networks = 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(etcd_client.get_prefix(env_vars.get('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"}, } etcd_client.put(join_path(env_vars.get('IMAGE_STORE_PREFIX'), uuid4().hex), json.dumps(data)) app.run(host="::", debug=True) if __name__ == "__main__": main()