#
#
-# Copyright (C) 2008, 2009, 2010, 2011, 2012 Google Inc.
+# Copyright (C) 2008, 2009, 2010, 2011, 2012, 2013 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
])
-def _ProbeTapVnetHdr(fd):
+def _GetTunFeatures(fd, _ioctl=fcntl.ioctl):
+ """Retrieves supported TUN features from file descriptor.
+
+ @see: L{_ProbeTapVnetHdr}
+
+ """
+ req = struct.pack("I", 0)
+ try:
+ buf = _ioctl(fd, TUNGETFEATURES, req)
+ except EnvironmentError, err:
+ logging.warning("ioctl(TUNGETFEATURES) failed: %s", err)
+ return None
+ else:
+ (flags, ) = struct.unpack("I", buf)
+ return flags
+
+
+def _ProbeTapVnetHdr(fd, _features_fn=_GetTunFeatures):
"""Check whether to enable the IFF_VNET_HDR flag.
To do this, _all_ of the following conditions must be met:
@param fd: the file descriptor of /dev/net/tun
"""
- req = struct.pack("I", 0)
- try:
- res = fcntl.ioctl(fd, TUNGETFEATURES, req)
- except EnvironmentError:
- logging.warning("TUNGETFEATURES ioctl() not implemented")
- return False
+ flags = _features_fn(fd)
- tunflags = struct.unpack("I", res)[0]
- if tunflags & IFF_VNET_HDR:
- return True
- else:
- logging.warning("Host does not support IFF_VNET_HDR, not enabling")
+ if flags is None:
+ # Not supported
return False
+ result = bool(flags & IFF_VNET_HDR)
+
+ if not result:
+ logging.warning("Kernel does not support IFF_VNET_HDR, not enabling")
+
+ return result
+
def _OpenTap(vnet_hdr=True):
"""Open a new tap device and return its file descriptor.
try:
res = fcntl.ioctl(tapfd, TUNSETIFF, ifr)
- except EnvironmentError:
- raise errors.HypervisorError("Failed to allocate a new TAP device")
+ except EnvironmentError, err:
+ raise errors.HypervisorError("Failed to allocate a new TAP device: %s" %
+ err)
# Get the interface name from the ioctl
ifname = struct.unpack("16sh", res)[0].strip("\x00")
return (ifname, tapfd)
-def _BuildNetworkEnv(name, network, gateway, network6, gateway6,
- network_type, mac_prefix, tags, env):
- """Build environment variables concerning a Network.
-
- """
- if name:
- env["NETWORK_NAME"] = name
- if network:
- env["NETWORK_SUBNET"] = network
- if gateway:
- env["NETWORK_GATEWAY"] = gateway
- if network6:
- env["NETWORK_SUBNET6"] = network6
- if gateway6:
- env["NETWORK_GATEWAY6"] = gateway6
- if mac_prefix:
- env["NETWORK_MAC_PREFIX"] = mac_prefix
- if network_type:
- env["NETWORK_TYPE"] = network_type
- if tags:
- env["NETWORK_TAGS"] = " ".join(tags)
-
- return env
-
-
class QmpMessage:
"""QEMU Messaging Protocol (QMP) message.
greeting = self._Recv()
if not greeting[self._FIRST_MESSAGE_KEY]:
self._connected = False
- raise errors.HypervisorError("kvm: qmp communication error (wrong"
+ raise errors.HypervisorError("kvm: QMP communication error (wrong"
" server greeting")
# Let's put the monitor in command mode using the qmp_capabilities
constants.HV_ACPI: hv_base.NO_CHECK,
constants.HV_SERIAL_CONSOLE: hv_base.NO_CHECK,
constants.HV_SERIAL_SPEED: hv_base.NO_CHECK,
- constants.HV_VNC_BIND_ADDRESS:
- (False, lambda x: (netutils.IP4Address.IsValid(x) or
- utils.IsNormAbsPath(x)),
- "the VNC bind address must be either a valid IP address or an absolute"
- " pathname", None, None),
+ constants.HV_VNC_BIND_ADDRESS: hv_base.NO_CHECK, # will be checked later
constants.HV_VNC_TLS: hv_base.NO_CHECK,
constants.HV_VNC_X509: hv_base.OPT_DIR_CHECK,
constants.HV_VNC_X509_VERIFY: hv_base.NO_CHECK,
constants.HV_KVM_SPICE_IP_VERSION:
(False, lambda x: (x == constants.IFACE_NO_IP_VERSION_SPECIFIED or
x in constants.VALID_IP_VERSIONS),
- "the SPICE IP version should be 4 or 6",
+ "The SPICE IP version should be 4 or 6",
None, None),
constants.HV_KVM_SPICE_PASSWORD_FILE: hv_base.OPT_FILE_CHECK,
constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR:
_ENABLE_KVM_RE = re.compile(r"^-enable-kvm\s", re.M)
_DISABLE_KVM_RE = re.compile(r"^-disable-kvm\s", re.M)
_NETDEV_RE = re.compile(r"^-netdev\s", re.M)
+ _DISPLAY_RE = re.compile(r"^-display\s", re.M)
+ _MACHINE_RE = re.compile(r"^-machine\s", re.M)
_NEW_VIRTIO_RE = re.compile(r"^name \"%s\"" % _VIRTIO_NET_PCI, re.M)
# match -drive.*boot=on|off on different lines, but in between accept only
# dashes not preceeded by a new line (which would mean another option
# different than -drive is starting)
_BOOT_RE = re.compile(r"^-drive\s([^-]|(?<!^)-)*,boot=on\|off", re.M | re.S)
+ _UUID_RE = re.compile(r"^-uuid\s", re.M)
ANCILLARY_FILES = [
_KVM_NETWORK_SCRIPT,
_KVMOPT_HELP = "help"
_KVMOPT_MLIST = "mlist"
_KVMOPT_DEVICELIST = "devicelist"
+
+ # Command to execute to get the output from kvm, and whether to
+ # accept the output even on failure.
_KVMOPTS_CMDS = {
- _KVMOPT_HELP: ["--help"],
- _KVMOPT_MLIST: ["-M", "?"],
- _KVMOPT_DEVICELIST: ["-device", "?"],
+ _KVMOPT_HELP: (["--help"], False),
+ _KVMOPT_MLIST: (["-M", "?"], False),
+ _KVMOPT_DEVICELIST: (["-device", "?"], True),
}
def __init__(self):
if nic.network:
n = objects.Network.FromDict(nic.netinfo)
- _BuildNetworkEnv(nic.network, n.network, n.gateway,
- n.network6, n.gateway6, n.network_type,
- n.mac_prefix, n.tags, env)
+ env.update(n.HooksDict())
if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
env["BRIDGE"] = nic.nicparams[constants.NIC_LINK]
result = utils.RunCmd([pathutils.KVM_IFUP, tap], env=env)
if result.failed:
- raise errors.HypervisorError("Failed to configure interface %s: %s."
- " Network configuration script output: %s" %
+ raise errors.HypervisorError("Failed to configure interface %s: %s;"
+ " network configuration script output: %s" %
(tap, result.fail_reason, result.output))
@staticmethod
# Run CPU pinning, based on configured mask
self._AssignCpuAffinity(cpu_mask, pid, thread_dict)
- def ListInstances(self):
+ def ListInstances(self, hvparams=None):
"""Get the list of running instances.
We can do this by listing our live instances directory and
result.append(name)
return result
- 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: hvparams to be used with this instance
@rtype: tuple of strings
@return: (name, id, memory, vcpus, stat, times)
return (instance_name, pid, memory, vcpus, istat, times)
- def GetAllInstancesInfo(self):
+ def GetAllInstancesInfo(self, hvparams=None):
"""Get properties of all instances.
+ @type hvparams: dict of strings
+ @param hvparams: hypervisor parameter
@return: list of tuples (name, id, memory, vcpus, stat, times)
"""
"""
# pylint: disable=R0912,R0914,R0915
hvp = instance.hvparams
+ self.ValidateParameters(hvp)
pidfile = self._InstancePidFile(instance.name)
kvm = hvp[constants.HV_KVM_PATH]
mversion = hvp[constants.HV_KVM_MACHINE_VERSION]
if not mversion:
mversion = self._GetDefaultMachineVersion(kvm)
- kvm_cmd.extend(["-M", mversion])
+ if self._MACHINE_RE.search(kvmhelp):
+ # TODO (2.8): kernel_irqchip and kvm_shadow_mem machine properties, as
+ # extra hypervisor parameters. We should also investigate whether and how
+ # shadow_mem should be considered for the resource model.
+ if (hvp[constants.HV_KVM_FLAG] == constants.HT_KVM_ENABLED):
+ specprop = ",accel=kvm"
+ else:
+ specprop = ""
+ machinespec = "%s%s" % (mversion, specprop)
+ kvm_cmd.extend(["-machine", machinespec])
+ else:
+ kvm_cmd.extend(["-M", mversion])
+ if (hvp[constants.HV_KVM_FLAG] == constants.HT_KVM_ENABLED and
+ self._ENABLE_KVM_RE.search(kvmhelp)):
+ kvm_cmd.extend(["-enable-kvm"])
+ elif (hvp[constants.HV_KVM_FLAG] == constants.HT_KVM_DISABLED and
+ self._DISABLE_KVM_RE.search(kvmhelp)):
+ kvm_cmd.extend(["-disable-kvm"])
kernel_path = hvp[constants.HV_KERNEL_PATH]
if kernel_path:
boot_floppy = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_FLOPPY
boot_network = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_NETWORK
- self.ValidateParameters(hvp)
-
if startup_paused:
kvm_cmd.extend([_KVM_START_PAUSED_FLAG])
- if (hvp[constants.HV_KVM_FLAG] == constants.HT_KVM_ENABLED and
- self._ENABLE_KVM_RE.search(kvmhelp)):
- kvm_cmd.extend(["-enable-kvm"])
- elif (hvp[constants.HV_KVM_FLAG] == constants.HT_KVM_DISABLED and
- self._DISABLE_KVM_RE.search(kvmhelp)):
- kvm_cmd.extend(["-disable-kvm"])
-
if boot_network:
kvm_cmd.extend(["-boot", "n"])
kvm_cmd.extend(["-usbdevice", constants.HT_MOUSE_TABLET])
if vnc_bind_address:
+ if netutils.IsValidInterface(vnc_bind_address):
+ if_addresses = netutils.GetInterfaceIpAddresses(vnc_bind_address)
+ if_ip4_addresses = if_addresses[constants.IP4_VERSION]
+ if len(if_ip4_addresses) < 1:
+ logging.error("Could not determine IPv4 address of interface %s",
+ vnc_bind_address)
+ else:
+ vnc_bind_address = if_ip4_addresses[0]
if netutils.IP4Address.IsValid(vnc_bind_address):
if instance.network_port > constants.VNC_BASE_PORT:
display = instance.network_port - constants.VNC_BASE_PORT
else:
vnc_arg = "%s:%d" % (vnc_bind_address, display)
else:
- logging.error("Network port is not a valid VNC display (%d < %d)."
- " Not starting VNC", instance.network_port,
- constants.VNC_BASE_PORT)
+ logging.error("Network port is not a valid VNC display (%d < %d),"
+ " not starting VNC",
+ instance.network_port, constants.VNC_BASE_PORT)
vnc_arg = "none"
# Only allow tls and other option when not binding to a file, for now.
# have that kind of IP addresses, throw an exception
if spice_ip_version != constants.IFACE_NO_IP_VERSION_SPECIFIED:
if not addresses[spice_ip_version]:
- raise errors.HypervisorError("spice: unable to get an IPv%s address"
+ raise errors.HypervisorError("SPICE: Unable to get an IPv%s address"
" for %s" % (spice_ip_version,
spice_bind))
elif addresses[constants.IP6_VERSION]:
spice_ip_version = constants.IP6_VERSION
else:
- raise errors.HypervisorError("spice: unable to get an IP address"
+ raise errors.HypervisorError("SPICE: Unable to get an IP address"
" for %s" % (spice_bind))
spice_address = addresses[spice_ip_version][0]
# Enable the spice agent communication channel between the host and the
# agent.
kvm_cmd.extend(["-device", "virtio-serial-pci"])
- kvm_cmd.extend(["-device", "virtserialport,chardev=spicechannel0,"
- "name=com.redhat.spice.0"])
+ kvm_cmd.extend([
+ "-device",
+ "virtserialport,chardev=spicechannel0,name=com.redhat.spice.0",
+ ])
kvm_cmd.extend(["-chardev", "spicevmc,id=spicechannel0,name=vdagent"])
logging.info("KVM: SPICE will listen on port %s", instance.network_port)
kvm_cmd.extend(["-spice", spice_arg])
else:
- kvm_cmd.extend(["-nographic"])
+ # From qemu 1.4 -nographic is incompatible with -daemonize. The new way
+ # also works in earlier versions though (tested with 1.1 and 1.3)
+ if self._DISPLAY_RE.search(kvmhelp):
+ kvm_cmd.extend(["-display", "none"])
+ else:
+ kvm_cmd.extend(["-nographic"])
if hvp[constants.HV_USE_LOCALTIME]:
kvm_cmd.extend(["-localtime"])
for dev in hvp[constants.HV_USB_DEVICES].split(","):
kvm_cmd.extend(["-usbdevice", dev])
+ # Set system UUID to instance UUID
+ if self._UUID_RE.search(kvmhelp):
+ kvm_cmd.extend(["-uuid", instance.uuid])
+
if hvp[constants.HV_KVM_EXTRA]:
kvm_cmd.extend([hvp[constants.HV_KVM_EXTRA]])
kvm_supports_netdev = self._NETDEV_RE.search(kvmhelp)
for nic_seq, nic in enumerate(kvm_nics):
- tapname, tapfd = _OpenTap(vnet_hdr)
+ tapname, tapfd = _OpenTap(vnet_hdr=vnet_hdr)
tapfds.append(tapfd)
taps.append(tapname)
if kvm_supports_netdev:
"""Invoke a command on the instance monitor.
"""
+ # TODO: Replace monitor calls with QMP once KVM >= 0.14 is the minimum
+ # version. The monitor protocol is designed for human consumption, whereas
+ # QMP is made for programmatic usage. In the worst case QMP can also
+ # execute monitor commands. As it is, all calls to socat take at least
+ # 500ms and likely more: socat can't detect the end of the reply and waits
+ # for 500ms of no data received before exiting (500 ms is the default for
+ # the "-t" parameter).
socat = ("echo %s | %s STDIO UNIX-CONNECT:%s" %
(utils.ShellQuote(command),
constants.SOCAT_PATH,
utils.ShellQuote(self._InstanceMonitor(instance_name))))
result = utils.RunCmd(socat)
if result.failed:
- msg = ("Failed to send command '%s' to instance %s."
- " output: %s, error: %s, fail_reason: %s" %
- (command, instance_name,
- result.stdout, result.stderr, result.fail_reason))
+ msg = ("Failed to send command '%s' to instance '%s', reason '%s',"
+ " output: %s" %
+ (command, instance_name, result.fail_reason, result.output))
raise errors.HypervisorError(msg)
return result
def _GetKVMOutput(cls, kvm_path, option):
"""Return the output of a kvm invocation
+ @type kvm_path: string
+ @param kvm_path: path to the kvm executable
+ @type option: a key of _KVMOPTS_CMDS
+ @param option: kvm option to fetch the output from
@return: output a supported kvm invocation
@raise errors.HypervisorError: when the KVM help output cannot be retrieved
"""
assert option in cls._KVMOPTS_CMDS, "Invalid output option"
- result = utils.RunCmd([kvm_path] + cls._KVMOPTS_CMDS[option])
- if result.failed:
+ optlist, can_fail = cls._KVMOPTS_CMDS[option]
+
+ result = utils.RunCmd([kvm_path] + optlist)
+ if result.failed and not can_fail:
raise errors.HypervisorError("Unable to get KVM %s output" %
" ".join(cls._KVMOPTS_CMDS[option]))
return result.output
else:
self.StopInstance(instance, force=True)
- 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
currently running.
+ @type cluster_name: string
+ @param cluster_name: name of the cluster
@type instance: L{objects.Instance}
@param instance: the instance to be migrated
@type target: string
"""
self._CallMonitorCommand(instance.name, "balloon %d" % mem)
- def GetNodeInfo(self):
+ def GetNodeInfo(self, hvparams=None):
"""Return information about the node.
+ @type hvparams: dict of strings
+ @param hvparams: hypervisor parameters, not used in this class
+
@return: a dict with the following keys (values in MiB):
- memory_total: the total memory size on the node
- memory_free: the available memory on the node for instances
message=("No serial shell for instance %s" %
instance.name))
- def Verify(self):
+ def Verify(self, hvparams=None):
"""Verify the hypervisor.
Check that the required binaries exist.
+ @type hvparams: dict of strings
+ @param hvparams: hypervisor parameters to be verified against, not used here
+
@return: Problem description if something is wrong, C{None} otherwise
"""
- # FIXME: this is the global kvm version, but the actual version can be
- # customized as an hv parameter. we should use the nodegroup's default kvm
- # path parameter here.
+ msgs = []
+ # FIXME: this is the global kvm binary, but the actual path can be
+ # customized as an hv parameter; we should use the nodegroup's
+ # default kvm path parameter here.
if not os.path.exists(constants.KVM_PATH):
- return "The KVM binary ('%s') does not exist" % constants.KVM_PATH
+ msgs.append("The KVM binary ('%s') does not exist" % constants.KVM_PATH)
if not os.path.exists(constants.SOCAT_PATH):
- return "The socat binary ('%s') does not exist" % constants.SOCAT_PATH
- return None
+ msgs.append("The socat binary ('%s') does not exist" %
+ constants.SOCAT_PATH)
+
+ return self._FormatVerifyResults(msgs)
@classmethod
def CheckParameterSyntax(cls, hvparams):
# IP of that family
if (netutils.IP4Address.IsValid(spice_bind) and
spice_ip_version != constants.IP4_VERSION):
- raise errors.HypervisorError("spice: got an IPv4 address (%s), but"
+ raise errors.HypervisorError("SPICE: Got an IPv4 address (%s), but"
" the specified IP version is %s" %
(spice_bind, spice_ip_version))
if (netutils.IP6Address.IsValid(spice_bind) and
spice_ip_version != constants.IP6_VERSION):
- raise errors.HypervisorError("spice: got an IPv6 address (%s), but"
+ raise errors.HypervisorError("SPICE: Got an IPv6 address (%s), but"
" the specified IP version is %s" %
(spice_bind, spice_ip_version))
else:
# error if any of them is set without it.
for param in _SPICE_ADDITIONAL_PARAMS:
if hvparams[param]:
- raise errors.HypervisorError("spice: %s requires %s to be set" %
+ raise errors.HypervisorError("SPICE: %s requires %s to be set" %
(param, constants.HV_KVM_SPICE_BIND))
@classmethod
except KeyError:
raise errors.HypervisorError("Unknown security domain user %s"
% username)
+ vnc_bind_address = hvparams[constants.HV_VNC_BIND_ADDRESS]
+ if vnc_bind_address:
+ bound_to_addr = netutils.IP4Address.IsValid(vnc_bind_address)
+ is_interface = netutils.IsValidInterface(vnc_bind_address)
+ is_path = utils.IsNormAbsPath(vnc_bind_address)
+ if not bound_to_addr and not is_interface and not is_path:
+ raise errors.HypervisorError("VNC: The %s parameter must be either"
+ " a valid IP address, an interface name,"
+ " or an absolute path" %
+ constants.HV_KVM_SPICE_BIND)
spice_bind = hvparams[constants.HV_KVM_SPICE_BIND]
if spice_bind:
# only one of VNC and SPICE can be used currently.
if hvparams[constants.HV_VNC_BIND_ADDRESS]:
- raise errors.HypervisorError("both SPICE and VNC are configured, but"
+ raise errors.HypervisorError("Both SPICE and VNC are configured, but"
" only one of them can be used at a"
- " given time.")
+ " given time")
# check that KVM supports SPICE
kvmhelp = cls._GetKVMOutput(kvm_path, cls._KVMOPT_HELP)
if not cls._SPICE_RE.search(kvmhelp):
- raise errors.HypervisorError("spice is configured, but it is not"
- " supported according to kvm --help")
+ raise errors.HypervisorError("SPICE is configured, but it is not"
+ " supported according to 'kvm --help'")
# if spice_bind is not an IP address, it must be a valid interface
- bound_to_addr = (netutils.IP4Address.IsValid(spice_bind)
- or netutils.IP6Address.IsValid(spice_bind))
+ bound_to_addr = (netutils.IP4Address.IsValid(spice_bind) or
+ netutils.IP6Address.IsValid(spice_bind))
if not bound_to_addr and not netutils.IsValidInterface(spice_bind):
- raise errors.HypervisorError("spice: the %s parameter must be either"
+ raise errors.HypervisorError("SPICE: The %s parameter must be either"
" a valid IP address or interface name" %
constants.HV_KVM_SPICE_BIND)
machine_version)
@classmethod
- def PowercycleNode(cls):
+ def PowercycleNode(cls, hvparams=None):
"""KVM powercycle, just a wrapper over Linux powercycle.
+ @type hvparams: dict of strings
+ @param hvparams: hypervisor params to be used on this node
+
"""
cls.LinuxPowercycle()
projects / ganeti-local / blobdiff