fnux/uncloud
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Shutdown Source VM (PAUSED) on successfull migration + blackened all .py files

Browse source
This commit is contained in:
ahmadbilalkhalid 2019-12-30 14:35:07 +05:00
commit 9bdf4d2180
31 changed files with 1307 additions and 638 deletions
Download patch file Download diff file Expand all files Collapse all files

16
ucloud/api/common_fields.py
View file

@ -20,12 +20,16 @@ class Field:
def is_valid(self):
if self.value == KeyError:
self.add_error("'{}' field is a required field".format(self.name))
self.add_error(
"'{}' field is a required field".format(self.name)
)
else:
if isinstance(self.value, Optional):
pass
elif not isinstance(self.value, self.type):
self.add_error("Incorrect Type for '{}' field".format(self.name))
self.add_error(
"Incorrect Type for '{}' field".format(self.name)
)
else:
self.validation()
@ -49,6 +53,10 @@ class VmUUIDField(Field):
self.validation = self.vm_uuid_validation
def vm_uuid_validation(self):
r = shared.etcd_client.get(os.path.join(settings['etcd']['vm_prefix'], self.uuid))
r = shared.etcd_client.get(
os.path.join(settings["etcd"]["vm_prefix"], self.uuid)
)
if not r:
self.add_error("VM with uuid {} does not exists".format(self.uuid))
self.add_error(
"VM with uuid {} does not exists".format(self.uuid)
)

5
ucloud/api/create_image_store.py
View file

@ -14,4 +14,7 @@ data = {
"attributes": {"list": [], "key": [], "pool": "images"},
}
shared.etcd_client.put(os.path.join(settings['etcd']['image_store_prefix'], uuid4().hex), json.dumps(data))
shared.etcd_client.put(
os.path.join(settings["etcd"]["image_store_prefix"], uuid4().hex),
json.dumps(data),
)

44
ucloud/api/helper.py
View file

