import os
import os.path
import time
+import logging
from cStringIO import StringIO
from ganeti import constants
from ganeti import errors
-from ganeti import logger
from ganeti import utils
from ganeti.hypervisor import hv_base
all the functionality that is identical for both.
"""
+ REBOOT_RETRY_COUNT = 60
+ REBOOT_RETRY_INTERVAL = 10
- @staticmethod
- def _WriteConfigFile(instance, block_devices, extra_args):
+ ANCILLARY_FILES = [
+ '/etc/xen/xend-config.sxp',
+ '/etc/xen/scripts/vif-bridge',
+ ]
+
+ @classmethod
+ def _WriteConfigFile(cls, instance, block_devices):
"""Write the Xen config file for the instance.
"""
raise NotImplementedError
@staticmethod
- def _RemoveConfigFile(instance):
+ def _WriteConfigFileStatic(instance_name, data):
+ """Write the Xen config file for the instance.
+
+ This version of the function just writes the config file from static data.
+
+ """
+ utils.WriteFile("/etc/xen/%s" % instance_name, data=data)
+
+ @staticmethod
+ def _ReadConfigFile(instance_name):
+ """Returns the contents of the instance config file.
+
+ """
+ try:
+ file_content = utils.ReadFile("/etc/xen/%s" % instance_name)
+ except EnvironmentError, err:
+ raise errors.HypervisorError("Failed to load Xen config file: %s" % err)
+ return file_content
+
+ @staticmethod
+ def _RemoveConfigFile(instance_name):
"""Remove the xen configuration file.
"""
- utils.RemoveFile("/etc/xen/%s" % instance.name)
+ utils.RemoveFile("/etc/xen/%s" % instance_name)
@staticmethod
def _GetXMList(include_node):
"""Return the list of running instances.
- If the `include_node` argument is True, then we return information
+ If the include_node argument is True, then we return information
for dom0 also, otherwise we filter that from the return value.
- The return value is a list of (name, id, memory, vcpus, state, time spent)
+ @return: list of (name, id, memory, vcpus, state, time spent)
"""
for dummy in range(5):
result = utils.RunCmd(["xm", "list"])
if not result.failed:
break
- logger.Error("xm list failed (%s): %s" % (result.fail_reason,
- result.output))
+ logging.error("xm list failed (%s): %s", result.fail_reason,
+ result.output)
time.sleep(1)
if result.failed:
raise errors.HypervisorError("xm list failed, retries"
" exceeded (%s): %s" %
- (result.fail_reason, result.stderr))
+ (result.fail_reason, result.output))
# skip over the heading
lines = result.stdout.splitlines()[1:]
def GetInstanceInfo(self, instance_name):
"""Get instance properties.
- Args:
- instance_name: the instance name
+ @param instance_name: the instance name
+
+ @return: tuple (name, id, memory, vcpus, stat, times)
- Returns:
- (name, id, memory, vcpus, stat, times)
"""
xm_list = self._GetXMList(instance_name=="Domain-0")
result = None
def GetAllInstancesInfo(self):
"""Get properties of all instances.
- Returns:
- [(name, id, memory, vcpus, stat, times),...]
+ @return: list of tuples (name, id, memory, vcpus, stat, times)
+
"""
xm_list = self._GetXMList(False)
return xm_list
- def StartInstance(self, instance, block_devices, extra_args):
- """Start an instance."""
- self._WriteConfigFile(instance, block_devices, extra_args)
+ def StartInstance(self, instance, block_devices):
+ """Start an instance.
+
+ """
+ self._WriteConfigFile(instance, block_devices)
result = utils.RunCmd(["xm", "create", instance.name])
if result.failed:
result.output))
def StopInstance(self, instance, force=False):
- """Stop an instance."""
- self._RemoveConfigFile(instance)
+ """Stop an instance.
+
+ """
+ self._RemoveConfigFile(instance.name)
if force:
command = ["xm", "destroy", instance.name]
else:
result = utils.RunCmd(command)
if result.failed:
- raise errors.HypervisorError("Failed to stop instance %s: %s" %
- (instance.name, result.fail_reason))
+ raise errors.HypervisorError("Failed to stop instance %s: %s, %s" %
+ (instance.name, result.fail_reason,
+ result.output))
def RebootInstance(self, instance):
- """Reboot an instance."""
+ """Reboot an instance.
+
+ """
+ ini_info = self.GetInstanceInfo(instance.name)
result = utils.RunCmd(["xm", "reboot", instance.name])
if result.failed:
- raise errors.HypervisorError("Failed to reboot instance %s: %s" %
- (instance.name, result.fail_reason))
+ raise errors.HypervisorError("Failed to reboot instance %s: %s, %s" %
+ (instance.name, result.fail_reason,
+ result.output))
+ done = False
+ retries = self.REBOOT_RETRY_COUNT
+ while retries > 0:
+ new_info = self.GetInstanceInfo(instance.name)
+ # check if the domain ID has changed or the run time has
+ # decreased
+ if new_info[1] != ini_info[1] or new_info[5] < ini_info[5]:
+ done = True
+ break
+ time.sleep(self.REBOOT_RETRY_INTERVAL)
+ retries -= 1
+
+ if not done:
+ raise errors.HypervisorError("Failed to reboot instance %s: instance"
+ " did not reboot in the expected interval" %
+ (instance.name, ))
def GetNodeInfo(self):
"""Return information about the node.
- The return value is a dict, which has to have the following items:
- (all values in MiB)
- - memory_total: the total memory size on the node
- - memory_free: the available memory on the node for instances
- - memory_dom0: the memory used by the node itself, if available
+ @return: a dict with the following keys (memory values in MiB):
+ - memory_total: the total memory size on the node
+ - memory_free: the available memory on the node for instances
+ - memory_dom0: the memory used by the node itself, if available
+ - nr_cpus: total number of CPUs
+ - nr_nodes: in a NUMA system, the number of domains
+ - nr_sockets: the number of physical CPU sockets in the node
"""
# note: in xen 3, memory has changed to total_memory
result = utils.RunCmd(["xm", "info"])
if result.failed:
- logger.Error("Can't run 'xm info': %s" % result.fail_reason)
+ logging.error("Can't run 'xm info' (%s): %s", result.fail_reason,
+ result.output)
return None
xmoutput = result.stdout.splitlines()
result = {}
+ cores_per_socket = threads_per_core = nr_cpus = None
for line in xmoutput:
splitfields = line.split(":", 1)
elif key == 'free_memory':
result['memory_free'] = int(val)
elif key == 'nr_cpus':
- result['cpu_total'] = int(val)
+ nr_cpus = result['cpu_total'] = int(val)
+ elif key == 'nr_nodes':
+ result['cpu_nodes'] = int(val)
+ elif key == 'cores_per_socket':
+ cores_per_socket = int(val)
+ elif key == 'threads_per_core':
+ threads_per_core = int(val)
+
+ if (cores_per_socket is not None and
+ threads_per_core is not None and nr_cpus is not None):
+ result['cpu_sockets'] = nr_cpus / (cores_per_socket * threads_per_core)
+
dom0_info = self.GetInstanceInfo("Domain-0")
if dom0_info is not None:
result['memory_dom0'] = dom0_info[2]
return result
- @staticmethod
- def GetShellCommandForConsole(instance):
+ @classmethod
+ def GetShellCommandForConsole(cls, instance, hvparams, beparams):
"""Return a command for connecting to the console of an instance.
"""
- raise NotImplementedError
+ return "xm console %s" % instance.name
+
def Verify(self):
"""Verify the hypervisor.
"""
result = utils.RunCmd(["xm", "info"])
if result.failed:
- return "'xm info' failed: %s" % result.fail_reason
+ return "'xm info' failed: %s, %s" % (result.fail_reason, result.output)
@staticmethod
def _GetConfigFileDiskData(disk_template, block_devices):
This method builds the xen config disk directive according to the
given disk_template and block_devices.
- Args:
- disk_template: String containing instance disk template
- block_devices: List[tuple1,tuple2,...]
- tuple: (cfdev, rldev)
- cfdev: dict containing ganeti config disk part
- rldev: ganeti.bdev.BlockDev object
+ @param disk_template: string containing instance disk template
+ @param block_devices: list of tuples (cfdev, rldev):
+ - cfdev: dict containing ganeti config disk part
+ - rldev: ganeti.bdev.BlockDev object
- Returns:
- String containing disk directive for xen instance config file
+ @return: string containing disk directive for xen instance config file
"""
FILE_DRIVER_MAP = {
constants.FD_BLKTAP: "tap:aio",
}
disk_data = []
- for cfdev, rldev in block_devices:
+ if len(block_devices) > 24:
+ # 'z' - 'a' = 24
+ raise errors.HypervisorError("Too many disks")
+ # FIXME: instead of this hardcoding here, each of PVM/HVM should
+ # directly export their info (currently HVM will just sed this info)
+ namespace = ["sd" + chr(i + ord('a')) for i in range(24)]
+ for sd_name, (cfdev, dev_path) in zip(namespace, block_devices):
+ if cfdev.mode == constants.DISK_RDWR:
+ mode = "w"
+ else:
+ mode = "r"
if cfdev.dev_type == constants.LD_FILE:
- line = "'%s:%s,%s,w'" % (FILE_DRIVER_MAP[cfdev.physical_id[0]],
- rldev.dev_path, cfdev.iv_name)
+ line = "'%s:%s,%s,%s'" % (FILE_DRIVER_MAP[cfdev.physical_id[0]],
+ dev_path, sd_name, mode)
else:
- line = "'phy:%s,%s,w'" % (rldev.dev_path, cfdev.iv_name)
+ line = "'phy:%s,%s,%s'" % (dev_path, sd_name, mode)
disk_data.append(line)
return disk_data
+ def MigrationInfo(self, instance):
+ """Get instance information to perform a migration.
+
+ @type instance: L{objects.Instance}
+ @param instance: instance to be migrated
+ @rtype: string
+ @return: content of the xen config file
+
+ """
+ return self._ReadConfigFile(instance.name)
+
+ def AcceptInstance(self, instance, info, target):
+ """Prepare to accept an instance.
+
+ @type instance: L{objects.Instance}
+ @param instance: instance to be accepted
+ @type info: string
+ @param info: content of the xen config file on the source node
+ @type target: string
+ @param target: target host (usually ip), on this node
+
+ """
+ pass
+
+ def FinalizeMigration(self, instance, info, success):
+ """Finalize an instance migration.
+
+ After a successful migration we write the xen config file.
+ We do nothing on a failure, as we did not change anything at accept time.
+
+ @type instance: L{objects.Instance}
+ @param instance: instance whose migration is being aborted
+ @type info: string
+ @param info: content of the xen config file on the source node
+ @type success: boolean
+ @param success: whether the migration was a success or a failure
+
+ """
+ if success:
+ self._WriteConfigFileStatic(instance.name, info)
+
+ def MigrateInstance(self, instance, target, live):
+ """Migrate an instance to a target node.
+
+ The migration will not be attempted if the instance is not
+ currently running.
+
+ @type instance: string
+ @param instance: instance name
+ @type target: string
+ @param target: ip address of the target node
+ @type live: boolean
+ @param live: perform a live migration
+
+ """
+ if self.GetInstanceInfo(instance) is None:
+ raise errors.HypervisorError("Instance not running, cannot migrate")
+ args = ["xm", "migrate"]
+ if live:
+ args.append("-l")
+ args.extend([instance, target])
+ result = utils.RunCmd(args)
+ if result.failed:
+ raise errors.HypervisorError("Failed to migrate instance %s: %s" %
+ (instance, result.output))
+ # remove old xen file after migration succeeded
+ try:
+ self._RemoveConfigFile(instance)
+ except EnvironmentError:
+ logging.exception("Failure while removing instance config file")
+
+ @classmethod
+ def PowercycleNode(cls):
+ """Xen-specific powercycle.
+
+ This first does a Linux reboot (which triggers automatically a Xen
+ reboot), and if that fails it tries to do a Xen reboot. The reason
+ we don't try a Xen reboot first is that the xen reboot launches an
+ external command which connects to the Xen hypervisor, and that
+ won't work in case the root filesystem is broken and/or the xend
+ daemon is not working.
+
+ """
+ try:
+ cls.LinuxPowercycle()
+ finally:
+ utils.RunCmd(["xm", "debug", "R"])
+
class XenPvmHypervisor(XenHypervisor):
"""Xen PVM hypervisor interface"""
+ PARAMETERS = {
+ constants.HV_KERNEL_PATH: hv_base.REQ_FILE_CHECK,
+ constants.HV_INITRD_PATH: hv_base.OPT_FILE_CHECK,
+ constants.HV_ROOT_PATH: hv_base.REQUIRED_CHECK,
+ constants.HV_KERNEL_ARGS: hv_base.NO_CHECK,
+ }
+
@classmethod
- def _WriteConfigFile(cls, instance, block_devices, extra_args):
+ def _WriteConfigFile(cls, instance, block_devices):
"""Write the Xen config file for the instance.
"""
+ hvp = instance.hvparams
config = StringIO()
config.write("# this is autogenerated by Ganeti, please do not edit\n#\n")
# kernel handling
- if instance.kernel_path in (None, constants.VALUE_DEFAULT):
- kpath = constants.XEN_KERNEL
- else:
- if not os.path.exists(instance.kernel_path):
- raise errors.HypervisorError("The kernel %s for instance %s is"
- " missing" % (instance.kernel_path,
- instance.name))
- kpath = instance.kernel_path
+ kpath = hvp[constants.HV_KERNEL_PATH]
config.write("kernel = '%s'\n" % kpath)
# initrd handling
- if instance.initrd_path in (None, constants.VALUE_DEFAULT):
- if os.path.exists(constants.XEN_INITRD):
- initrd_path = constants.XEN_INITRD
- else:
- initrd_path = None
- elif instance.initrd_path == constants.VALUE_NONE:
- initrd_path = None
- else:
- if not os.path.exists(instance.initrd_path):
- raise errors.HypervisorError("The initrd %s for instance %s is"
- " missing" % (instance.initrd_path,
- instance.name))
- initrd_path = instance.initrd_path
-
+ initrd_path = hvp[constants.HV_INITRD_PATH]
if initrd_path:
config.write("ramdisk = '%s'\n" % initrd_path)
# rest of the settings
- config.write("memory = %d\n" % instance.memory)
- config.write("vcpus = %d\n" % instance.vcpus)
+ config.write("memory = %d\n" % instance.beparams[constants.BE_MEMORY])
+ config.write("vcpus = %d\n" % instance.beparams[constants.BE_VCPUS])
config.write("name = '%s'\n" % instance.name)
vif_data = []
config.write("disk = [%s]\n" % ",".join(
cls._GetConfigFileDiskData(instance.disk_template,
block_devices)))
- config.write("root = '/dev/sda ro'\n")
+
+ config.write("root = '%s'\n" % hvp[constants.HV_ROOT_PATH])
config.write("on_poweroff = 'destroy'\n")
config.write("on_reboot = 'restart'\n")
config.write("on_crash = 'restart'\n")
- if extra_args:
- config.write("extra = '%s'\n" % extra_args)
+ config.write("extra = '%s'\n" % hvp[constants.HV_KERNEL_ARGS])
# just in case it exists
utils.RemoveFile("/etc/xen/auto/%s" % instance.name)
try:
- f = open("/etc/xen/%s" % instance.name, "w")
- try:
- f.write(config.getvalue())
- finally:
- f.close()
- except IOError, err:
- raise errors.OpExecError("Cannot write Xen instance confile"
- " file /etc/xen/%s: %s" % (instance.name, err))
- return True
-
- @staticmethod
- def GetShellCommandForConsole(instance):
- """Return a command for connecting to the console of an instance.
+ utils.WriteFile("/etc/xen/%s" % instance.name, data=config.getvalue())
+ except EnvironmentError, err:
+ raise errors.HypervisorError("Cannot write Xen instance confile"
+ " file /etc/xen/%s: %s" %
+ (instance.name, err))
- """
- return "xm console %s" % instance.name
+ return True
class XenHvmHypervisor(XenHypervisor):
"""Xen HVM hypervisor interface"""
+ ANCILLARY_FILES = XenHypervisor.ANCILLARY_FILES + \
+ [constants.VNC_PASSWORD_FILE]
+
+ PARAMETERS = {
+ constants.HV_ACPI: hv_base.NO_CHECK,
+ constants.HV_BOOT_ORDER: (True, ) + \
+ (lambda x: x and len(x.strip("acdn")) == 0,
+ "Invalid boot order specified, must be one or more of [acdn]",
+ None, None),
+ constants.HV_CDROM_IMAGE_PATH: hv_base.OPT_FILE_CHECK,
+ constants.HV_DISK_TYPE: \
+ hv_base.ParamInSet(True, constants.HT_HVM_VALID_DISK_TYPES),
+ constants.HV_NIC_TYPE: \
+ hv_base.ParamInSet(True, constants.HT_HVM_VALID_NIC_TYPES),
+ constants.HV_PAE: hv_base.NO_CHECK,
+ constants.HV_VNC_BIND_ADDRESS: \
+ (False, utils.IsValidIP,
+ "VNC bind address is not a valid IP address", None, None),
+ constants.HV_KERNEL_PATH: hv_base.REQ_FILE_CHECK,
+ constants.HV_DEVICE_MODEL: hv_base.REQ_FILE_CHECK,
+ }
+
@classmethod
- def _WriteConfigFile(cls, instance, block_devices, extra_args):
+ def _WriteConfigFile(cls, instance, block_devices):
"""Create a Xen 3.1 HVM config file.
"""
+ hvp = instance.hvparams
+
config = StringIO()
config.write("# this is autogenerated by Ganeti, please do not edit\n#\n")
- config.write("kernel = '/usr/lib/xen/boot/hvmloader'\n")
+
+ # kernel handling
+ kpath = hvp[constants.HV_KERNEL_PATH]
+ config.write("kernel = '%s'\n" % kpath)
+
config.write("builder = 'hvm'\n")
- config.write("memory = %d\n" % instance.memory)
- config.write("vcpus = %d\n" % instance.vcpus)
+ config.write("memory = %d\n" % instance.beparams[constants.BE_MEMORY])
+ config.write("vcpus = %d\n" % instance.beparams[constants.BE_VCPUS])
config.write("name = '%s'\n" % instance.name)
- config.write("pae = 1\n")
- config.write("acpi = 1\n")
- config.write("apic = 1\n")
- arch = os.uname()[4]
- if '64' in arch:
- config.write("device_model = '/usr/lib64/xen/bin/qemu-dm'\n")
+ if hvp[constants.HV_PAE]:
+ config.write("pae = 1\n")
else:
- config.write("device_model = '/usr/lib/xen/bin/qemu-dm'\n")
- if instance.hvm_boot_order is None:
- config.write("boot = '%s'\n" % constants.HT_HVM_DEFAULT_BOOT_ORDER)
+ config.write("pae = 0\n")
+ if hvp[constants.HV_ACPI]:
+ config.write("acpi = 1\n")
else:
- config.write("boot = '%s'\n" % instance.hvm_boot_order)
+ config.write("acpi = 0\n")
+ config.write("apic = 1\n")
+ config.write("device_model = '%s'\n" % hvp[constants.HV_DEVICE_MODEL])
+ config.write("boot = '%s'\n" % hvp[constants.HV_BOOT_ORDER])
config.write("sdl = 0\n")
- config.write("usb = 1\n");
- config.write("usbdevice = 'tablet'\n");
+ config.write("usb = 1\n")
+ config.write("usbdevice = 'tablet'\n")
config.write("vnc = 1\n")
- config.write("vnclisten = '0.0.0.0'\n")
+ if hvp[constants.HV_VNC_BIND_ADDRESS] is None:
+ config.write("vnclisten = '%s'\n" % constants.VNC_DEFAULT_BIND_ADDRESS)
+ else:
+ config.write("vnclisten = '%s'\n" % hvp[constants.HV_VNC_BIND_ADDRESS])
- if instance.network_port > constants.HT_HVM_VNC_BASE_PORT:
- display = instance.network_port - constants.HT_HVM_VNC_BASE_PORT
+ if instance.network_port > constants.VNC_BASE_PORT:
+ display = instance.network_port - constants.VNC_BASE_PORT
config.write("vncdisplay = %s\n" % display)
config.write("vncunused = 0\n")
else:
config.write("vncunused = 1\n")
try:
- password_file = open(constants.VNC_PASSWORD_FILE, "r")
- try:
- password = password_file.readline()
- finally:
- password_file.close()
- except IOError:
- raise errors.OpExecError("failed to open VNC password file %s " %
- constants.VNC_PASSWORD_FILE)
+ password = utils.ReadFile(constants.VNC_PASSWORD_FILE)
+ except EnvironmentError, err:
+ raise errors.HypervisorError("Failed to open VNC password file %s: %s" %
+ (constants.VNC_PASSWORD_FILE, err))
config.write("vncpasswd = '%s'\n" % password.rstrip())
config.write("localtime = 1\n")
vif_data = []
+ nic_type = hvp[constants.HV_NIC_TYPE]
+ if nic_type is None:
+ # ensure old instances don't change
+ nic_type_str = ", type=ioemu"
+ elif nic_type == constants.HT_NIC_PARAVIRTUAL:
+ nic_type_str = ", type=paravirtualized"
+ else:
+ nic_type_str = ", model=%s, type=ioemu" % nic_type
for nic in instance.nics:
- nic_str = "mac=%s, bridge=%s, type=ioemu" % (nic.mac, nic.bridge)
+ nic_str = "mac=%s, bridge=%s%s" % (nic.mac, nic.bridge, nic_type_str)
ip = getattr(nic, "ip", None)
if ip is not None:
nic_str += ", ip=%s" % ip
vif_data.append("'%s'" % nic_str)
config.write("vif = [%s]\n" % ",".join(vif_data))
- iso = "'file:/srv/ganeti/iso/hvm-install.iso,hdc:cdrom,r'"
- config.write("disk = [%s, %s]\n" % (",".join(
- cls._GetConfigFileDiskData(instance.disk_template,
- block_devices)), iso))
+ disk_data = cls._GetConfigFileDiskData(instance.disk_template,
+ block_devices)
+ disk_type = hvp[constants.HV_DISK_TYPE]
+ if disk_type in (None, constants.HT_DISK_IOEMU):
+ replacement = ",ioemu:hd"
+ else:
+ replacement = ",hd"
+ disk_data = [line.replace(",sd", replacement) for line in disk_data]
+ iso_path = hvp[constants.HV_CDROM_IMAGE_PATH]
+ if iso_path:
+ iso = "'file:%s,hdc:cdrom,r'" % iso_path
+ disk_data.append(iso)
+
+ config.write("disk = [%s]\n" % (",".join(disk_data)))
+
config.write("on_poweroff = 'destroy'\n")
config.write("on_reboot = 'restart'\n")
config.write("on_crash = 'restart'\n")
- if extra_args:
- config.write("extra = '%s'\n" % extra_args)
# just in case it exists
utils.RemoveFile("/etc/xen/auto/%s" % instance.name)
try:
- f = open("/etc/xen/%s" % instance.name, "w")
- try:
- f.write(config.getvalue())
- finally:
- f.close()
- except IOError, err:
- raise errors.OpExecError("Cannot write Xen instance confile"
- " file /etc/xen/%s: %s" % (instance.name, err))
- return True
+ utils.WriteFile("/etc/xen/%s" % instance.name,
+ data=config.getvalue())
+ except EnvironmentError, err:
+ raise errors.HypervisorError("Cannot write Xen instance confile"
+ " file /etc/xen/%s: %s" %
+ (instance.name, err))
- @staticmethod
- def GetShellCommandForConsole(instance):
- """Return a command for connecting to the console of an instance.
-
- """
- if instance.network_port is None:
- raise errors.OpExecError("no console port defined for %s"
- % instance.name)
- else:
- raise errors.OpExecError("no PTY console, connect to %s:%s via VNC"
- % (instance.primary_node,
- instance.network_port))
+ return True