def stop(self):
ret = super(xen_core, self).stop()
if ret:
return ret
# don't really want destroy here, needs to wait for it to end
(exit_code, _, _) = self.do_execute("%s shutdown %d -w" % (glob.config.get("paths", "xm"), self.real_id))
# ignore "Domain doesn't exist" error for shutdown
ret = xen_exit_codes.translate(exit_code, "shutdown")
if ret == errors.XEN_DOMAIN_DOESNT_EXIST:
return errors.throw(errors.ERR_SUCCESS)
return xen_exit_codes.translate(exit_code, "shutdown")
def __get_xentop_info(self):
try:
self.xentop_info
return errors.throw(errors.ERR_SUCCESS)
except AttributeError:
pass
(exit_code, stdout, _) = self.do_execute("xentop -b -i 1")
if exit_code != 0:
return xen_exit_codes.translate(exit_code)
# get this VPS' information
line = -1
split_info = None
for i in xrange(4, len(stdout)): # domain info starts on line 5
info = re.sub("[ ]+", " ", stdout[i].strip())
split_info = info.split(" ")
if split_info[0] == str(self.real_id):
line = i
break
# cache it locally
if line == -1:
self.xentop_info = -1
else:
self.xentop_info = split_info
return errors.throw(errors.ERR_SUCCESS)
def reboot(self):
ret = super(xen_core, self).reboot()
if ret:
return ret
(exit_code, _, _) = self.do_execute("%s reboot %d" % (glob.config.get("paths", "xm"), self.real_id))
return xen_exit_codes.translate(exit_code)
def poweroff(self):
ret = super(xen_core, self).poweroff()
if ret:
return ret
(exit_code, _, _) = self.do_execute("%s shutdown %d -w" % (glob.config.get("paths", "xm"), self.real_id))
# ignore "Domain doesn't exist" error for shutdown
ret = xen_exit_codes.translate(exit_code, "shutdown")
if ret == errors.XEN_DOMAIN_DOESNT_EXIST:
return errors.throw(errors.ERR_SUCCESS)
return ret
def destroy(self):
ret = super(xen_core, self).destroy()
if ret:
return ret
# don't really want destroy here, needs to wait for it to end
(exit_code, _, _) = self.do_execute("%s shutdown %d -w" % (glob.config.get("paths", "xm"), self.real_id))
if exit_code != 0 and exit_code != 1:
# ignore "Domain doesn't exist" error for shutdown
ret = xen_exit_codes.translate(exit_code, "shutdown")
if ret != errors.XEN_DOMAIN_DOESNT_EXIST:
return errors.throw(ret)
(exit_code, _, _) = self.do_execute(
"rm -rf %s" % os.path.join(glob.config.get("xen", "root_domain_dir"), str(self.real_id))
)
if exit_code != 0:
return errors.throw(errors.XEN_COULDNT_REMOVE)
return errors.throw(errors.ERR_SUCCESS)
def uptime(self):
ret = super(xen_core, self).uptime()
if ret:
return ret
# get uptime
(exit_code, stdout, _) = self.do_execute("%s uptime %d" % (glob.config.get("paths", "xm"), self.real_id))
if exit_code != 0:
return xen_exit_codes.translate(exit_code)
# parse uptime
uptime_split = re.sub("[ ]+", " ", stdout[1].strip()).split(" ")
uptime_split = uptime_split[2:]
uptime = " ".join(uptime_split)
# update db
(php_exit_code, _, _) = php.db_update(
"vps_stats", "update_attribute", str(self.server["server_id"]), str(self.vps_id), "uptime", str(uptime)
)
return php_exit_codes.translate(php_exit_code)
def start(self):
ret = super(xen_core, self).start()
if ret:
return ret
# see if it is started
(exit_code, stdout, _) = self.do_execute(
'%s list | /usr/bin/env grep -E "^%s "' % (glob.config.get("paths", "xm"), self.real_id)
)
# if it is, then nothing to do!
if len(stdout) != 0:
return errors.throw(errors.ERR_SUCCESS)
# get relevant paths
config_path = self.__get_config_path()
disk_img_path = self.__get_disk_img_path()
# grab total RAM being used by existing VMs
(exit_code, vms, _) = self.do_execute(
'%s -b -i 1 | /usr/bin/env grep -E "^ " | ' % glob.config.get("paths", "xentop")
+ '/usr/bin/env sed -r "s/[ ]+/ /g" | '
+ '/usr/bin/env grep -vE "^ NAME" | '
+ '/usr/bin/env grep -vE "^ Domain-0" | '
+ '/usr/bin/env grep -vE "^ %d " | ' % self.real_id
+ "/usr/bin/env cut -d ' ' -f8"
)
if exit_code != 0:
return errors.throw(errors.XEN_RAM_CHECK_FAIL)
# calculate total RAM
total_used_ram = 0
for vm in vms:
total_used_ram += int(vm)
# calculate free memory
(exit_code, total_ram, _) = self.do_execute(
"/usr/bin/env free | /usr/bin/env grep Mem | "
+ '/usr/bin/env sed -r "s/[ ]+/ /g" | '
+ "/usr/bin/env cut -d ' ' -f2"
)
# convert to integer
total_ram = int(total_ram[0])
if glob.config.get("xen", "use_swap") == "true":
# calculate free swap
(exit_code, total_swap, _) = self.do_execute(
"/usr/bin/env free | /usr/bin/env grep Swap | "
+ '/usr/bin/env sed -r "s/[ ]+/ /g" | '
+ "/usr/bin/env cut -d ' ' -f2"
)
# add to total
total_ram += int(total_swap[0])
# calculate memory to use
(exit_code, memory, _) = self.do_execute(
'grep -E "^memory" "%s" | ' % config_path + 'sed -r "s/^.*=[ ]*[\\"]?([0-9]+)[\\"]?[ ]*$/\\1/g"'
)
if exit_code != 0:
return errors.throw(errors.XEN_RAM_CHECK_FAIL)
# if RAM exceeds free, then fail
if total_used_ram + int(memory[0]) * 1024 > total_ram:
return errors.throw(errors.XEN_OUT_OF_RAM)
# sanity
exit_code = self.__umount_sanity(disk_img_path)
# something screwy happened to the server
if exit_code == 0:
return errors.throw(errors.XEN_SANITY_UMOUNT_FAIL)
# start the image
(exit_code, _, _) = self.do_execute('%s create "%s"' % (glob.config.get("paths", "xm"), config_path))
return xen_exit_codes.translate(exit_code, "create")
