"""
import logging
+import errno
import string # pylint: disable=W0402
+import shutil
from cStringIO import StringIO
from ganeti import constants
from ganeti import netutils
from ganeti import objects
from ganeti import pathutils
-from ganeti import ssconf
XEND_CONFIG_FILE = utils.PathJoin(pathutils.XEN_CONFIG_DIR, "xend-config.sxp")
return "cpus = [ %s ]" % ", ".join(map(_GetCPUMap, cpu_list))
-def _RunXmList(fn, xmllist_errors):
- """Helper function for L{_GetXmList} to run "xm list".
+def _RunInstanceList(fn, instance_list_errors):
+ """Helper function for L{_GetInstanceList} to retrieve the list of instances
+ from xen.
@type fn: callable
- @param fn: Function returning result of running C{xm list}
- @type xmllist_errors: list
- @param xmllist_errors: Error list
+ @param fn: Function to query xen for the list of instances
+ @type instance_list_errors: list
+ @param instance_list_errors: Error list
@rtype: list
"""
result = fn()
if result.failed:
- logging.error("xm list failed (%s): %s", result.fail_reason,
- result.output)
- xmllist_errors.append(result)
+ logging.error("Retrieving the instance list from xen failed (%s): %s",
+ result.fail_reason, result.output)
+ instance_list_errors.append(result)
raise utils.RetryAgain()
# skip over the heading
return result.stdout.splitlines()
-def _ParseXmList(lines, include_node):
- """Parses the output of C{xm list}.
+def _ParseInstanceList(lines, include_node):
+ """Parses the output of listing instances by xen.
@type lines: list
- @param lines: Output lines of C{xm list}
+ @param lines: Result of retrieving the instance list from xen
@type include_node: boolean
@param include_node: If True, return information for Dom0
@return: list of tuple containing (name, id, memory, vcpus, state, time
# Domain-0 0 3418 4 r----- 266.2
data = line.split()
if len(data) != 6:
- raise errors.HypervisorError("Can't parse output of xm list,"
+ raise errors.HypervisorError("Can't parse instance list,"
" line: %s" % line)
try:
data[1] = int(data[1])
data[3] = int(data[3])
data[5] = float(data[5])
except (TypeError, ValueError), err:
- raise errors.HypervisorError("Can't parse output of xm list,"
+ raise errors.HypervisorError("Can't parse instance list,"
" line: %s, error: %s" % (line, err))
# skip the Domain-0 (optional)
return result
-def _GetXmList(fn, include_node, _timeout=5):
+def _GetInstanceList(fn, include_node, _timeout=5):
"""Return the list of running instances.
- See L{_RunXmList} and L{_ParseXmList} for parameter details.
+ See L{_RunInstanceList} and L{_ParseInstanceList} for parameter details.
"""
- xmllist_errors = []
+ instance_list_errors = []
try:
- lines = utils.Retry(_RunXmList, (0.3, 1.5, 1.0), _timeout,
- args=(fn, xmllist_errors))
+ lines = utils.Retry(_RunInstanceList, (0.3, 1.5, 1.0), _timeout,
+ args=(fn, instance_list_errors))
except utils.RetryTimeout:
- if xmllist_errors:
- xmlist_result = xmllist_errors.pop()
+ if instance_list_errors:
+ instance_list_result = instance_list_errors.pop()
- errmsg = ("xm list failed, timeout exceeded (%s): %s" %
- (xmlist_result.fail_reason, xmlist_result.output))
+ errmsg = ("listing instances failed, timeout exceeded (%s): %s" %
+ (instance_list_result.fail_reason, instance_list_result.output))
else:
- errmsg = "xm list failed"
+ errmsg = "listing instances failed"
raise errors.HypervisorError(errmsg)
- return _ParseXmList(lines, include_node)
+ return _ParseInstanceList(lines, include_node)
+
+
+def _IsInstanceRunning(instance_info):
+ return instance_info == "r-----" \
+ or instance_info == "-b----"
+
+
+def _IsInstanceShutdown(instance_info):
+ return instance_info == "---s--"
def _ParseNodeInfo(info):
return result
-def _MergeInstanceInfo(info, fn):
+def _MergeInstanceInfo(info, instance_list):
"""Updates node information from L{_ParseNodeInfo} with instance info.
@type info: dict
@param info: Result from L{_ParseNodeInfo}
- @type fn: callable
- @param fn: Function returning result of running C{xm list}
+ @type instance_list: list of tuples
+ @param instance_list: list of instance information; one tuple per instance
@rtype: dict
"""
total_instmem = 0
- for (name, _, mem, vcpus, _, _) in fn(True):
+ for (name, _, mem, vcpus, _, _) in instance_list:
if name == _DOM0_NAME:
info["memory_dom0"] = mem
- info["dom0_cpus"] = vcpus
+ info["cpu_dom0"] = vcpus
# Include Dom0 in total memory usage
total_instmem += mem
return info
-def _GetNodeInfo(info, fn):
+def _GetNodeInfo(info, instance_list):
"""Combines L{_MergeInstanceInfo} and L{_ParseNodeInfo}.
+ @type instance_list: list of tuples
+ @param instance_list: list of instance information; one tuple per instance
+
"""
- return _MergeInstanceInfo(_ParseNodeInfo(info), fn)
+ return _MergeInstanceInfo(_ParseNodeInfo(info), instance_list)
def _GetConfigFileDiskData(block_devices, blockdev_prefix,
@param block_devices: list of tuples (cfdev, rldev):
- cfdev: dict containing ganeti config disk part
- - rldev: ganeti.bdev.BlockDev object
+ - rldev: ganeti.block.bdev.BlockDev object
@param blockdev_prefix: a string containing blockdevice prefix,
e.g. "sd" for /dev/sda
disk_data = []
- for sd_suffix, (cfdev, dev_path) in zip(_letters, block_devices):
+ for sd_suffix, (cfdev, dev_path, _) in zip(_letters, block_devices):
sd_name = blockdev_prefix + sd_suffix
if cfdev.mode == constants.DISK_RDWR:
else:
mode = "r"
- if cfdev.dev_type == constants.LD_FILE:
- driver = _FILE_DRIVER_MAP[cfdev.physical_id[0]]
+ if cfdev.dev_type in [constants.DT_FILE, constants.DT_SHARED_FILE]:
+ driver = _FILE_DRIVER_MAP[cfdev.logical_id[0]]
else:
driver = "phy"
return disk_data
+def _QuoteCpuidField(data):
+ """Add quotes around the CPUID field only if necessary.
+
+ Xen CPUID fields come in two shapes: LIBXL strings, which need quotes around
+ them, and lists of XEND strings, which don't.
+
+ @param data: Either type of parameter.
+ @return: The quoted version thereof.
+
+ """
+ return "'%s'" % data if data.startswith("host") else data
+
+
class XenHypervisor(hv_base.BaseHypervisor):
"""Xen generic hypervisor interface
CAN_MIGRATE = True
REBOOT_RETRY_COUNT = 60
REBOOT_RETRY_INTERVAL = 10
+ _ROOT_DIR = pathutils.RUN_DIR + "/xen-hypervisor"
+ _NICS_DIR = _ROOT_DIR + "/nic" # contains NICs' info
+ _DIRS = [_ROOT_DIR, _NICS_DIR]
ANCILLARY_FILES = [
XEND_CONFIG_FILE,
XL_CONFIG_FILE,
]
+ def __init__(self, _cfgdir=None, _run_cmd_fn=None, _cmd=None):
+ hv_base.BaseHypervisor.__init__(self)
+
+ if _cfgdir is None:
+ self._cfgdir = pathutils.XEN_CONFIG_DIR
+ else:
+ self._cfgdir = _cfgdir
+
+ if _run_cmd_fn is None:
+ self._run_cmd_fn = utils.RunCmd
+ else:
+ self._run_cmd_fn = _run_cmd_fn
+
+ self._cmd = _cmd
+
@staticmethod
- def _ConfigFileName(instance_name):
+ def _GetCommandFromHvparams(hvparams):
+ """Returns the Xen command extracted from the given hvparams.
+
+ @type hvparams: dict of strings
+ @param hvparams: hypervisor parameters
+
+ """
+ if hvparams is None or constants.HV_XEN_CMD not in hvparams:
+ raise errors.HypervisorError("Cannot determine xen command.")
+ else:
+ return hvparams[constants.HV_XEN_CMD]
+
+ def _GetCommand(self, hvparams):
+ """Returns Xen command to use.
+
+ @type hvparams: dict of strings
+ @param hvparams: hypervisor parameters
+
+ """
+ if self._cmd is None:
+ cmd = XenHypervisor._GetCommandFromHvparams(hvparams)
+ else:
+ cmd = self._cmd
+
+ if cmd not in constants.KNOWN_XEN_COMMANDS:
+ raise errors.ProgrammerError("Unknown Xen command '%s'" % cmd)
+
+ return cmd
+
+ def _RunXen(self, args, hvparams):
+ """Wrapper around L{utils.process.RunCmd} to run Xen command.
+
+ @type hvparams: dict of strings
+ @param hvparams: dictionary of hypervisor params
+ @see: L{utils.process.RunCmd}
+
+ """
+ cmd = [self._GetCommand(hvparams)]
+ cmd.extend(args)
+
+ return self._run_cmd_fn(cmd)
+
+ def _ConfigFileName(self, instance_name):
"""Get the config file name for an instance.
@param instance_name: instance name
@rtype: str
"""
- return utils.PathJoin(pathutils.XEN_CONFIG_DIR, instance_name)
+ return utils.PathJoin(self._cfgdir, instance_name)
@classmethod
- def _WriteConfigFile(cls, instance, startup_memory, block_devices):
+ def _WriteNICInfoFile(cls, instance, idx, nic):
"""Write the Xen config file for the instance.
+ This version of the function just writes the config file from static data.
+
+ """
+ instance_name = instance.name
+ dirs = [(dname, constants.RUN_DIRS_MODE)
+ for dname in cls._DIRS + [cls._InstanceNICDir(instance_name)]]
+ utils.EnsureDirs(dirs)
+
+ cfg_file = cls._InstanceNICFile(instance_name, idx)
+ data = StringIO()
+
+ data.write("TAGS=%s\n" % "\ ".join(instance.GetTags()))
+ if nic.netinfo:
+ netinfo = objects.Network.FromDict(nic.netinfo)
+ for k, v in netinfo.HooksDict().iteritems():
+ data.write("%s=%s\n" % (k, v))
+
+ data.write("MAC=%s\n" % nic.mac)
+ if nic.ip:
+ data.write("IP=%s\n" % nic.ip)
+ data.write("INTERFACE_INDEX=%s\n" % str(idx))
+ if nic.name:
+ data.write("INTERFACE_NAME=%s\n" % nic.name)
+ data.write("INTERFACE_UUID=%s\n" % nic.uuid)
+ data.write("MODE=%s\n" % nic.nicparams[constants.NIC_MODE])
+ data.write("LINK=%s\n" % nic.nicparams[constants.NIC_LINK])
+
+ try:
+ utils.WriteFile(cfg_file, data=data.getvalue())
+ except EnvironmentError, err:
+ raise errors.HypervisorError("Cannot write Xen instance configuration"
+ " file %s: %s" % (cfg_file, err))
+
+ @classmethod
+ def _InstanceNICDir(cls, instance_name):
+ """Returns the directory holding the tap device files for a given instance.
+
+ """
+ return utils.PathJoin(cls._NICS_DIR, instance_name)
+
+ @classmethod
+ def _InstanceNICFile(cls, instance_name, seq):
+ """Returns the name of the file containing the tap device for a given NIC
+
+ """
+ return utils.PathJoin(cls._InstanceNICDir(instance_name), str(seq))
+
+ @classmethod
+ def _GetConfig(cls, instance, startup_memory, block_devices):
+ """Build Xen configuration for an instance.
+
"""
raise NotImplementedError
- @staticmethod
- def _WriteConfigFileStatic(instance_name, data):
+ def _WriteConfigFile(self, instance_name, data):
"""Write the Xen config file for the instance.
This version of the function just writes the config file from static data.
"""
# just in case it exists
- utils.RemoveFile(utils.PathJoin(pathutils.XEN_CONFIG_DIR, "auto",
- instance_name))
+ utils.RemoveFile(utils.PathJoin(self._cfgdir, "auto", instance_name))
- cfg_file = XenHypervisor._ConfigFileName(instance_name)
+ cfg_file = self._ConfigFileName(instance_name)
try:
utils.WriteFile(cfg_file, data=data)
except EnvironmentError, err:
raise errors.HypervisorError("Cannot write Xen instance configuration"
" file %s: %s" % (cfg_file, err))
- @staticmethod
- def _ReadConfigFile(instance_name):
+ def _ReadConfigFile(self, instance_name):
"""Returns the contents of the instance config file.
"""
- filename = XenHypervisor._ConfigFileName(instance_name)
+ filename = self._ConfigFileName(instance_name)
try:
file_content = utils.ReadFile(filename)
return file_content
- @staticmethod
- def _RemoveConfigFile(instance_name):
+ def _RemoveConfigFile(self, instance_name):
"""Remove the xen configuration file.
"""
- utils.RemoveFile(XenHypervisor._ConfigFileName(instance_name))
+ utils.RemoveFile(self._ConfigFileName(instance_name))
+ try:
+ shutil.rmtree(self._InstanceNICDir(instance_name))
+ except OSError, err:
+ if err.errno != errno.ENOENT:
+ raise
- @staticmethod
- def _GetXmList(include_node):
- """Wrapper around module level L{_GetXmList}.
+ def _StashConfigFile(self, instance_name):
+ """Move the Xen config file to the log directory and return its new path.
+
+ """
+ old_filename = self._ConfigFileName(instance_name)
+ base = ("%s-%s" %
+ (instance_name, utils.TimestampForFilename()))
+ new_filename = utils.PathJoin(pathutils.LOG_XEN_DIR, base)
+ utils.RenameFile(old_filename, new_filename)
+ return new_filename
+
+ def _GetInstanceList(self, include_node, hvparams):
+ """Wrapper around module level L{_GetInstanceList}.
+
+ @type hvparams: dict of strings
+ @param hvparams: hypervisor parameters to be used on this node
"""
- # TODO: Abstract running Xen command for testing
- return _GetXmList(lambda: utils.RunCmd([constants.XEN_CMD, "list"]),
- include_node)
+ return _GetInstanceList(lambda: self._RunXen(["list"], hvparams),
+ include_node)
- def ListInstances(self):
+ def ListInstances(self, hvparams=None):
"""Get the list of running instances.
"""
- xm_list = self._GetXmList(False)
- names = [info[0] for info in xm_list]
+ instance_list = self._GetInstanceList(False, hvparams)
+ names = [info[0] for info in instance_list]
return names
- def GetInstanceInfo(self, instance_name):
+ def GetInstanceInfo(self, instance_name, hvparams=None):
"""Get instance properties.
+ @type instance_name: string
@param instance_name: the instance name
+ @type hvparams: dict of strings
+ @param hvparams: the instance's hypervisor params
@return: tuple (name, id, memory, vcpus, stat, times)
"""
- xm_list = self._GetXmList(instance_name == _DOM0_NAME)
+ instance_list = self._GetInstanceList(instance_name == _DOM0_NAME, hvparams)
result = None
- for data in xm_list:
+ for data in instance_list:
if data[0] == instance_name:
result = data
break
return result
- def GetAllInstancesInfo(self):
+ def GetAllInstancesInfo(self, hvparams=None):
"""Get properties of all instances.
+ @type hvparams: dict of strings
+ @param hvparams: hypervisor parameters
@return: list of tuples (name, id, memory, vcpus, stat, times)
"""
- xm_list = self._GetXmList(False)
- return xm_list
+ return self._GetInstanceList(False, hvparams)
+
+ def _MakeConfigFile(self, instance, startup_memory, block_devices):
+ """Gather configuration details and write to disk.
+
+ See L{_GetConfig} for arguments.
+
+ """
+ buf = StringIO()
+ buf.write("# Automatically generated by Ganeti. Do not edit!\n")
+ buf.write("\n")
+ buf.write(self._GetConfig(instance, startup_memory, block_devices))
+ buf.write("\n")
+
+ self._WriteConfigFile(instance.name, buf.getvalue())
def StartInstance(self, instance, block_devices, startup_paused):
"""Start an instance.
"""
- startup_memory = self._InstanceStartupMemory(instance)
- self._WriteConfigFile(instance, startup_memory, block_devices)
- cmd = [constants.XEN_CMD, "create"]
+ startup_memory = self._InstanceStartupMemory(instance,
+ hvparams=instance.hvparams)
+
+ self._MakeConfigFile(instance, startup_memory, block_devices)
+
+ cmd = ["create"]
if startup_paused:
- cmd.extend(["-p"])
- cmd.extend([self._ConfigFileName(instance.name)])
- result = utils.RunCmd(cmd)
+ cmd.append("-p")
+ cmd.append(self._ConfigFileName(instance.name))
+ result = self._RunXen(cmd, instance.hvparams)
if result.failed:
- raise errors.HypervisorError("Failed to start instance %s: %s (%s)" %
+ # Move the Xen configuration file to the log directory to avoid
+ # leaving a stale config file behind.
+ stashed_config = self._StashConfigFile(instance.name)
+ raise errors.HypervisorError("Failed to start instance %s: %s (%s). Moved"
+ " config file to %s" %
(instance.name, result.fail_reason,
- result.output))
+ result.output, stashed_config))
def StopInstance(self, instance, force=False, retry=False, name=None):
"""Stop an instance.
"""
if name is None:
name = instance.name
- self._RemoveConfigFile(name)
+
+ return self._StopInstance(name, force, instance.hvparams)
+
+ def _ShutdownInstance(self, name, hvparams):
+ """Shutdown an instance if the instance is running.
+
+ @type name: string
+ @param name: name of the instance to stop
+ @type hvparams: dict of string
+ @param hvparams: hypervisor parameters of the instance
+
+ The '-w' flag waits for shutdown to complete which avoids the need
+ to poll in the case where we want to destroy the domain
+ immediately after shutdown.
+
+ """
+ instance_info = self.GetInstanceInfo(name, hvparams=hvparams)
+
+ if instance_info is None or _IsInstanceShutdown(instance_info[4]):
+ logging.info("Failed to shutdown instance %s, not running", name)
+ return None
+
+ return self._RunXen(["shutdown", "-w", name], hvparams)
+
+ def _DestroyInstance(self, name, hvparams):
+ """Destroy an instance if the instance if the instance exists.
+
+ @type name: string
+ @param name: name of the instance to destroy
+ @type hvparams: dict of string
+ @param hvparams: hypervisor parameters of the instance
+
+ """
+ instance_info = self.GetInstanceInfo(name, hvparams=hvparams)
+
+ if instance_info is None:
+ logging.info("Failed to destroy instance %s, does not exist", name)
+ return None
+
+ return self._RunXen(["destroy", name], hvparams)
+
+ def _StopInstance(self, name, force, hvparams):
+ """Stop an instance.
+
+ @type name: string
+ @param name: name of the instance to destroy
+
+ @type force: boolean
+ @param force: whether to do a "hard" stop (destroy)
+
+ @type hvparams: dict of string
+ @param hvparams: hypervisor parameters of the instance
+
+ """
if force:
- command = [constants.XEN_CMD, "destroy", name]
+ result = self._DestroyInstance(name, hvparams)
else:
- command = [constants.XEN_CMD, "shutdown", name]
- result = utils.RunCmd(command)
+ self._ShutdownInstance(name, hvparams)
+ result = self._DestroyInstance(name, hvparams)
- if result.failed:
+ if result is not None and result.failed and \
+ self.GetInstanceInfo(name, hvparams=hvparams) is not None:
raise errors.HypervisorError("Failed to stop instance %s: %s, %s" %
(name, result.fail_reason, result.output))
+ # Remove configuration file if stopping/starting instance was successful
+ self._RemoveConfigFile(name)
+
def RebootInstance(self, instance):
"""Reboot an instance.
"""
- ini_info = self.GetInstanceInfo(instance.name)
+ ini_info = self.GetInstanceInfo(instance.name, hvparams=instance.hvparams)
if ini_info is None:
raise errors.HypervisorError("Failed to reboot instance %s,"
" not running" % instance.name)
- result = utils.RunCmd([constants.XEN_CMD, "reboot", instance.name])
+ result = self._RunXen(["reboot", instance.name], instance.hvparams)
if result.failed:
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)
+ new_info = self.GetInstanceInfo(instance.name, hvparams=instance.hvparams)
# check if the domain ID has changed or the run time has decreased
if (new_info is not None and
@param mem: actual memory size to use for instance runtime
"""
- cmd = [constants.XEN_CMD, "mem-set", instance.name, mem]
- result = utils.RunCmd(cmd)
+ result = self._RunXen(["mem-set", instance.name, mem], instance.hvparams)
if result.failed:
raise errors.HypervisorError("Failed to balloon instance %s: %s (%s)" %
(instance.name, result.fail_reason,
result.output))
+
+ # Update configuration file
cmd = ["sed", "-ie", "s/^memory.*$/memory = %s/" % mem]
- cmd.append(XenHypervisor._ConfigFileName(instance.name))
+ cmd.append(self._ConfigFileName(instance.name))
+
result = utils.RunCmd(cmd)
if result.failed:
raise errors.HypervisorError("Failed to update memory for %s: %s (%s)" %
(instance.name, result.fail_reason,
result.output))
- def GetNodeInfo(self):
+ def GetNodeInfo(self, hvparams=None):
"""Return information about the node.
@see: L{_GetNodeInfo} and L{_ParseNodeInfo}
"""
- # TODO: Abstract running Xen command for testing
- result = utils.RunCmd([constants.XEN_CMD, "info"])
+ result = self._RunXen(["info"], hvparams)
if result.failed:
- logging.error("Can't run 'xm info' (%s): %s", result.fail_reason,
- result.output)
+ logging.error("Can't retrieve xen hypervisor information (%s): %s",
+ result.fail_reason, result.output)
return None
- return _GetNodeInfo(result.stdout, self._GetXmList)
+ instance_list = self._GetInstanceList(True, hvparams)
+ return _GetNodeInfo(result.stdout, instance_list)
@classmethod
- def GetInstanceConsole(cls, instance, hvparams, beparams):
+ def GetInstanceConsole(cls, instance, primary_node, hvparams, beparams):
"""Return a command for connecting to the console of an instance.
"""
+ xen_cmd = XenHypervisor._GetCommandFromHvparams(hvparams)
return objects.InstanceConsole(instance=instance.name,
kind=constants.CONS_SSH,
- host=instance.primary_node,
+ host=primary_node.name,
user=constants.SSH_CONSOLE_USER,
command=[pathutils.XEN_CONSOLE_WRAPPER,
- constants.XEN_CMD, instance.name])
+ xen_cmd, instance.name])
- def Verify(self):
+ def Verify(self, hvparams=None):
"""Verify the hypervisor.
For Xen, this verifies that the xend process is running.
+ @type hvparams: dict of strings
+ @param hvparams: hypervisor parameters to be verified against
+
@return: Problem description if something is wrong, C{None} otherwise
"""
- result = utils.RunCmd([constants.XEN_CMD, "info"])
+ if hvparams is None:
+ return "Could not verify the hypervisor, because no hvparams were" \
+ " provided."
+
+ if constants.HV_XEN_CMD in hvparams:
+ xen_cmd = hvparams[constants.HV_XEN_CMD]
+ try:
+ self._CheckToolstack(xen_cmd)
+ except errors.HypervisorError:
+ return "The configured xen toolstack '%s' is not available on this" \
+ " node." % xen_cmd
+
+ result = self._RunXen(["info"], hvparams)
if result.failed:
- return "'xm info' failed: %s, %s" % (result.fail_reason, result.output)
+ return "Retrieving information from xen failed: %s, %s" % \
+ (result.fail_reason, result.output)
return None
"""
if success:
- self._WriteConfigFileStatic(instance.name, info)
+ self._WriteConfigFile(instance.name, info)
- def MigrateInstance(self, instance, target, live):
+ def MigrateInstance(self, cluster_name, instance, target, live):
"""Migrate an instance to a target node.
The migration will not be attempted if the instance is not
@param live: perform a live migration
"""
- if self.GetInstanceInfo(instance.name) is None:
+ port = instance.hvparams[constants.HV_MIGRATION_PORT]
+
+ return self._MigrateInstance(cluster_name, instance.name, target, port,
+ live, instance.hvparams)
+
+ def _MigrateInstance(self, cluster_name, instance_name, target, port, live,
+ hvparams, _ping_fn=netutils.TcpPing):
+ """Migrate an instance to a target node.
+
+ @see: L{MigrateInstance} for details
+
+ """
+ if hvparams is None:
+ raise errors.HypervisorError("No hvparams provided.")
+
+ if self.GetInstanceInfo(instance_name, hvparams=hvparams) is None:
raise errors.HypervisorError("Instance not running, cannot migrate")
- port = instance.hvparams[constants.HV_MIGRATION_PORT]
+ cmd = self._GetCommand(hvparams)
- if (constants.XEN_CMD == constants.XEN_CMD_XM and
- not netutils.TcpPing(target, port, live_port_needed=True)):
+ if (cmd == constants.XEN_CMD_XM and
+ not _ping_fn(target, port, live_port_needed=True)):
raise errors.HypervisorError("Remote host %s not listening on port"
" %s, cannot migrate" % (target, port))
- args = [constants.XEN_CMD, "migrate"]
- if constants.XEN_CMD == constants.XEN_CMD_XM:
+ args = ["migrate"]
+
+ if cmd == constants.XEN_CMD_XM:
args.extend(["-p", "%d" % port])
if live:
args.append("-l")
- elif constants.XEN_CMD == constants.XEN_CMD_XL:
- cluster_name = ssconf.SimpleStore().GetClusterName()
- args.extend(["-s", constants.XL_SSH_CMD % cluster_name])
- args.extend(["-C", self._ConfigFileName(instance.name)])
+
+ elif cmd == constants.XEN_CMD_XL:
+ args.extend([
+ "-s", constants.XL_SSH_CMD % cluster_name,
+ "-C", self._ConfigFileName(instance_name),
+ ])
+
else:
- raise errors.HypervisorError("Unsupported xen command: %s" %
- constants.XEN_CMD)
+ raise errors.HypervisorError("Unsupported Xen command: %s" % self._cmd)
+
+ args.extend([instance_name, target])
- args.extend([instance.name, target])
- result = utils.RunCmd(args)
+ result = self._RunXen(args, hvparams)
if result.failed:
raise errors.HypervisorError("Failed to migrate instance %s: %s" %
- (instance.name, result.output))
+ (instance_name, result.output))
def FinalizeMigrationSource(self, instance, success, live):
"""Finalize the instance migration on the source node.
"""
return objects.MigrationStatus(status=constants.HV_MIGRATION_COMPLETED)
- @classmethod
- def PowercycleNode(cls):
+ def PowercycleNode(self, hvparams=None):
"""Xen-specific powercycle.
This first does a Linux reboot (which triggers automatically a Xen
won't work in case the root filesystem is broken and/or the xend
daemon is not working.
+ @type hvparams: dict of strings
+ @param hvparams: hypervisor params to be used on this node
+
"""
try:
- cls.LinuxPowercycle()
+ self.LinuxPowercycle()
finally:
- utils.RunCmd([constants.XEN_CMD, "debug", "R"])
+ xen_cmd = self._GetCommand(hvparams)
+ utils.RunCmd([xen_cmd, "debug", "R"])
+
+ def _CheckToolstack(self, xen_cmd):
+ """Check whether the given toolstack is available on the node.
+
+ @type xen_cmd: string
+ @param xen_cmd: xen command (e.g. 'xm' or 'xl')
+
+ """
+ binary_found = self._CheckToolstackBinary(xen_cmd)
+ if not binary_found:
+ raise errors.HypervisorError("No '%s' binary found on node." % xen_cmd)
+ elif xen_cmd == constants.XEN_CMD_XL:
+ if not self._CheckToolstackXlConfigured():
+ raise errors.HypervisorError("Toolstack '%s' is not enabled on this"
+ "node." % xen_cmd)
+
+ def _CheckToolstackBinary(self, xen_cmd):
+ """Checks whether the xen command's binary is found on the machine.
+
+ """
+ if xen_cmd not in constants.KNOWN_XEN_COMMANDS:
+ raise errors.HypervisorError("Unknown xen command '%s'." % xen_cmd)
+ result = self._run_cmd_fn(["which", xen_cmd])
+ return not result.failed
+
+ def _CheckToolstackXlConfigured(self):
+ """Checks whether xl is enabled on an xl-capable node.
+
+ @rtype: bool
+ @returns: C{True} if 'xl' is enabled, C{False} otherwise
+
+ """
+ result = self._run_cmd_fn([constants.XEN_CMD_XL, "help"])
+ if not result.failed:
+ return True
+ elif result.failed:
+ if "toolstack" in result.stderr:
+ return False
+ # xl fails for some other reason than the toolstack
+ else:
+ raise errors.HypervisorError("Cannot run xen ('%s'). Error: %s."
+ % (constants.XEN_CMD_XL, result.stderr))
class XenPvmHypervisor(XenHypervisor):
constants.HV_CPU_CAP: hv_base.OPT_NONNEGATIVE_INT_CHECK,
constants.HV_CPU_WEIGHT:
(False, lambda x: 0 < x < 65536, "invalid weight", None, None),
+ constants.HV_VIF_SCRIPT: hv_base.OPT_FILE_CHECK,
+ constants.HV_XEN_CMD:
+ hv_base.ParamInSet(True, constants.KNOWN_XEN_COMMANDS),
+ constants.HV_XEN_CPUID: hv_base.NO_CHECK,
+ constants.HV_SOUNDHW: hv_base.NO_CHECK,
}
- @classmethod
- def _WriteConfigFile(cls, instance, startup_memory, block_devices):
+ def _GetConfig(self, instance, startup_memory, block_devices):
"""Write the Xen config file for the instance.
"""
config.write("name = '%s'\n" % instance.name)
vif_data = []
- for nic in instance.nics:
+ for idx, nic in enumerate(instance.nics):
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]
+ if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_OVS:
+ nic_str += ", bridge=%s" % nic.nicparams[constants.NIC_LINK]
+ if nic.nicparams[constants.NIC_VLAN]:
+ nic_str += "%s" % nic.nicparams[constants.NIC_VLAN]
+ if hvp[constants.HV_VIF_SCRIPT]:
+ nic_str += ", script=%s" % hvp[constants.HV_VIF_SCRIPT]
vif_data.append("'%s'" % nic_str)
+ self._WriteNICInfoFile(instance, idx, nic)
disk_data = \
_GetConfigFileDiskData(block_devices, hvp[constants.HV_BLOCKDEV_PREFIX])
config.write("on_reboot = 'destroy'\n")
config.write("on_crash = 'restart'\n")
config.write("extra = '%s'\n" % hvp[constants.HV_KERNEL_ARGS])
- cls._WriteConfigFileStatic(instance.name, config.getvalue())
- return True
+ cpuid = hvp[constants.HV_XEN_CPUID]
+ if cpuid:
+ config.write("cpuid = %s\n" % _QuoteCpuidField(cpuid))
+
+ if hvp[constants.HV_SOUNDHW]:
+ config.write("soundhw = '%s'\n" % hvp[constants.HV_SOUNDHW])
+
+ return config.getvalue()
class XenHvmHypervisor(XenHypervisor):
constants.HV_CPU_CAP: hv_base.NO_CHECK,
constants.HV_CPU_WEIGHT:
(False, lambda x: 0 < x < 65535, "invalid weight", None, None),
+ constants.HV_VIF_TYPE:
+ hv_base.ParamInSet(False, constants.HT_HVM_VALID_VIF_TYPES),
+ constants.HV_VIF_SCRIPT: hv_base.OPT_FILE_CHECK,
+ constants.HV_VIRIDIAN: hv_base.NO_CHECK,
+ constants.HV_XEN_CMD:
+ hv_base.ParamInSet(True, constants.KNOWN_XEN_COMMANDS),
+ constants.HV_XEN_CPUID: hv_base.NO_CHECK,
+ constants.HV_SOUNDHW: hv_base.NO_CHECK,
}
- @classmethod
- def _WriteConfigFile(cls, instance, startup_memory, block_devices):
+ def _GetConfig(self, instance, startup_memory, 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")
# kernel handling
kpath = hvp[constants.HV_KERNEL_PATH]
config.write("acpi = 1\n")
else:
config.write("acpi = 0\n")
+ if hvp[constants.HV_VIRIDIAN]:
+ config.write("viridian = 1\n")
+ else:
+ config.write("viridian = 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("localtime = 1\n")
vif_data = []
+ # Note: what is called 'nic_type' here, is used as value for the xen nic
+ # vif config parameter 'model'. For the xen nic vif parameter 'type', we use
+ # the 'vif_type' to avoid a clash of notation.
nic_type = hvp[constants.HV_NIC_TYPE]
+
if nic_type is None:
+ vif_type_str = ""
+ if hvp[constants.HV_VIF_TYPE]:
+ vif_type_str = ", type=%s" % hvp[constants.HV_VIF_TYPE]
# ensure old instances don't change
- nic_type_str = ", type=ioemu"
+ nic_type_str = vif_type_str
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:
+ # parameter 'model' is only valid with type 'ioemu'
+ nic_type_str = ", model=%s, type=%s" % \
+ (nic_type, constants.HT_HVM_VIF_IOEMU)
+ for idx, nic in enumerate(instance.nics):
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]
+ if hvp[constants.HV_VIF_SCRIPT]:
+ nic_str += ", script=%s" % hvp[constants.HV_VIF_SCRIPT]
vif_data.append("'%s'" % nic_str)
+ self._WriteNICInfoFile(instance, idx, nic)
config.write("vif = [%s]\n" % ",".join(vif_data))
else:
config.write("on_reboot = 'destroy'\n")
config.write("on_crash = 'restart'\n")
- cls._WriteConfigFileStatic(instance.name, config.getvalue())
- return True
+ cpuid = hvp[constants.HV_XEN_CPUID]
+ if cpuid:
+ config.write("cpuid = %s\n" % _QuoteCpuidField(cpuid))
+
+ if hvp[constants.HV_SOUNDHW]:
+ config.write("soundhw = '%s'\n" % hvp[constants.HV_SOUNDHW])
+
+ return config.getvalue()
projects / ganeti-local / blobdiff