pvc/VMInstance.py

331 lines
13 KiB
Python
Raw Normal View History

2018-05-31 20:26:44 -04:00
#!/usr/bin/env python3
# VMInstance.py - Class implementing a PVC virtual machine and run by pvcd
# Part of the Parallel Virtual Cluster (PVC) system
#
# Copyright (C) 2018 Joshua M. Boniface <joshua@boniface.me>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
#
###############################################################################
2018-06-06 22:59:31 -04:00
import os, sys, uuid, socket, time, threading, libvirt, kazoo.client, ansiiprint
2018-05-31 20:26:44 -04:00
class VMInstance:
2018-06-06 22:59:31 -04:00
# Initialization function
2018-06-08 12:19:48 -04:00
def __init__(self, domuuid, zk, config, thishypervisor):
2018-05-31 20:26:44 -04:00
# Passed-in variables on creation
self.domuuid = domuuid
self.zk = zk
2018-06-08 12:19:48 -04:00
self.config = config
2018-05-31 20:26:44 -04:00
self.thishypervisor = thishypervisor
# These will all be set later
self.hypervisor = None
self.state = None
self.instart = False
self.instop = False
self.inshutdown = False
self.inmigrate = False
self.inreceive = False
2018-05-31 20:26:44 -04:00
self.dom = self.lookupByUUID(self.domuuid)
2018-05-31 20:26:44 -04:00
# Watch for changes to the state field in Zookeeper
@zk.DataWatch('/domains/{}/state'.format(self.domuuid))
def watch_state(data, stat, event=""):
self.manage_vm_state()
# Watch for changes to the hypervisor field in Zookeeper
# @zk.DataWatch('/domains/{}/hypervisor'.format(self.domuuid))
# def watch_hypervisor(data, stat, event=""):
# if self.ininit == False:
# self.manage_vm_state()
# else:
# # This case handles the very first init at startup to avoid it happening twice
# self.ininit = False
# self.manage_vm_state()
# Get data functions
2018-06-02 15:19:29 -04:00
def getstate(self):
return self.state
2018-06-02 15:19:29 -04:00
def gethypervisor(self):
return self.hypervisor
2018-05-31 20:26:44 -04:00
# Start up the VM
def start_vm(self, xmlconfig):
ansiiprint.echo('Starting VM', '{}:'.format(self.domuuid), 'i')
self.instart = True
# Start up a new Libvirt connection
libvirt_name = "qemu:///system"
conn = libvirt.open(libvirt_name)
if conn == None:
ansiiprint.echo('Failed to open local libvirt connection', '{}:'.format(self.domuuid), 'e')
self.instart = False
return
try:
dom = conn.createXML(xmlconfig, 0)
2018-06-10 21:04:00 -04:00
if not self.domuuid in self.thishypervisor.domain_list:
self.thishypervisor.domain_list.append(self.domuuid)
ansiiprint.echo('Successfully started VM', '{}:'.format(self.domuuid), 'o')
self.dom = dom
2018-06-02 16:09:25 -04:00
except libvirt.libvirtError as e:
ansiiprint.echo('Failed to create VM', '{}:'.format(self.domuuid), 'e')
self.zk.set('/domains/{}/state'.format(self.domuuid), 'stop'.encode('ascii'))
2018-06-10 21:04:00 -04:00
self.dom = None
2018-06-02 00:33:54 -04:00
conn.close()
self.instart = False
2018-05-31 20:26:44 -04:00
# Stop the VM forcibly without updating state
def terminate_vm(self):
ansiiprint.echo('Terminating VM', '{}:'.format(self.domuuid), 'i')
self.instop = True
try:
self.dom.destroy()
except AttributeError:
ansiiprint.echo('Failed to terminate VM', '{}:'.format(self.domuuid), 'e')
if self.domuuid in self.thishypervisor.domain_list:
try:
self.thishypervisor.domain_list.remove(self.domuuid)
except ValueError:
pass
ansiiprint.echo('Successfully terminated VM', '{}:'.format(self.domuuid), 'o')
2018-06-11 19:14:22 -04:00
self.instop = False
2018-05-31 20:26:44 -04:00
# Stop the VM forcibly
def stop_vm(self):
ansiiprint.echo('Forcibly stopping VM', '{}:'.format(self.domuuid), 'i')
self.instop = True
try:
self.dom.destroy()
except AttributeError:
ansiiprint.echo('Failed to stop VM', '{}:'.format(self.domuuid), 'e')
if self.domuuid in self.thishypervisor.domain_list:
try:
self.thishypervisor.domain_list.remove(self.domuuid)
except ValueError:
pass
2018-06-02 15:52:50 -04:00
self.zk.set('/domains/{}/state'.format(self.domuuid), 'stop'.encode('ascii'))
ansiiprint.echo('Successfully stopped VM', '{}:'.format(self.domuuid), 'o')
2018-06-02 15:52:50 -04:00
self.dom = None
self.instop = False
2018-05-31 20:26:44 -04:00
# Shutdown the VM gracefully
def shutdown_vm(self):
ansiiprint.echo('Gracefully stopping VM', '{}:'.format(self.domuuid), 'i')
self.inshutdown = True
2018-05-31 20:26:44 -04:00
self.dom.shutdown()
2018-06-02 16:24:11 -04:00
try:
tick = 0
while self.dom.state()[0] == libvirt.VIR_DOMAIN_RUNNING and tick < 60:
tick += 1
2018-06-02 16:24:11 -04:00
time.sleep(0.5)
if tick >= 60:
ansiiprint.echo('Shutdown timeout expired', '{}:'.format(self.domuuid), 'e')
self.stop_vm()
self.inshutdown = False
return
2018-06-02 16:24:11 -04:00
except:
pass
2018-06-02 16:19:51 -04:00
if self.domuuid in self.thishypervisor.domain_list:
try:
self.thishypervisor.domain_list.remove(self.domuuid)
except ValueError:
pass
2018-05-31 20:26:44 -04:00
self.zk.set('/domains/{}/state'.format(self.domuuid), 'stop'.encode('ascii'))
ansiiprint.echo('Successfully shutdown VM', '{}:'.format(self.domuuid), 'o')
2018-06-02 15:52:50 -04:00
self.dom = None
self.inshutdown = False
2018-06-02 15:52:50 -04:00
def live_migrate_vm(self, dest_hypervisor):
2018-06-02 15:39:17 -04:00
try:
2018-06-06 21:54:38 -04:00
dest_conn = libvirt.open('qemu+tcp://{}/system'.format(self.hypervisor))
2018-06-02 15:39:17 -04:00
if dest_conn == None:
raise
except:
ansiiprint.echo('Failed to open connection to qemu+tcp://{}/system; aborting migration.'.format(self.hypervisor), '{}:'.format(self.domuuid), 'e')
return 1
2018-05-31 20:26:44 -04:00
2018-06-02 15:39:17 -04:00
try:
target_dom = self.dom.migrate(dest_conn, libvirt.VIR_MIGRATE_LIVE, None, None, 0)
if target_dom == None:
raise
ansiiprint.echo('Successfully migrated VM', '{}:'.format(self.domuuid), 'o')
2018-06-06 22:59:31 -04:00
2018-06-02 15:39:17 -04:00
except:
dest_conn.close()
return 1
dest_conn.close()
return 0
# Migrate the VM to a target host
def migrate_vm(self):
self.inmigrate = True
ansiiprint.echo('Migrating VM to hypervisor "{}"'.format(self.hypervisor), '{}:'.format(self.domuuid), 'i')
migrate_ret = self.live_migrate_vm(self.hypervisor)
if migrate_ret != 0:
ansiiprint.echo('Could not live migrate VM; shutting down to migrate instead', '{}:'.format(self.domuuid), 'e')
self.shutdown_vm()
2018-06-06 21:54:38 -04:00
time.sleep(1)
self.zk.set('/domains/{}/state'.format(self.domuuid), 'start'.encode('ascii'))
else:
try:
self.thishypervisor.domain_list.remove(self.domuuid)
except ValueError:
pass
time.sleep(1)
self.zk.set('/domains/{}/state'.format(self.domuuid), 'start'.encode('ascii'))
2018-06-02 15:58:21 -04:00
self.inmigrate = False
2018-06-04 11:49:39 -04:00
2018-05-31 20:26:44 -04:00
# Receive the migration from another host (wait until VM is running)
def receive_migrate(self):
self.inreceive = True
2018-06-11 16:53:04 -04:00
ansiiprint.echo('Receiving migration', '{}:'.format(self.domuuid), 'i')
2018-06-11 03:01:12 -04:00
while True:
self.state = self.zk.get('/domains/{}/state'.format(self.domuuid))[0].decode('ascii')
2018-06-07 00:40:32 -04:00
self.dom = self.lookupByUUID(self.domuuid)
if self.dom == None and self.state == 'migrate':
2018-06-02 19:06:59 -04:00
continue
2018-06-02 18:38:59 -04:00
if self.state != 'migrate':
2018-06-02 19:06:59 -04:00
break
2018-06-02 18:38:59 -04:00
try:
if self.dom.state()[0] == libvirt.VIR_DOMAIN_RUNNING:
break
except:
continue
2018-06-11 02:03:23 -04:00
if self.dom.state()[0] == libvirt.VIR_DOMAIN_RUNNING:
if not self.domuuid in self.thishypervisor.domain_list:
self.thishypervisor.domain_list.append(self.domuuid)
2018-06-11 02:08:09 -04:00
ansiiprint.echo('Successfully received migrated VM', '{}:'.format(self.domuuid), 'o')
self.zk.set('/domains/{}/state'.format(self.domuuid), 'start'.encode('ascii'))
2018-06-11 16:53:04 -04:00
else:
2018-06-11 02:03:23 -04:00
ansiiprint.echo('Failed to receive migrated VM', '{}:'.format(self.domuuid), 'e')
2018-06-11 16:53:04 -04:00
self.zk.set('/domains/{}/state'.format(self.domuuid), 'start'.encode('ascii'))
self.inreceive = False
2018-05-31 23:28:26 -04:00
2018-05-31 20:26:44 -04:00
#
# Main function to manage a VM (taking only self)
#
def manage_vm_state(self):
# Give ourselves a bit of leeway time
time.sleep(0.2)
# Get the current values from zookeeper
self.state = self.zk.get('/domains/{}/state'.format(self.domuuid))[0].decode('ascii')
self.hypervisor = self.zk.get('/domains/{}/hypervisor'.format(self.domuuid))[0].decode('ascii')
2018-05-31 20:26:44 -04:00
# Check the current state of the VM
try:
2018-05-31 23:28:26 -04:00
if self.dom != None:
2018-06-06 11:42:49 -04:00
running, reason = self.dom.state()
2018-05-31 23:28:26 -04:00
else:
2018-06-02 15:52:50 -04:00
raise
2018-05-31 20:26:44 -04:00
except:
running = libvirt.VIR_DOMAIN_NOSTATE
2018-05-31 20:26:44 -04:00
2018-06-11 19:22:33 -04:00
ansiiprint.echo('VM state change for "{}": {} {}'.format(self.domuuid, self.state, self.hypervisor), '', 'i')
# Conditional pass one - If we're already doing something, bail out
if self.instart == True or self.instop == True or self.inshutdown == True or self.inmigrate == True or self.inreceive == True:
return 0
2018-06-02 15:26:37 -04:00
# VM should be stopped
if running == libvirt.VIR_DOMAIN_RUNNING and self.state == "stop" and self.hypervisor == self.thishypervisor.name:
2018-05-31 20:26:44 -04:00
self.stop_vm()
2018-06-02 15:26:37 -04:00
# VM should be shut down
elif running == libvirt.VIR_DOMAIN_RUNNING and self.state == "shutdown" and self.hypervisor == self.thishypervisor.name:
2018-05-31 20:26:44 -04:00
self.shutdown_vm()
2018-06-02 15:26:37 -04:00
# VM should be migrated to this hypervisor
elif running != libvirt.VIR_DOMAIN_RUNNING and self.state == "migrate" and self.hypervisor == self.thishypervisor.name:
self.receive_migrate()
2018-06-02 15:26:37 -04:00
# VM should be migrated away from this hypervisor
elif running == libvirt.VIR_DOMAIN_RUNNING and self.state == "migrate" and self.hypervisor != self.thishypervisor.name:
2018-05-31 20:26:44 -04:00
self.migrate_vm()
# VM should be running but not on this hypervisor
elif running == libvirt.VIR_DOMAIN_RUNNING and self.state == "start" and self.hypervisor != self.thishypervisor.name:
self.terminate_vm()
2018-06-02 15:54:43 -04:00
# VM is already running and should be
elif running == libvirt.VIR_DOMAIN_RUNNING and self.state == "start" and self.hypervisor == self.thishypervisor.name:
if not self.domuuid in self.thishypervisor.domain_list:
self.thishypervisor.domain_list.append(self.domuuid)
2018-06-11 18:41:32 -04:00
# VM is already running and should be but stuck in migrate state
elif running == libvirt.VIR_DOMAIN_RUNNING and self.state == "migrate" and self.hypervisor == self.thishypervisor.name:
self.zk.set('/domains/{}/state'.format(self.domuuid), 'start'.encode('ascii'))
if not self.domuuid in self.thishypervisor.domain_list:
self.thishypervisor.domain_list.append(self.domuuid)
2018-06-02 15:26:37 -04:00
# VM should be started
elif running != libvirt.VIR_DOMAIN_RUNNING and self.state == "start" and self.hypervisor == self.thishypervisor.name:
2018-05-31 20:26:44 -04:00
# Grab the domain information from Zookeeper
domxml, domxmlstat = self.zk.get('/domains/{}/xml'.format(self.domuuid))
2018-05-31 20:26:44 -04:00
domxml = str(domxml.decode('ascii'))
self.start_vm(domxml)
2018-06-06 22:59:31 -04:00
# This function is a wrapper for libvirt.lookupByUUID which fixes some problems
# 1. Takes a text UUID and handles converting it to bytes
# 2. Try's it and returns a sensible value if not
def lookupByUUID(self, tuuid):
conn = None
dom = None
libvirt_name = "qemu:///system"
2018-06-06 22:59:31 -04:00
# Convert the text UUID to bytes
buuid = uuid.UUID(tuuid).bytes
# Try
try:
# Open a libvirt connection
conn = libvirt.open(libvirt_name)
if conn == None:
ansiiprint.echo('Failed to open local libvirt connection', '{}:'.format(self.domuuid), 'e')
2018-06-06 22:59:31 -04:00
return dom
# Lookup the UUID
dom = conn.lookupByUUID(buuid)
# Fail
except:
pass
# After everything
finally:
# Close the libvirt connection
if conn != None:
conn.close()
# Return the dom object (or None)
return dom