forked from uncloud/uncloud
120 lines
4.2 KiB
Python
120 lines
4.2 KiB
Python
import json
|
|
|
|
import uncloud.secrets as secrets
|
|
|
|
from django.core.management.base import BaseCommand
|
|
from django.contrib.auth import get_user_model
|
|
|
|
from uncloud_vm.models import VMSnapshotProduct, VMProduct, VMHost
|
|
from datetime import datetime
|
|
|
|
class Command(BaseCommand):
|
|
help = 'Select VM Host for VMs'
|
|
|
|
def add_arguments(self, parser):
|
|
parser.add_argument('--this-hostname', required=True)
|
|
parser.add_argument('--this-cluster', required=True)
|
|
|
|
parser.add_argument('--create-vm-snapshots', action='store_true')
|
|
parser.add_argument('--schedule-vms', action='store_true')
|
|
parser.add_argument('--start-vms', action='store_true')
|
|
|
|
|
|
def handle(self, *args, **options):
|
|
for cmd in [ 'create_vm_snapshots', 'schedule_vms', 'start_vms' ]:
|
|
if options[cmd]:
|
|
f = getattr(self, cmd)
|
|
f(args, options)
|
|
|
|
def schedule_vms(self, *args, **options):
|
|
for pending_vm in VMProduct.objects.filter(status='PENDING'):
|
|
cores_needed = pending_vm.cores
|
|
ram_needed = pending_vm.ram_in_gb
|
|
|
|
# Database filtering
|
|
possible_vmhosts = VMHost.objects.filter(physical_cores__gte=cores_needed)
|
|
|
|
# Logical filtering
|
|
possible_vmhosts = [ vmhost for vmhost in possible_vmhosts
|
|
if vmhost.available_cores >=cores_needed
|
|
and vmhost.available_ram_in_gb >= ram_needed ]
|
|
|
|
if not possible_vmhosts:
|
|
log.error("No suitable Host found - cannot schedule VM {}".format(pending_vm))
|
|
continue
|
|
|
|
vmhost = possible_vmhosts[0]
|
|
pending_vm.vmhost = vmhost
|
|
pending_vm.status = 'SCHEDULED'
|
|
pending_vm.save()
|
|
|
|
print("Scheduled VM {} on VMHOST {}".format(pending_vm, pending_vm.vmhost))
|
|
|
|
print(self)
|
|
|
|
def start_vms(self, *args, **options):
|
|
vmhost = VMHost.objects.get(hostname=options['this_hostname'])
|
|
|
|
if not vmhost:
|
|
raise Exception("No vmhost {} exists".format(options['vmhostname']))
|
|
|
|
# not active? done here
|
|
if not vmhost.status = 'ACTIVE':
|
|
return
|
|
|
|
vms_to_start = VMProduct.objects.filter(vmhost=vmhost,
|
|
status='SCHEDULED')
|
|
for vm in vms_to_start:
|
|
""" run qemu:
|
|
check if VM is not already active / qemu running
|
|
prepare / create the Qemu arguments
|
|
"""
|
|
print("Starting VM {}".format(VM))
|
|
|
|
def check_vms(self, *args, **options):
|
|
"""
|
|
Check if all VMs that are supposed to run are running
|
|
"""
|
|
|
|
def modify_vms(self, *args, **options):
|
|
"""
|
|
Check all VMs that are requested to be modified and restart them
|
|
"""
|
|
|
|
def create_vm_snapshots(self, *args, **options):
|
|
this_cluster = VMCluster(option['this_cluster'])
|
|
|
|
for snapshot in VMSnapshotProduct.objects.filter(status='PENDING',
|
|
cluster=this_cluster):
|
|
if not snapshot.extra_data:
|
|
snapshot.extra_data = {}
|
|
|
|
# TODO: implement locking here
|
|
if 'creating_hostname' in snapshot.extra_data:
|
|
pass
|
|
|
|
snapshot.extra_data['creating_hostname'] = options['this_hostname']
|
|
snapshot.extra_data['creating_start'] = str(datetime.now())
|
|
snapshot.save()
|
|
|
|
# something on the line of:
|
|
# for disk im vm.disks:
|
|
# rbd snap create pool/image-name@snapshot name
|
|
# snapshot.extra_data['snapshots']
|
|
# register the snapshot names in extra_data (?)
|
|
|
|
print(snapshot)
|
|
|
|
def check_health(self, *args, **options):
|
|
pending_vms = VMProduct.objects.filter(status='PENDING')
|
|
vmhosts = VMHost.objects.filter(status='active')
|
|
|
|
# 1. Check that all active hosts reported back N seconds ago
|
|
# 2. Check that no VM is running on a dead host
|
|
# 3. Migrate VMs if necessary
|
|
# 4. Check that no VMs have been pending for longer than Y seconds
|
|
|
|
# If VM snapshots exist without a VM -> notify user (?)
|
|
|
|
print("Nothing is good, you should implement me")
|