@ -16,21 +16,23 @@ logger = logging.getLogger(__name__)
def check_otp(name, realm, token):
try:
data = {
"auth_name": settings['otp']['auth_name'],
"auth_token": TOTP(settings['otp']['auth_seed']).now(),
"auth_realm": settings['otp']['auth_realm'],
"auth_name": settings["otp"]["auth_name"],
"auth_token": TOTP(settings["otp"]["auth_seed"]).now(),
"auth_realm": settings["otp"]["auth_realm"],
"name": name,
"realm": realm,
"token": token,
}
except binascii.Error as err:
logger.error(
"Cannot compute OTP for seed: {}".format(settings['otp']['auth_seed'])
"Cannot compute OTP for seed: {}".format(
settings["otp"]["auth_seed"]
)
)
return 400
response = requests.post(
settings['otp']['verification_controller_url'], json=data
settings["otp"]["verification_controller_url"], json=data
)
return response.status_code
@ -43,7 +45,8 @@ def resolve_vm_name(name, owner):
"""
result = next(
filter(
lambda vm: vm.value["owner"] == owner and vm.value["name"] == name,
lambda vm: vm.value["owner"] == owner
and vm.value["name"] == name,
shared.vm_pool.vms,
),
None,
@ -80,18 +83,27 @@ def resolve_image_name(name, etcd_client):
"""
store_name, image_name = store_name_and_image_name
except Exception:
raise ValueError("Image name not in correct format i.e {store_name}:{image_name}")
raise ValueError(
"Image name not in correct format i.e {store_name}:{image_name}"
)
images = etcd_client.get_prefix(settings['etcd']['image_prefix'], value_in_json=True)
images = etcd_client.get_prefix(
settings["etcd"]["image_prefix"], value_in_json=True
)
# Try to find image with name == image_name and store_name == store_name
try:
image = next(filter(lambda im: im.value['name'] == image_name
and im.value['store_name'] == store_name, images))
image = next(
filter(
lambda im: im.value["name"] == image_name
and im.value["store_name"] == store_name,
images,
)
)
except StopIteration:
raise KeyError("No image with name {} found.".format(name))
else:
image_uuid = image.key.split('/')[-1]
image_uuid = image.key.split("/")[-1]
return image_uuid
@ -100,7 +112,9 @@ def random_bytes(num=6):
return [random.randrange(256) for _ in range(num)]
def generate_mac(uaa=False, multicast=False, oui=None, separator=':', byte_fmt='%02x'):
def generate_mac(
uaa=False, multicast=False, oui=None, separator=":", byte_fmt="%02x"
):
mac = random_bytes()
if oui:
if type(oui) == str:
@ -131,7 +145,9 @@ def get_ip_addr(mac_address, device):
and is connected/neighbor of arg:device
"""
try:
output = sp.check_output(['ip', '-6', 'neigh', 'show', 'dev', device], stderr=sp.PIPE)
output = sp.check_output(
["ip", "-6", "neigh", "show", "dev", device], stderr=sp.PIPE
)
except sp.CalledProcessError:
return None
else:
@ -160,7 +176,7 @@ def mac2ipv6(mac, prefix):
# format output
ipv6_parts = [str(0)] * 4
for i in range(0, len(parts), 2):
ipv6_parts.append("".join(parts[i:i + 2]))
ipv6_parts.append("".join(parts[i : i + 2]))
lower_part = ipaddress.IPv6Address(":".join(ipv6_parts))
prefix = ipaddress.IPv6Address(prefix)

178
ucloud/api/main.py
View file

@ -43,7 +43,7 @@ def handle_exception(e):
return e
# now you're handling non-HTTP exceptions only
return {'message': 'Server Error'}, 500
return {"message": "Server Error"}, 500
class CreateVM(Resource):
@ -55,7 +55,7 @@ class CreateVM(Resource):
validator = schemas.CreateVMSchema(data)
if validator.is_valid():
vm_uuid = uuid4().hex
vm_key = join_path(settings['etcd']['vm_prefix'], vm_uuid)
vm_key = join_path(settings["etcd"]["vm_prefix"], vm_uuid)
specs = {
"cpu": validator.specs["cpu"],
"ram": validator.specs["ram"],
@ -63,8 +63,12 @@ class CreateVM(Resource):
"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"]))]
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"],
@ -77,14 +81,15 @@ class CreateVM(Resource):
"vnc_socket": "",
"network": list(zip(data["network"], macs, tap_ids)),
"metadata": {"ssh-keys": []},
"in_migration": False
"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']
type=RequestType.ScheduleVM,
uuid=vm_uuid,
request_prefix=settings["etcd"]["request_prefix"],
)
shared.request_pool.put(r)
@ -99,7 +104,7 @@ class VmStatus(Resource):
validator = schemas.VMStatusSchema(data)
if validator.is_valid():
vm = shared.vm_pool.get(
join_path(settings['etcd']['vm_prefix'], data["uuid"])
join_path(settings["etcd"]["vm_prefix"], data["uuid"])
)
vm_value = vm.value.copy()
vm_value["ip"] = []
@ -107,13 +112,15 @@ class VmStatus(Resource):
network_name, mac, tap = network_mac_and_tap
network = shared.etcd_client.get(
join_path(
settings['etcd']['network_prefix'],
settings["etcd"]["network_prefix"],
data["name"],
network_name,
),
value_in_json=True,
)
ipv6_addr = network.value.get("ipv6").split("::")[0] + "::"
ipv6_addr = (
network.value.get("ipv6").split("::")[0] + "::"
)
vm_value["ip"].append(mac2ipv6(mac, ipv6_addr))
vm.value = vm_value
return vm.value
@ -128,7 +135,7 @@ class CreateImage(Resource):
validator = schemas.CreateImageSchema(data)
if validator.is_valid():
file_entry = shared.etcd_client.get(
join_path(settings['etcd']['file_prefix'], data["uuid"])
join_path(settings["etcd"]["file_prefix"], data["uuid"])
)
file_entry_value = json.loads(file_entry.value)
@ -141,7 +148,9 @@ class CreateImage(Resource):
"visibility": "public",
}
shared.etcd_client.put(
join_path(settings['etcd']['image_prefix'], data["uuid"]),
join_path(
settings["etcd"]["image_prefix"], data["uuid"]
),
json.dumps(image_entry_json),
)
@ -153,11 +162,9 @@ class ListPublicImages(Resource):
@staticmethod
def get():
images = shared.etcd_client.get_prefix(
settings['etcd']['image_prefix'], value_in_json=True
settings["etcd"]["image_prefix"], value_in_json=True
)
r = {
"images": []
}
r = {"images": []}
for image in images:
image_key = "{}:{}".format(
image.value["store_name"], image.value["name"]
@ -176,7 +183,7 @@ class VMAction(Resource):
if validator.is_valid():
vm_entry = shared.vm_pool.get(
join_path(settings['etcd']['vm_prefix'], data["uuid"])
join_path(settings["etcd"]["vm_prefix"], data["uuid"])
)
action = data["action"]
@ -184,13 +191,19 @@ class VMAction(Resource):
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 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")
logger.error(
"Some Error Occurred while deleting VM"
)
return {"message": "VM deletion unsuccessfull"}
else:
shared.etcd_client.client.delete(vm_entry.key)
@ -200,10 +213,13 @@ class VMAction(Resource):
type="{}VM".format(action.title()),
uuid=data["uuid"],
hostname=vm_entry.hostname,
request_prefix=settings['etcd']['request_prefix']
request_prefix=settings["etcd"]["request_prefix"],
)
shared.request_pool.put(r)
return {"message": "VM {} Queued".format(action.title())}, 200
return (
{"message": "VM {} Queued".format(action.title())},
200,
)
else:
return validator.get_errors(), 400
@ -216,15 +232,21 @@ class VMMigration(Resource):
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'])
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
return (
{"message": "VM Migration Initialization Queued"},
200,
)
else:
return validator.get_errors(), 400
@ -237,10 +259,12 @@ class ListUserVM(Resource):
if validator.is_valid():
vms = shared.etcd_client.get_prefix(
settings['etcd']['vm_prefix'], value_in_json=True
settings["etcd"]["vm_prefix"], value_in_json=True
)
return_vms = []
user_vms = filter(lambda v: v.value["owner"] == data["name"], vms)
user_vms = filter(
lambda v: v.value["owner"] == data["name"], vms
)
for vm in user_vms:
return_vms.append(
{
@ -249,9 +273,7 @@ class ListUserVM(Resource):
"specs": vm.value["specs"],
"status": vm.value["status"],
"hostname": vm.value["hostname"],
"vnc_socket": None
if vm.value.get("vnc_socket", None) is None
else vm.value["vnc_socket"],
"vnc_socket": vm.value.get("vnc_socket", None),
}
)
if return_vms:
@ -270,11 +292,13 @@ class ListUserFiles(Resource):
if validator.is_valid():
files = shared.etcd_client.get_prefix(
settings['etcd']['file_prefix'], value_in_json=True
settings["etcd"]["file_prefix"], value_in_json=True
)
return_files = []
user_files = list(
filter(lambda f: f.value["owner"] == data["name"], files)
filter(
lambda f: f.value["owner"] == data["name"], files
)
)
for file in user_files:
return_files.append(
@ -294,14 +318,18 @@ class CreateHost(Resource):
data = request.json
validator = schemas.CreateHostSchema(data)
if validator.is_valid():
host_key = join_path(settings['etcd']['host_prefix'], uuid4().hex)
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)
shared.etcd_client.put(
host_key, host_entry, value_in_json=True
)
return {"message": "Host Created"}, 200
@ -333,7 +361,7 @@ class GetSSHKeys(Resource):
# {user_prefix}/{realm}/{name}/key/
etcd_key = join_path(
settings['etcd']['user_prefix'],
settings["etcd"]["user_prefix"],
data["realm"],
data["name"],
"key",
@ -343,25 +371,30 @@ class GetSSHKeys(Resource):
)
keys = {
key.key.split("/")[-1]: key.value for key in etcd_entry
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'],
settings["etcd"]["user_prefix"],
data["realm"],
data["name"],
"key",
data["key_name"],
)
etcd_entry = shared.etcd_client.get(etcd_key, value_in_json=True)
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
etcd_entry.key.split("/")[
-1
]: etcd_entry.value
}
}
else:
@ -379,13 +412,15 @@ class AddSSHKey(Resource):
# {user_prefix}/{realm}/{name}/key/{key_name}
etcd_key = join_path(
settings['etcd']['user_prefix'],
settings["etcd"]["user_prefix"],
data["realm"],
data["name"],
"key",
data["key_name"],
)
etcd_entry = shared.etcd_client.get(etcd_key, value_in_json=True)
etcd_entry = shared.etcd_client.get(
etcd_key, value_in_json=True
)
if etcd_entry:
return {
"message": "Key with name '{}' already exists".format(
@ -394,7 +429,9 @@ class AddSSHKey(Resource):
}
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)
shared.etcd_client.put(
etcd_key, data["key"], value_in_json=True
)
return {"message": "Key added successfully"}
else:
return validator.get_errors(), 400
@ -409,13 +446,15 @@ class RemoveSSHKey(Resource):
# {user_prefix}/{realm}/{name}/key/{key_name}
etcd_key = join_path(
settings['etcd']['user_prefix'],
settings["etcd"]["user_prefix"],
data["realm"],
data["name"],
"key",
data["key_name"],
)
etcd_entry = shared.etcd_client.get(etcd_key, value_in_json=True)
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."}
@ -446,15 +485,17 @@ class CreateNetwork(Resource):
if validator.user.value:
try:
nb = pynetbox.api(
url=settings['netbox']['url'],
token=settings['netbox']['token'],
url=settings["netbox"]["url"],
token=settings["netbox"]["token"],
)
nb_prefix = nb.ipam.prefixes.get(
prefix=settings['network']['prefix']
prefix=settings["network"]["prefix"]
)
prefix = nb_prefix.available_prefixes.create(
data={
"prefix_length": int(settings['network']['prefix_length']),
"prefix_length": int(
settings["network"]["prefix_length"]
),
"description": '{}\'s network "{}"'.format(
data["name"], data["network_name"]
),
@ -463,18 +504,22 @@ class CreateNetwork(Resource):
)
except Exception as err:
app.logger.error(err)
return {"message": "Error occured while creating network."}
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'],
settings["etcd"]["network_prefix"],
data["name"],
data["network_name"],
)
shared.etcd_client.put(
network_key, network_entry, value_in_json=True
)
shared.etcd_client.put(network_key, network_entry, value_in_json=True)
return {"message": "Network successfully added."}
else:
return validator.get_errors(), 400
@ -488,9 +533,11 @@ class ListUserNetwork(Resource):
if validator.is_valid():
prefix = join_path(
settings['etcd']['network_prefix'], data["name"]
settings["etcd"]["network_prefix"], data["name"]
)
networks = shared.etcd_client.get_prefix(
prefix, value_in_json=True
)
networks = shared.etcd_client.get_prefix(prefix, value_in_json=True)
user_networks = []
for net in networks:
net.value["name"] = net.key.split("/")[-1]
@ -524,7 +571,11 @@ 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))
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,
@ -534,7 +585,12 @@ def main():
"attributes": {"list": [], "key": [], "pool": "images"},
}
shared.etcd_client.put(join_path(settings['etcd']['image_store_prefix'], uuid4().hex), json.dumps(data))
shared.etcd_client.put(
join_path(
settings["etcd"]["image_store_prefix"], uuid4().hex
),
json.dumps(data),
)
app.run(host="::", debug=True)

275
ucloud/api/schemas.py
View file

@ -80,7 +80,12 @@ class OTPSchema(BaseSchema):
super().__init__(data=data, fields=_fields)
def validation(self):
if check_otp(self.name.value, self.realm.value, self.token.value) != 200:
if (
check_otp(
self.name.value, self.realm.value, self.token.value
)
!= 200
):
self.add_error("Wrong Credentials")
@ -92,7 +97,9 @@ class CreateImageSchema(BaseSchema):
# Fields
self.uuid = Field("uuid", str, data.get("uuid", KeyError))
self.name = Field("name", str, data.get("name", KeyError))
self.image_store = Field("image_store", str, data.get("image_store", KeyError))
self.image_store = Field(
"image_store", str, data.get("image_store", KeyError)
)
# Validations
self.uuid.validation = self.file_uuid_validation
@ -103,34 +110,52 @@ class CreateImageSchema(BaseSchema):
super().__init__(data, fields)
def file_uuid_validation(self):
file_entry = shared.etcd_client.get(os.path.join(settings['etcd']['file_prefix'], self.uuid.value))
file_entry = shared.etcd_client.get(
os.path.join(
settings["etcd"]["file_prefix"], self.uuid.value
)
)
if file_entry is None:
self.add_error(
"Image File with uuid '{}' Not Found".format(self.uuid.value)
"Image File with uuid '{}' Not Found".format(
self.uuid.value
)
)
def image_store_name_validation(self):
image_stores = list(shared.etcd_client.get_prefix(settings['etcd']['image_store_prefix']))
image_stores = list(
shared.etcd_client.get_prefix(
settings["etcd"]["image_store_prefix"]
)
)
image_store = next(
filter(
lambda s: json.loads(s.value)["name"] == self.image_store.value,
lambda s: json.loads(s.value)["name"]
== self.image_store.value,
image_stores,
),
None,
)
if not image_store:
self.add_error("Store '{}' does not exists".format(self.image_store.value))
self.add_error(
"Store '{}' does not exists".format(
self.image_store.value
)
)
# Host Operations
class CreateHostSchema(OTPSchema):
def __init__(self, data):
self.parsed_specs = {}
# Fields
self.specs = Field("specs", dict, data.get("specs", KeyError))
self.hostname = Field("hostname", str, data.get("hostname", KeyError))
self.hostname = Field(
"hostname", str, data.get("hostname", KeyError)
)
# Validation
self.specs.validation = self.specs_validation
@ -142,22 +167,28 @@ class CreateHostSchema(OTPSchema):
def specs_validation(self):
ALLOWED_BASE = 10
_cpu = self.specs.value.get('cpu', KeyError)
_ram = self.specs.value.get('ram', KeyError)
_os_ssd = self.specs.value.get('os-ssd', KeyError)
_hdd = self.specs.value.get('hdd', KeyError)
_cpu = self.specs.value.get("cpu", KeyError)
_ram = self.specs.value.get("ram", KeyError)
_os_ssd = self.specs.value.get("os-ssd", KeyError)
_hdd = self.specs.value.get("hdd", KeyError)
if KeyError in [_cpu, _ram, _os_ssd, _hdd]:
self.add_error("You must specify CPU, RAM and OS-SSD in your specs")
self.add_error(
"You must specify CPU, RAM and OS-SSD in your specs"
)
return None
try:
parsed_ram = bitmath.parse_string_unsafe(_ram)
parsed_os_ssd = bitmath.parse_string_unsafe(_os_ssd)
if parsed_ram.base != ALLOWED_BASE:
self.add_error("Your specified RAM is not in correct units")
self.add_error(
"Your specified RAM is not in correct units"
)
if parsed_os_ssd.base != ALLOWED_BASE:
self.add_error("Your specified OS-SSD is not in correct units")
self.add_error(
"Your specified OS-SSD is not in correct units"
)
if _cpu < 1:
self.add_error("CPU must be atleast 1")
@ -172,7 +203,9 @@ class CreateHostSchema(OTPSchema):
for hdd in _hdd:
_parsed_hdd = bitmath.parse_string_unsafe(hdd)
if _parsed_hdd.base != ALLOWED_BASE:
self.add_error("Your specified HDD is not in correct units")
self.add_error(
"Your specified HDD is not in correct units"
)
break
else:
parsed_hdd.append(str(_parsed_hdd))
@ -183,15 +216,17 @@ class CreateHostSchema(OTPSchema):
else:
if self.get_errors():
self.specs = {
'cpu': _cpu,
'ram': str(parsed_ram),
'os-ssd': str(parsed_os_ssd),
'hdd': parsed_hdd
"cpu": _cpu,
"ram": str(parsed_ram),
"os-ssd": str(parsed_os_ssd),
"hdd": parsed_hdd,
}
def validation(self):
if self.realm.value != "ungleich-admin":
self.add_error("Invalid Credentials/Insufficient Permission")
self.add_error(
"Invalid Credentials/Insufficient Permission"
)
# VM Operations
@ -203,9 +238,13 @@ class CreateVMSchema(OTPSchema):
# Fields
self.specs = Field("specs", dict, data.get("specs", KeyError))
self.vm_name = Field("vm_name", str, data.get("vm_name", KeyError))
self.vm_name = Field(
"vm_name", str, data.get("vm_name", KeyError)
)
self.image = Field("image", str, data.get("image", KeyError))
self.network = Field("network", list, data.get("network", KeyError))
self.network = Field(
"network", list, data.get("network", KeyError)
)
# Validation
self.image.validation = self.image_validation
@ -219,17 +258,25 @@ class CreateVMSchema(OTPSchema):
def image_validation(self):
try:
image_uuid = helper.resolve_image_name(self.image.value, shared.etcd_client)
image_uuid = helper.resolve_image_name(
self.image.value, shared.etcd_client
)
except Exception as e:
logger.exception("Cannot resolve image name = %s", self.image.value)
logger.exception(
"Cannot resolve image name = %s", self.image.value
)
self.add_error(str(e))
else:
self.image_uuid = image_uuid
def vm_name_validation(self):
if resolve_vm_name(name=self.vm_name.value, owner=self.name.value):
if resolve_vm_name(
name=self.vm_name.value, owner=self.name.value
):
self.add_error(
'VM with same name "{}" already exists'.format(self.vm_name.value)
'VM with same name "{}" already exists'.format(
self.vm_name.value
)
)
def network_validation(self):
@ -237,32 +284,46 @@ class CreateVMSchema(OTPSchema):
if _network:
for net in _network:
network = shared.etcd_client.get(os.path.join(settings['etcd']['network_prefix'],
self.name.value,
net), value_in_json=True)
network = shared.etcd_client.get(
os.path.join(
settings["etcd"]["network_prefix"],
self.name.value,
net,
),
value_in_json=True,
)
if not network:
self.add_error("Network with name {} does not exists" \
.format(net))
self.add_error(
"Network with name {} does not exists".format(
net
)
)
def specs_validation(self):
ALLOWED_BASE = 10
_cpu = self.specs.value.get('cpu', KeyError)
_ram = self.specs.value.get('ram', KeyError)
_os_ssd = self.specs.value.get('os-ssd', KeyError)
_hdd = self.specs.value.get('hdd', KeyError)
_cpu = self.specs.value.get("cpu", KeyError)
_ram = self.specs.value.get("ram", KeyError)
_os_ssd = self.specs.value.get("os-ssd", KeyError)
_hdd = self.specs.value.get("hdd", KeyError)
if KeyError in [_cpu, _ram, _os_ssd, _hdd]:
self.add_error("You must specify CPU, RAM and OS-SSD in your specs")
self.add_error(
"You must specify CPU, RAM and OS-SSD in your specs"
)
return None
try:
parsed_ram = bitmath.parse_string_unsafe(_ram)
parsed_os_ssd = bitmath.parse_string_unsafe(_os_ssd)
if parsed_ram.base != ALLOWED_BASE:
self.add_error("Your specified RAM is not in correct units")
self.add_error(
"Your specified RAM is not in correct units"
)
if parsed_os_ssd.base != ALLOWED_BASE:
self.add_error("Your specified OS-SSD is not in correct units")
self.add_error(
"Your specified OS-SSD is not in correct units"
)
if _cpu < 1:
self.add_error("CPU must be atleast 1")
@ -277,7 +338,9 @@ class CreateVMSchema(OTPSchema):
for hdd in _hdd:
_parsed_hdd = bitmath.parse_string_unsafe(hdd)
if _parsed_hdd.base != ALLOWED_BASE:
self.add_error("Your specified HDD is not in correct units")
self.add_error(
"Your specified HDD is not in correct units"
)
break
else:
parsed_hdd.append(str(_parsed_hdd))
@ -288,21 +351,24 @@ class CreateVMSchema(OTPSchema):
else:
if self.get_errors():
self.specs = {
'cpu': _cpu,
'ram': str(parsed_ram),
'os-ssd': str(parsed_os_ssd),
'hdd': parsed_hdd
"cpu": _cpu,
"ram": str(parsed_ram),
"os-ssd": str(parsed_os_ssd),
"hdd": parsed_hdd,
}
class VMStatusSchema(OTPSchema):
def __init__(self, data):
data["uuid"] = (
resolve_vm_name(
name=data.get("vm_name", None),
owner=(data.get("in_support_of", None) or data.get("name", None)),
)
or KeyError
resolve_vm_name(
name=data.get("vm_name", None),
owner=(
data.get("in_support_of", None)
or data.get("name", None)
),
)
or KeyError
)
self.uuid = VmUUIDField(data)
@ -313,7 +379,8 @@ class VMStatusSchema(OTPSchema):
def validation(self):
vm = shared.vm_pool.get(self.uuid.value)
if not (
vm.value["owner"] == self.name.value or self.realm.value == "ungleich-admin"
vm.value["owner"] == self.name.value
or self.realm.value == "ungleich-admin"
):
self.add_error("Invalid User")
@ -321,11 +388,14 @@ class VMStatusSchema(OTPSchema):
class VmActionSchema(OTPSchema):
def __init__(self, data):
data["uuid"] = (
resolve_vm_name(
name=data.get("vm_name", None),
owner=(data.get("in_support_of", None) or data.get("name", None)),
)
or KeyError
resolve_vm_name(
name=data.get("vm_name", None),
owner=(
data.get("in_support_of", None)
or data.get("name", None)
),
)
or KeyError
)
self.uuid = VmUUIDField(data)
self.action = Field("action", str, data.get("action", KeyError))
@ -340,20 +410,23 @@ class VmActionSchema(OTPSchema):
allowed_actions = ["start", "stop", "delete"]
if self.action.value not in allowed_actions:
self.add_error(
"Invalid Action. Allowed Actions are {}".format(allowed_actions)
"Invalid Action. Allowed Actions are {}".format(
allowed_actions
)
)
def validation(self):
vm = shared.vm_pool.get(self.uuid.value)
if not (
vm.value["owner"] == self.name.value or self.realm.value == "ungleich-admin"
vm.value["owner"] == self.name.value
or self.realm.value == "ungleich-admin"
):
self.add_error("Invalid User")
if (
self.action.value == "start"
and vm.status == VMStatus.running
and vm.hostname != ""
self.action.value == "start"
and vm.status == VMStatus.running
and vm.hostname != ""
):
self.add_error("VM Already Running")
@ -367,15 +440,20 @@ class VmActionSchema(OTPSchema):
class VmMigrationSchema(OTPSchema):
def __init__(self, data):
data["uuid"] = (
resolve_vm_name(
name=data.get("vm_name", None),
owner=(data.get("in_support_of", None) or data.get("name", None)),
)
or KeyError
resolve_vm_name(
name=data.get("vm_name", None),
owner=(
data.get("in_support_of", None)
or data.get("name", None)
),
)
or KeyError
)
self.uuid = VmUUIDField(data)
self.destination = Field("destination", str, data.get("destination", KeyError))
self.destination = Field(
"destination", str, data.get("destination", KeyError)
)
self.destination.validation = self.destination_validation
@ -384,9 +462,18 @@ class VmMigrationSchema(OTPSchema):
def destination_validation(self):
hostname = self.destination.value
host = next(filter(lambda h: h.hostname == hostname, shared.host_pool.hosts), None)
host = next(
filter(
lambda h: h.hostname == hostname, shared.host_pool.hosts
),
None,
)
if not host:
self.add_error("No Such Host ({}) exists".format(self.destination.value))
self.add_error(
"No Such Host ({}) exists".format(
self.destination.value
)
)
elif host.status != HostStatus.alive:
self.add_error("Destination Host is dead")
else:
@ -395,20 +482,27 @@ class VmMigrationSchema(OTPSchema):
def validation(self):
vm = shared.vm_pool.get(self.uuid.value)
if not (
vm.value["owner"] == self.name.value or self.realm.value == "ungleich-admin"
vm.value["owner"] == self.name.value
or self.realm.value == "ungleich-admin"
):
self.add_error("Invalid User")
if vm.status != VMStatus.running:
self.add_error("Can't migrate non-running VM")
if vm.hostname == os.path.join(settings['etcd']['host_prefix'], self.destination.value):
self.add_error("Destination host couldn't be same as Source Host")
if vm.hostname == os.path.join(
settings["etcd"]["host_prefix"], self.destination.value
):
self.add_error(
"Destination host couldn't be same as Source Host"
)
class AddSSHSchema(OTPSchema):
def __init__(self, data):
self.key_name = Field("key_name", str, data.get("key_name", KeyError))
self.key_name = Field(
"key_name", str, data.get("key_name", KeyError)
)
self.key = Field("key", str, data.get("key_name", KeyError))
fields = [self.key_name, self.key]
@ -417,7 +511,9 @@ class AddSSHSchema(OTPSchema):
class RemoveSSHSchema(OTPSchema):
def __init__(self, data):
self.key_name = Field("key_name", str, data.get("key_name", KeyError))
self.key_name = Field(
"key_name", str, data.get("key_name", KeyError)
)
fields = [self.key_name]
super().__init__(data=data, fields=fields)
@ -425,7 +521,9 @@ class RemoveSSHSchema(OTPSchema):
class GetSSHSchema(OTPSchema):
def __init__(self, data):
self.key_name = Field("key_name", str, data.get("key_name", None))
self.key_name = Field(
"key_name", str, data.get("key_name", None)
)
fields = [self.key_name]
super().__init__(data=data, fields=fields)
@ -433,7 +531,9 @@ class GetSSHSchema(OTPSchema):
class CreateNetwork(OTPSchema):
def __init__(self, data):
self.network_name = Field("network_name", str, data.get("network_name", KeyError))
self.network_name = Field(
"network_name", str, data.get("network_name", KeyError)
)
self.type = Field("type", str, data.get("type", KeyError))
self.user = Field("user", bool, bool(data.get("user", False)))
@ -444,15 +544,26 @@ class CreateNetwork(OTPSchema):
super().__init__(data, fields=fields)
def network_name_validation(self):
network = shared.etcd_client.get(os.path.join(settings['etcd']['network_prefix'],
self.name.value,
self.network_name.value),
value_in_json=True)
network = shared.etcd_client.get(
os.path.join(
settings["etcd"]["network_prefix"],
self.name.value,
self.network_name.value,
),
value_in_json=True,
)
if network:
self.add_error("Network with name {} already exists" \
.format(self.network_name.value))
self.add_error(
"Network with name {} already exists".format(
self.network_name.value
)
)
def network_type_validation(self):
supported_network_types = ["vxlan"]
if self.type.value not in supported_network_types:
self.add_error("Unsupported Network Type. Supported network types are {}".format(supported_network_types))
self.add_error(
"Unsupported Network Type. Supported network types are {}".format(
supported_network_types
)
)