#
#
-# Copyright (C) 2006, 2007, 2008 Google Inc.
+# Copyright (C) 2006, 2007, 2008, 2009, 2010 Google Inc.
#
# 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
"""
-import os
-import os.path
-import time
import logging
from cStringIO import StringIO
from ganeti import errors
from ganeti import utils
from ganeti.hypervisor import hv_base
+from ganeti import netutils
+from ganeti import objects
class XenHypervisor(hv_base.BaseHypervisor):
all the functionality that is identical for both.
"""
+ CAN_MIGRATE = True
+ REBOOT_RETRY_COUNT = 60
+ REBOOT_RETRY_INTERVAL = 10
+
+ ANCILLARY_FILES = [
+ "/etc/xen/xend-config.sxp",
+ "/etc/xen/scripts/vif-bridge",
+ ]
@classmethod
- def _WriteConfigFile(cls, instance, block_devices, extra_args):
+ def _WriteConfigFile(cls, instance, block_devices):
"""Write the Xen config file for the instance.
"""
"""
utils.RemoveFile("/etc/xen/%s" % instance_name)
+ @classmethod
+ def _CreateConfigCpus(cls, cpu_mask):
+ """Create a CPU config string that's compatible with Xen's
+ configuration file.
+
+ """
+ # Convert the string CPU mask to a list of list of int's
+ cpu_list = utils.ParseMultiCpuMask(cpu_mask)
+
+ if len(cpu_list) == 1:
+ all_cpu_mapping = cpu_list[0]
+ if (len(all_cpu_mapping) == 1 and
+ all_cpu_mapping[0] == constants.CPU_PINNING_ALL_VAL):
+ # If CPU pinning has 1 entry that's "all", then remove the
+ # parameter from the config file
+ return None
+ else:
+ # If CPU pinning has one non-all entry, mapping all vCPUS (the entire
+ # VM) to one physical CPU, using format 'cpu = "C"'
+ return "cpu = \"%s\"" % ",".join(map(str, all_cpu_mapping))
+ else:
+ def _GetCPUMap(vcpu):
+ if vcpu[0] == constants.CPU_PINNING_ALL_VAL:
+ cpu_map = constants.CPU_PINNING_ALL_XEN
+ else:
+ cpu_map = ",".join(map(str, vcpu))
+ return "\"%s\"" % cpu_map
+
+ # build the result string in format 'cpus = [ "c", "c", "c" ]',
+ # where each c is a physical CPU number, a range, a list, or any
+ # combination
+ return "cpus = [ %s ]" % ", ".join(map(_GetCPUMap, cpu_list))
+
@staticmethod
- def _GetXMList(include_node):
+ def _RunXmList(xmlist_errors):
+ """Helper function for L{_GetXMList} to run "xm list".
+
+ """
+ result = utils.RunCmd(["xm", "list"])
+ if result.failed:
+ logging.error("xm list failed (%s): %s", result.fail_reason,
+ result.output)
+ xmlist_errors.append(result)
+ raise utils.RetryAgain()
+
+ # skip over the heading
+ return result.stdout.splitlines()[1:]
+
+ @classmethod
+ def _GetXMList(cls, include_node):
"""Return the list of running instances.
If the include_node argument is True, then we return information
@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
- logging.error("xm list failed (%s): %s", result.fail_reason,
- result.output)
- time.sleep(1)
+ xmlist_errors = []
+ try:
+ lines = utils.Retry(cls._RunXmList, 1, 5, args=(xmlist_errors, ))
+ except utils.RetryTimeout:
+ if xmlist_errors:
+ xmlist_result = xmlist_errors.pop()
- if result.failed:
- raise errors.HypervisorError("xm list failed, retries"
- " exceeded (%s): %s" %
- (result.fail_reason, result.stderr))
+ errmsg = ("xm list failed, timeout exceeded (%s): %s" %
+ (xmlist_result.fail_reason, xmlist_result.output))
+ else:
+ errmsg = "xm list failed"
+
+ raise errors.HypervisorError(errmsg)
- # skip over the heading
- lines = result.stdout.splitlines()[1:]
result = []
for line in lines:
# The format of lines is:
data[2] = int(data[2])
data[3] = int(data[3])
data[5] = float(data[5])
- except ValueError, err:
+ except (TypeError, ValueError), err:
raise errors.HypervisorError("Can't parse output of xm list,"
" line: %s, error: %s" % (line, err))
# skip the Domain-0 (optional)
- if include_node or data[0] != 'Domain-0':
+ if include_node or data[0] != "Domain-0":
result.append(data)
return result
@return: tuple (name, id, memory, vcpus, stat, times)
"""
- xm_list = self._GetXMList(instance_name=="Domain-0")
+ xm_list = self._GetXMList(instance_name == "Domain-0")
result = None
for data in xm_list:
if data[0] == instance_name:
xm_list = self._GetXMList(False)
return xm_list
- def StartInstance(self, instance, block_devices, extra_args):
+ def StartInstance(self, instance, block_devices, startup_paused):
"""Start an instance.
"""
- self._WriteConfigFile(instance, block_devices, extra_args)
- result = utils.RunCmd(["xm", "create", instance.name])
+ self._WriteConfigFile(instance, block_devices)
+ cmd = ["xm", "create"]
+ if startup_paused:
+ cmd.extend(["--paused"])
+ cmd.extend([instance.name])
+ result = utils.RunCmd(cmd)
if result.failed:
raise errors.HypervisorError("Failed to start instance %s: %s (%s)" %
(instance.name, result.fail_reason,
result.output))
- def StopInstance(self, instance, force=False):
+ def StopInstance(self, instance, force=False, retry=False, name=None):
"""Stop an instance.
"""
- self._RemoveConfigFile(instance.name)
+ if name is None:
+ name = instance.name
+ self._RemoveConfigFile(name)
if force:
- command = ["xm", "destroy", instance.name]
+ command = ["xm", "destroy", name]
else:
- command = ["xm", "shutdown", instance.name]
+ command = ["xm", "shutdown", name]
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" %
+ (name, result.fail_reason, result.output))
def RebootInstance(self, instance):
"""Reboot an instance.
"""
- result = utils.RunCmd(["xm", "reboot", instance.name])
+ ini_info = self.GetInstanceInfo(instance.name)
+ if ini_info is None:
+ raise errors.HypervisorError("Failed to reboot instance %s,"
+ " not running" % 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))
+
+ def _CheckInstance():
+ new_info = self.GetInstanceInfo(instance.name)
+
+ # check if the domain ID has changed or the run time has decreased
+ if (new_info is not None and
+ (new_info[1] != ini_info[1] or new_info[5] < ini_info[5])):
+ return
+
+ raise utils.RetryAgain()
+
+ try:
+ utils.Retry(_CheckInstance, self.REBOOT_RETRY_INTERVAL,
+ self.REBOOT_RETRY_INTERVAL * self.REBOOT_RETRY_COUNT)
+ except utils.RetryTimeout:
+ 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.
- @return: a dict with the following keys (values in MiB):
+ @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
xmoutput = result.stdout.splitlines()
result = {}
+ cores_per_socket = threads_per_core = nr_cpus = None
for line in xmoutput:
splitfields = line.split(":", 1)
if len(splitfields) > 1:
key = splitfields[0].strip()
val = splitfields[1].strip()
- if key == 'memory' or key == 'total_memory':
- result['memory_total'] = int(val)
- elif key == 'free_memory':
- result['memory_free'] = int(val)
- elif key == 'nr_cpus':
- result['cpu_total'] = int(val)
+ if key == "memory" or key == "total_memory":
+ result["memory_total"] = int(val)
+ elif key == "free_memory":
+ result["memory_free"] = int(val)
+ elif key == "nr_cpus":
+ 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]
+ result["memory_dom0"] = dom0_info[2]
return result
@classmethod
- def GetShellCommandForConsole(cls, instance):
+ def GetInstanceConsole(cls, instance, hvparams, beparams):
"""Return a command for connecting to the console of an instance.
"""
- return "xm console %s" % instance.name
-
+ return objects.InstanceConsole(instance=instance.name,
+ kind=constants.CONS_SSH,
+ host=instance.primary_node,
+ user=constants.GANETI_RUNAS,
+ command=[constants.XM_CONSOLE_WRAPPER,
+ 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):
+ def _GetConfigFileDiskData(block_devices, blockdev_prefix):
"""Get disk directive for xen config file.
This method builds the xen config disk directive according to the
given disk_template and block_devices.
- @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
+ @param blockdev_prefix: a string containing blockdevice prefix,
+ e.g. "sd" for /dev/sda
@return: string containing disk directive for xen instance config file
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)]
+ namespace = [blockdev_prefix + 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]],
- dev_path, sd_name)
+ line = "'%s:%s,%s,%s'" % (FILE_DRIVER_MAP[cfdev.physical_id[0]],
+ dev_path, sd_name, mode)
else:
- line = "'phy:%s,%s,w'" % (dev_path, sd_name)
+ line = "'phy:%s,%s,%s'" % (dev_path, sd_name, mode)
disk_data.append(line)
return disk_data
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
+ @param instance: instance whose migration is being finalized
@type info: string
@param info: content of the xen config file on the source node
@type success: boolean
The migration will not be attempted if the instance is not
currently running.
- @type instance: string
- @param instance: instance name
+ @type instance: L{objects.Instance}
+ @param instance: the instance to be migrated
@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:
+ if self.GetInstanceInfo(instance.name) is None:
raise errors.HypervisorError("Instance not running, cannot migrate")
- args = ["xm", "migrate"]
+
+ port = instance.hvparams[constants.HV_MIGRATION_PORT]
+
+ if not netutils.TcpPing(target, port, live_port_needed=True):
+ raise errors.HypervisorError("Remote host %s not listening on port"
+ " %s, cannot migrate" % (target, port))
+
+ args = ["xm", "migrate", "-p", "%d" % port]
if live:
args.append("-l")
- args.extend([instance, target])
+ args.extend([instance.name, target])
result = utils.RunCmd(args)
if result.failed:
raise errors.HypervisorError("Failed to migrate instance %s: %s" %
- (instance, result.output))
+ (instance.name, result.output))
# remove old xen file after migration succeeded
try:
- self._RemoveConfigFile(instance)
+ self._RemoveConfigFile(instance.name)
except EnvironmentError:
logging.exception("Failure while removing instance config file")
-
-class XenPvmHypervisor(XenHypervisor):
- """Xen PVM hypervisor interface"""
-
- PARAMETERS = [
- constants.HV_KERNEL_PATH,
- constants.HV_INITRD_PATH,
- constants.HV_ROOT_PATH,
- ]
-
@classmethod
- def CheckParameterSyntax(cls, hvparams):
- """Check the given parameters for validity.
-
- For the PVM hypervisor, this only check the existence of the
- kernel.
+ def PowercycleNode(cls):
+ """Xen-specific powercycle.
- @type hvparams: dict
- @param hvparams: dictionary with parameter names/value
- @raise errors.HypervisorError: when a parameter is not valid
+ 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.
"""
- super(XenPvmHypervisor, cls).CheckParameterSyntax(hvparams)
-
- if not hvparams[constants.HV_KERNEL_PATH]:
- raise errors.HypervisorError("Need a kernel for the instance")
-
- if not os.path.isabs(hvparams[constants.HV_KERNEL_PATH]):
- raise errors.HypervisorError("The kernel path must be an absolute path")
-
- if not hvparams[constants.HV_ROOT_PATH]:
- raise errors.HypervisorError("Need a root partition for the instance")
-
- if hvparams[constants.HV_INITRD_PATH]:
- if not os.path.isabs(hvparams[constants.HV_INITRD_PATH]):
- raise errors.HypervisorError("The initrd path must be an absolute path"
- ", if defined")
-
- def ValidateParameters(self, hvparams):
- """Check the given parameters for validity.
+ try:
+ cls.LinuxPowercycle()
+ finally:
+ utils.RunCmd(["xm", "debug", "R"])
- For the PVM hypervisor, this only check the existence of the
- kernel.
- """
- super(XenPvmHypervisor, self).ValidateParameters(hvparams)
+class XenPvmHypervisor(XenHypervisor):
+ """Xen PVM hypervisor interface"""
- kernel_path = hvparams[constants.HV_KERNEL_PATH]
- if not os.path.isfile(kernel_path):
- raise errors.HypervisorError("Instance kernel '%s' not found or"
- " not a file" % kernel_path)
- initrd_path = hvparams[constants.HV_INITRD_PATH]
- if initrd_path and not os.path.isfile(initrd_path):
- raise errors.HypervisorError("Instance initrd '%s' not found or"
- " not a file" % initrd_path)
+ PARAMETERS = {
+ constants.HV_USE_BOOTLOADER: hv_base.NO_CHECK,
+ constants.HV_BOOTLOADER_PATH: hv_base.OPT_FILE_CHECK,
+ constants.HV_BOOTLOADER_ARGS: hv_base.NO_CHECK,
+ constants.HV_KERNEL_PATH: hv_base.REQ_FILE_CHECK,
+ constants.HV_INITRD_PATH: hv_base.OPT_FILE_CHECK,
+ constants.HV_ROOT_PATH: hv_base.NO_CHECK,
+ constants.HV_KERNEL_ARGS: hv_base.NO_CHECK,
+ constants.HV_MIGRATION_PORT: hv_base.REQ_NET_PORT_CHECK,
+ constants.HV_MIGRATION_MODE: hv_base.MIGRATION_MODE_CHECK,
+ # TODO: Add a check for the blockdev prefix (matching [a-z:] or similar).
+ constants.HV_BLOCKDEV_PREFIX: hv_base.NO_CHECK,
+ constants.HV_REBOOT_BEHAVIOR:
+ hv_base.ParamInSet(True, constants.REBOOT_BEHAVIORS),
+ constants.HV_CPU_MASK: hv_base.OPT_MULTI_CPU_MASK_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
- kpath = instance.hvparams[constants.HV_KERNEL_PATH]
- config.write("kernel = '%s'\n" % kpath)
+ # if bootloader is True, use bootloader instead of kernel and ramdisk
+ # parameters.
+ if hvp[constants.HV_USE_BOOTLOADER]:
+ # bootloader handling
+ bootloader_path = hvp[constants.HV_BOOTLOADER_PATH]
+ if bootloader_path:
+ config.write("bootloader = '%s'\n" % bootloader_path)
+ else:
+ raise errors.HypervisorError("Bootloader enabled, but missing"
+ " bootloader path")
- # initrd handling
- initrd_path = instance.hvparams[constants.HV_INITRD_PATH]
- if initrd_path:
- config.write("ramdisk = '%s'\n" % initrd_path)
+ bootloader_args = hvp[constants.HV_BOOTLOADER_ARGS]
+ if bootloader_args:
+ config.write("bootargs = '%s'\n" % bootloader_args)
+ else:
+ # kernel handling
+ kpath = hvp[constants.HV_KERNEL_PATH]
+ config.write("kernel = '%s'\n" % kpath)
+
+ # initrd handling
+ 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.beparams[constants.BE_MEMORY])
config.write("vcpus = %d\n" % instance.beparams[constants.BE_VCPUS])
+ cpu_pinning = cls._CreateConfigCpus(hvp[constants.HV_CPU_MASK])
+ if cpu_pinning:
+ config.write("%s\n" % cpu_pinning)
+
config.write("name = '%s'\n" % instance.name)
vif_data = []
for nic in instance.nics:
- nic_str = "mac=%s, bridge=%s" % (nic.mac, nic.bridge)
+ nic_str = "mac=%s" % (nic.mac)
ip = getattr(nic, "ip", None)
if ip is not None:
nic_str += ", ip=%s" % ip
+ if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
+ nic_str += ", bridge=%s" % nic.nicparams[constants.NIC_LINK]
vif_data.append("'%s'" % nic_str)
+ disk_data = cls._GetConfigFileDiskData(block_devices,
+ hvp[constants.HV_BLOCKDEV_PREFIX])
+
config.write("vif = [%s]\n" % ",".join(vif_data))
- config.write("disk = [%s]\n" % ",".join(
- cls._GetConfigFileDiskData(instance.disk_template,
- block_devices)))
+ config.write("disk = [%s]\n" % ",".join(disk_data))
- rpath = instance.hvparams[constants.HV_ROOT_PATH]
- config.write("root = '%s ro'\n" % rpath)
+ if hvp[constants.HV_ROOT_PATH]:
+ config.write("root = '%s'\n" % hvp[constants.HV_ROOT_PATH])
config.write("on_poweroff = 'destroy'\n")
- config.write("on_reboot = 'restart'\n")
+ if hvp[constants.HV_REBOOT_BEHAVIOR] == constants.INSTANCE_REBOOT_ALLOWED:
+ config.write("on_reboot = 'restart'\n")
+ else:
+ config.write("on_reboot = 'destroy'\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))
+ 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 True
class XenHvmHypervisor(XenHypervisor):
"""Xen HVM hypervisor interface"""
- PARAMETERS = [
- constants.HV_ACPI,
- constants.HV_BOOT_ORDER,
- constants.HV_CDROM_IMAGE_PATH,
- constants.HV_DISK_TYPE,
- constants.HV_NIC_TYPE,
- constants.HV_PAE,
- constants.HV_VNC_BIND_ADDRESS,
+ ANCILLARY_FILES = XenHypervisor.ANCILLARY_FILES + [
+ constants.VNC_PASSWORD_FILE,
]
- @classmethod
- def CheckParameterSyntax(cls, hvparams):
- """Check the given parameter syntax.
-
- """
- super(XenHvmHypervisor, cls).CheckParameterSyntax(hvparams)
- # boot order verification
- boot_order = hvparams[constants.HV_BOOT_ORDER]
- if len(boot_order.strip("acdn")) != 0:
- raise errors.HypervisorError("Invalid boot order '%s' specified,"
- " must be one or more of [acdn]" %
- boot_order)
- # device type checks
- nic_type = hvparams[constants.HV_NIC_TYPE]
- if nic_type not in constants.HT_HVM_VALID_NIC_TYPES:
- raise errors.HypervisorError("Invalid NIC type %s specified for Xen HVM"
- " hypervisor" % nic_type)
- disk_type = hvparams[constants.HV_DISK_TYPE]
- if disk_type not in constants.HT_HVM_VALID_DISK_TYPES:
- raise errors.HypervisorError("Invalid disk type %s specified for Xen HVM"
- " hypervisor" % disk_type)
- # vnc_bind_address verification
- vnc_bind_address = hvparams[constants.HV_VNC_BIND_ADDRESS]
- if vnc_bind_address is not None:
- if not utils.IsValidIP(vnc_bind_address):
- raise errors.OpPrereqError("given VNC bind address '%s' doesn't look"
- " like a valid IP address" %
- vnc_bind_address)
-
- iso_path = hvparams[constants.HV_CDROM_IMAGE_PATH]
- if iso_path and not os.path.isabs(iso_path):
- raise errors.HypervisorError("The path to the HVM CDROM image must"
- " be an absolute path or None, not %s" %
- iso_path)
-
- def ValidateParameters(self, hvparams):
- """Check the given parameters for validity.
-
- For the PVM hypervisor, this only check the existence of the
- kernel.
-
- @type hvparams: dict
- @param hvparams: dictionary with parameter names/value
- @raise errors.HypervisorError: when a parameter is not valid
-
- """
- super(XenHvmHypervisor, self).ValidateParameters(hvparams)
-
- # hvm_cdrom_image_path verification
- iso_path = hvparams[constants.HV_CDROM_IMAGE_PATH]
- if iso_path and not os.path.isfile(iso_path):
- raise errors.HypervisorError("The HVM CDROM image must either be a"
- " regular file or a symlink pointing to"
- " an existing regular file, not %s" %
- iso_path)
+ 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, netutils.IP4Address.IsValid,
+ "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,
+ constants.HV_VNC_PASSWORD_FILE: hv_base.REQ_FILE_CHECK,
+ constants.HV_MIGRATION_PORT: hv_base.REQ_NET_PORT_CHECK,
+ constants.HV_MIGRATION_MODE: hv_base.MIGRATION_MODE_CHECK,
+ constants.HV_USE_LOCALTIME: hv_base.NO_CHECK,
+ # TODO: Add a check for the blockdev prefix (matching [a-z:] or similar).
+ constants.HV_BLOCKDEV_PREFIX: hv_base.NO_CHECK,
+ constants.HV_REBOOT_BEHAVIOR:
+ hv_base.ParamInSet(True, constants.REBOOT_BEHAVIORS),
+ constants.HV_CPU_MASK: hv_base.OPT_MULTI_CPU_MASK_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.beparams[constants.BE_MEMORY])
config.write("vcpus = %d\n" % instance.beparams[constants.BE_VCPUS])
+ cpu_pinning = cls._CreateConfigCpus(hvp[constants.HV_CPU_MASK])
+ if cpu_pinning:
+ config.write("%s\n" % cpu_pinning)
+
config.write("name = '%s'\n" % instance.name)
- if instance.hvparams[constants.HV_PAE]:
+ if hvp[constants.HV_PAE]:
config.write("pae = 1\n")
else:
config.write("pae = 0\n")
- if instance.hvparams[constants.HV_ACPI]:
+ if hvp[constants.HV_ACPI]:
config.write("acpi = 1\n")
else:
config.write("acpi = 0\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")
- else:
- config.write("device_model = '/usr/lib/xen/bin/qemu-dm'\n")
- if instance.hvparams[constants.HV_BOOT_ORDER] is None:
- config.write("boot = '%s'\n" % constants.HT_HVM_DEFAULT_BOOT_ORDER)
- else:
- config.write("boot = '%s'\n" % instance.hvparams["boot_order"])
+ 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("vnc = 1\n")
- if instance.hvparams[constants.HV_VNC_BIND_ADDRESS] is None:
+ 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" %
- instance.hvparams["vnc_bind_address"])
+ 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("# vncdisplay = 1\n")
config.write("vncunused = 1\n")
+ vnc_pwd_file = hvp[constants.HV_VNC_PASSWORD_FILE]
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(vnc_pwd_file)
+ except EnvironmentError, err:
+ raise errors.HypervisorError("Failed to open VNC password file %s: %s" %
+ (vnc_pwd_file, err))
config.write("vncpasswd = '%s'\n" % password.rstrip())
config.write("serial = 'pty'\n")
- config.write("localtime = 1\n")
+ if hvp[constants.HV_USE_LOCALTIME]:
+ config.write("localtime = 1\n")
vif_data = []
- nic_type = instance.hvparams[constants.HV_NIC_TYPE]
+ 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_HVM_DEV_PARAVIRTUAL:
+ 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%s" % (nic.mac, nic.bridge, nic_type_str)
+ nic_str = "mac=%s%s" % (nic.mac, nic_type_str)
ip = getattr(nic, "ip", None)
if ip is not None:
nic_str += ", ip=%s" % ip
+ if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
+ nic_str += ", bridge=%s" % nic.nicparams[constants.NIC_LINK]
vif_data.append("'%s'" % nic_str)
config.write("vif = [%s]\n" % ",".join(vif_data))
- disk_data = cls._GetConfigFileDiskData(instance.disk_template,
- block_devices)
- disk_type = instance.hvparams[constants.HV_DISK_TYPE]
- if disk_type in (None, constants.HT_HVM_DEV_IOEMU):
- replacement = ",ioemu:hd"
- else:
- replacement = ",hd"
- disk_data = [line.replace(",sd", replacement) for line in disk_data]
- iso_path = instance.hvparams[constants.HV_CDROM_IMAGE_PATH]
+
+ disk_data = cls._GetConfigFileDiskData(block_devices,
+ hvp[constants.HV_BLOCKDEV_PREFIX])
+
+ 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")
+ if hvp[constants.HV_REBOOT_BEHAVIOR] == constants.INSTANCE_REBOOT_ALLOWED:
+ config.write("on_reboot = 'restart'\n")
+ else:
+ config.write("on_reboot = 'destroy'\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))
+ 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 True