271 lines
8.7 KiB
Python
Executable File
271 lines
8.7 KiB
Python
Executable File
# TODO
|
|
# 1. Allow user of realm ungleich-admin to perform any action on
|
|
# any user vm.
|
|
|
|
import json
|
|
import subprocess
|
|
import os
|
|
|
|
from flask import Flask, request
|
|
from flask_restful import Resource, Api
|
|
from uuid import uuid4
|
|
from os.path import join
|
|
from config import etcd_client as client
|
|
from config import WITHOUT_CEPH, logging
|
|
|
|
from ucloud_common.vm import VmPool, VMStatus
|
|
from ucloud_common.host import HostPool
|
|
from ucloud_common.request import RequestEntry, RequestPool, RequestType
|
|
from schemas import (CreateVMSchema, VMStatusSchema,
|
|
CreateImageSchema, VmActionSchema,
|
|
OTPSchema, CreateHostSchema,
|
|
VmMigrationSchema)
|
|
|
|
app = Flask(__name__)
|
|
api = Api(app)
|
|
|
|
vm_pool = VmPool(client, "/v1/vm")
|
|
host_pool = HostPool(client, "/v1/host")
|
|
request_pool = RequestPool(client, "/v1/request")
|
|
|
|
|
|
class CreateVM(Resource):
|
|
@staticmethod
|
|
def post():
|
|
data = request.json
|
|
validator = CreateVMSchema(data)
|
|
if validator.is_valid():
|
|
# Create VM Entry under /v1/vm/
|
|
# TODO: !!!Generate Mac Address on creation of VM
|
|
vm_uuid = uuid4().hex
|
|
vm_key = f"/v1/vm/{vm_uuid}"
|
|
vm_entry = {
|
|
"owner": data["name"],
|
|
"specs": data["specs"],
|
|
"hostname": "",
|
|
"status": "",
|
|
"image_uuid": data["image_uuid"],
|
|
"log": [],
|
|
"storage_attachment": []
|
|
}
|
|
client.put(vm_key, vm_entry, value_in_json=True)
|
|
|
|
# Create ScheduleVM Request
|
|
r = RequestEntry.from_scratch(type=RequestType.ScheduleVM,
|
|
uuid=vm_uuid)
|
|
request_pool.put(r)
|
|
|
|
return {"message": "VM Creation Queued"}, 200
|
|
else:
|
|
return validator.get_errors(), 400
|
|
|
|
|
|
class VmStatus(Resource):
|
|
@staticmethod
|
|
def get():
|
|
data = request.json
|
|
validator = VMStatusSchema(data)
|
|
if validator.is_valid():
|
|
vm = vm_pool.get(f"/v1/vm/{data['uuid']}")
|
|
return str(vm)
|
|
else:
|
|
return validator.get_errors(), 400
|
|
|
|
|
|
class CreateImage(Resource):
|
|
@staticmethod
|
|
def post():
|
|
data = request.json
|
|
validator = CreateImageSchema(data)
|
|
if validator.is_valid():
|
|
file_entry = client.get(f"/v1/file/{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",
|
|
}
|
|
client.put(f"/v1/image/{data['uuid']}", json.dumps(image_entry_json))
|
|
|
|
return {"message": "Image successfully created"}
|
|
else:
|
|
return validator.get_errors(), 400
|
|
|
|
|
|
class ListPublicImages(Resource):
|
|
@staticmethod
|
|
def get():
|
|
images = client.get_prefix("/v1/image/")
|
|
r = {}
|
|
for image in images:
|
|
r[image.key.split("/")[-1]] = json.loads(image.value)
|
|
|
|
return r, 200
|
|
|
|
|
|
class VMAction(Resource):
|
|
@staticmethod
|
|
def post():
|
|
data = request.json
|
|
validator = VmActionSchema(data)
|
|
|
|
if validator.is_valid():
|
|
vm_entry = vm_pool.get(f"/v1/vm/{data['uuid']}")
|
|
action = data["action"]
|
|
|
|
if action == "start":
|
|
vm_entry.status = VMStatus.requested_start
|
|
vm_pool.put(vm_entry)
|
|
action = "schedule"
|
|
|
|
if action == "delete" and vm_entry.hostname == "":
|
|
try:
|
|
path_without_protocol = vm_entry.path[vm_entry.path.find(":")+1:]
|
|
|
|
if WITHOUT_CEPH:
|
|
command_to_delete = ["rm", os.path.join("/var/vm", vm_entry.uuid)]
|
|
else:
|
|
command_to_delete = ["rbd", "rm", path_without_protocol]
|
|
|
|
subprocess.check_output(command_to_delete, stderr=subprocess.PIPE)
|
|
except subprocess.CalledProcessError as e:
|
|
if "No such file" in e.stderr.decode("utf-8"):
|
|
client.client.delete(vm_entry.key)
|
|
return {"message": "VM successfully deleted"}
|
|
else:
|
|
logging.exception(e)
|
|
return {"message": "Some error occurred while deleting VM"}
|
|
else:
|
|
client.client.delete(vm_entry.key)
|
|
return {"message": "VM successfully deleted"}
|
|
|
|
r = RequestEntry.from_scratch(type=f"{action.title()}VM",
|
|
uuid=data['uuid'],
|
|
hostname=vm_entry.hostname)
|
|
request_pool.put(r)
|
|
return {"message": f"VM {action.title()} Queued"}, 200
|
|
else:
|
|
return validator.get_errors(), 400
|
|
|
|
|
|
class VMMigration(Resource):
|
|
@staticmethod
|
|
def post():
|
|
data = request.json
|
|
validator = VmMigrationSchema(data)
|
|
|
|
if validator.is_valid():
|
|
vm = vm_pool.get(data['uuid'])
|
|
|
|
r = RequestEntry.from_scratch(type=RequestType.ScheduleVM,
|
|
uuid=vm.uuid,
|
|
destination=join("/v1/host", data["destination"]),
|
|
migration=True)
|
|
request_pool.put(r)
|
|
return {"message": f"VM Migration Initialization Queued"}, 200
|
|
else:
|
|
return validator.get_errors(), 400
|
|
|
|
|
|
class ListUserVM(Resource):
|
|
@staticmethod
|
|
def get():
|
|
data = request.json
|
|
validator = OTPSchema(data)
|
|
|
|
if validator.is_valid():
|
|
vms = client.get_prefix(f"/v1/vm/", value_in_json=True)
|
|
if vms:
|
|
return_vms = []
|
|
user_vms = list(filter(lambda v: v.value["owner"] == data["name"], vms))
|
|
for vm in user_vms:
|
|
return_vms.append(
|
|
{
|
|
"vm_uuid": vm.key.split("/")[-1],
|
|
"specs": vm.value["specs"],
|
|
"status": vm.value["status"],
|
|
"hostname": vm.value["hostname"]
|
|
}
|
|
)
|
|
return {"message": return_vms}, 200
|
|
else:
|
|
return {"message": "No VM found"}, 404
|
|
else:
|
|
return validator.get_errors(), 400
|
|
|
|
|
|
class ListUserFiles(Resource):
|
|
@staticmethod
|
|
def get():
|
|
data = request.json
|
|
validator = OTPSchema(data)
|
|
|
|
if validator.is_valid():
|
|
files = client.get_prefix(f"/v1/file/", value_in_json=True)
|
|
if files:
|
|
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 {"message": "No File found"}, 404
|
|
else:
|
|
return validator.get_errors(), 400
|
|
|
|
|
|
class CreateHost(Resource):
|
|
@staticmethod
|
|
def post():
|
|
data = request.json
|
|
validator = CreateHostSchema(data)
|
|
if validator.is_valid():
|
|
host_key = f"/v1/host/{uuid4().hex}"
|
|
host_entry = {
|
|
"specs": data["specs"],
|
|
"hostname": data["hostname"],
|
|
"status": "DEAD",
|
|
"last_heartbeat": "",
|
|
}
|
|
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
|
|
|
|
|
|
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(CreateHost, "/host/create")
|
|
api.add_resource(ListHost, "/host/list")
|
|
|
|
if __name__ == "__main__":
|
|
app.run(host="::", debug=True)
|