X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/fdf7f055b2dc434c3401975612ec6f3e9e5a92b7..958d01f8f739093f752bff4af259f3e9bb7ff4c7:/lib/hypervisor/hv_xen.py diff --git a/lib/hypervisor/hv_xen.py b/lib/hypervisor/hv_xen.py index 6da7f1a..8d36e20 100644 --- a/lib/hypervisor/hv_xen.py +++ b/lib/hypervisor/hv_xen.py @@ -1,7 +1,7 @@ # # -# 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 @@ -23,9 +23,6 @@ """ -import os -import os.path -import time import logging from cStringIO import StringIO @@ -33,6 +30,8 @@ from ganeti import constants 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): @@ -42,15 +41,43 @@ 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. """ raise NotImplementedError @staticmethod + 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. @@ -58,7 +85,22 @@ class XenHypervisor(hv_base.BaseHypervisor): utils.RemoveFile("/etc/xen/%s" % instance_name) @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 @@ -67,21 +109,20 @@ class XenHypervisor(hv_base.BaseHypervisor): @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: @@ -96,7 +137,7 @@ class XenHypervisor(hv_base.BaseHypervisor): 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)) @@ -139,11 +180,11 @@ class XenHypervisor(hv_base.BaseHypervisor): xm_list = self._GetXMList(False) return xm_list - def StartInstance(self, instance, block_devices, extra_args): + def StartInstance(self, instance, block_devices): """Start an instance. """ - self._WriteConfigFile(instance, block_devices, extra_args) + self._WriteConfigFile(instance, block_devices) result = utils.RunCmd(["xm", "create", instance.name]) if result.failed: @@ -151,38 +192,67 @@ class XenHypervisor(hv_base.BaseHypervisor): (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 @@ -194,6 +264,7 @@ class XenHypervisor(hv_base.BaseHypervisor): xmoutput = result.stdout.splitlines() result = {} + cores_per_socket = threads_per_core = nr_cpus = None for line in xmoutput: splitfields = line.split(":", 1) @@ -205,20 +276,34 @@ class XenHypervisor(hv_base.BaseHypervisor): 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 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=["xm", "console", instance.name]) def Verify(self): """Verify the hypervisor. @@ -228,19 +313,20 @@ class XenHypervisor(hv_base.BaseHypervisor): """ 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 @@ -253,118 +339,166 @@ class XenHypervisor(hv_base.BaseHypervisor): 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 + 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 finalized + @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 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) - except EnvironmentError, err: - logger.Error("Failure while removing instance config file: %s" % - str(err)) - - -class XenPvmHypervisor(XenHypervisor): - """Xen PVM hypervisor interface""" - - PARAMETERS = [ - constants.HV_KERNEL_PATH, - constants.HV_INITRD_PATH, - ] + self._RemoveConfigFile(instance.name) + except EnvironmentError: + logging.exception("Failure while removing instance config file") @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 an absolute path") - - if hvparams[constants.HV_INITRD_PATH]: - if not os.path.isabs(hvparams[constants.HV_INITRD_PATH]): - raise errors.HypervisorError("The initrd path must 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.REQUIRED_CHECK, + constants.HV_KERNEL_ARGS: hv_base.NO_CHECK, + constants.HV_MIGRATION_PORT: hv_base.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, + } @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]) @@ -373,194 +507,152 @@ class XenPvmHypervisor(XenHypervisor): 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("root = '/dev/sda ro'\n") + config.write("disk = [%s]\n" % ",".join(disk_data)) + + 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)) + 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.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, + } @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]) 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) @@ -570,17 +662,14 @@ class XenHvmHypervisor(XenHypervisor): 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)) + 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