_CONF_DIR = _ROOT_DIR + "/conf" # contains instances startup data
_DIRS = [_ROOT_DIR, _PIDS_DIR, _CTRL_DIR, _CONF_DIR]
- PARAMETERS = [
- constants.HV_KERNEL_PATH,
- constants.HV_INITRD_PATH,
- constants.HV_ROOT_PATH,
- constants.HV_ACPI,
- constants.HV_SERIAL_CONSOLE,
- constants.HV_VNC_BIND_ADDRESS,
- constants.HV_VNC_TLS,
- constants.HV_VNC_X509,
- constants.HV_VNC_X509_VERIFY,
- constants.HV_CDROM_IMAGE_PATH,
- constants.HV_BOOT_ORDER,
- ]
+ PARAMETERS = {
+ constants.HV_KERNEL_PATH: hv_base.OPT_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_ACPI: hv_base.NO_CHECK,
+ constants.HV_SERIAL_CONSOLE: hv_base.NO_CHECK,
+ constants.HV_VNC_BIND_ADDRESS:
+ (False, lambda x: (utils.IsValidIP(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_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_VNC_PASSWORD_FILE: hv_base.OPT_FILE_CHECK,
+ constants.HV_CDROM_IMAGE_PATH: hv_base.OPT_FILE_CHECK,
+ constants.HV_BOOT_ORDER:
+ hv_base.ParamInSet(True, constants.HT_KVM_VALID_BO_TYPES),
+ constants.HV_NIC_TYPE:
+ hv_base.ParamInSet(True, constants.HT_KVM_VALID_NIC_TYPES),
+ constants.HV_DISK_TYPE:
+ hv_base.ParamInSet(True, constants.HT_KVM_VALID_DISK_TYPES),
+ constants.HV_USB_MOUSE:
+ hv_base.ParamInSet(False, constants.HT_KVM_VALID_MOUSE_TYPES),
+ constants.HV_MIGRATION_PORT: hv_base.NET_PORT_CHECK,
+ constants.HV_USE_LOCALTIME: hv_base.NO_CHECK,
+ }
_MIGRATION_STATUS_RE = re.compile('Migration\s+status:\s+(\w+)',
re.M | re.I)
+ _KVM_NETWORK_SCRIPT = constants.SYSCONFDIR + "/ganeti/kvm-vif-bridge"
+
+ ANCILLARY_FILES = [
+ _KVM_NETWORK_SCRIPT,
+ ]
+
def __init__(self):
hv_base.BaseHypervisor.__init__(self)
# Let's make sure the directories we need exist, even if the RUN_DIR lives
# in a tmpfs filesystem or has been otherwise wiped out.
- for mydir in self._DIRS:
- if not os.path.exists(mydir):
- os.mkdir(mydir)
+ dirs = [(dname, constants.RUN_DIRS_MODE) for dname in self._DIRS]
+ utils.EnsureDirs(dirs)
def _InstancePidAlive(self, instance_name):
"""Returns the instance pid and pidfile
"""
return '%s/%s.serial' % (cls._CTRL_DIR, instance_name)
+ @staticmethod
+ def _SocatUnixConsoleParams():
+ """Returns the correct parameters for socat
+
+ If we have a new-enough socat we can use raw mode with an escape character.
+
+ """
+ if constants.SOCAT_USE_ESCAPE:
+ return "raw,echo=0,escape=%s" % constants.SOCAT_ESCAPE_CODE
+ else:
+ return "echo=0,icanon=0"
+
@classmethod
def _InstanceKVMRuntime(cls, instance_name):
"""Returns the instance KVM runtime filename
"""
return '%s/%s.runtime' % (cls._CONF_DIR, instance_name)
+ @classmethod
+ def _RemoveInstanceRuntimeFiles(cls, pidfile, instance_name):
+ """Removes an instance's rutime sockets/files.
+
+ """
+ utils.RemoveFile(pidfile)
+ utils.RemoveFile(cls._InstanceMonitor(instance_name))
+ utils.RemoveFile(cls._InstanceSerial(instance_name))
+ utils.RemoveFile(cls._InstanceKVMRuntime(instance_name))
+
def _WriteNetScript(self, instance, seq, nic):
"""Write a script to connect a net interface to the proper bridge.
script.write("# this is autogenerated by Ganeti, please do not edit\n#\n")
script.write("export INSTANCE=%s\n" % instance.name)
script.write("export MAC=%s\n" % nic.mac)
- script.write("export IP=%s\n" % nic.ip)
- script.write("export BRIDGE=%s\n" % nic.bridge)
+ if nic.ip:
+ script.write("export IP=%s\n" % nic.ip)
+ script.write("export MODE=%s\n" % nic.nicparams[constants.NIC_MODE])
+ if nic.nicparams[constants.NIC_LINK]:
+ script.write("export LINK=%s\n" % nic.nicparams[constants.NIC_LINK])
+ if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
+ script.write("export BRIDGE=%s\n" % nic.nicparams[constants.NIC_LINK])
script.write("export INTERFACE=$1\n")
# TODO: make this configurable at ./configure time
- script.write("if [ -x /etc/ganeti/kvm-vif-bridge ]; then\n")
+ script.write("if [ -x '%s' ]; then\n" % self._KVM_NETWORK_SCRIPT)
script.write(" # Execute the user-specific vif file\n")
- script.write(" /etc/ganeti/kvm-vif-bridge\n")
+ script.write(" %s\n" % self._KVM_NETWORK_SCRIPT)
script.write("else\n")
- script.write(" # Connect the interface to the bridge\n")
script.write(" /sbin/ifconfig $INTERFACE 0.0.0.0 up\n")
- script.write(" /usr/sbin/brctl addif $BRIDGE $INTERFACE\n")
+ if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
+ script.write(" # Connect the interface to the bridge\n")
+ script.write(" /usr/sbin/brctl addif $BRIDGE $INTERFACE\n")
+ elif nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_ROUTED:
+ script.write(" # Route traffic targeted at the IP to the interface\n")
+ if nic.nicparams[constants.NIC_LINK]:
+ script.write(" while /sbin/ip rule del dev $INTERFACE; do :; done\n")
+ script.write(" /sbin/ip rule add dev $INTERFACE table $LINK\n")
+ script.write(" /sbin/ip route replace $IP table $LINK proto static"
+ " dev $INTERFACE\n")
+ else:
+ script.write(" /sbin/ip route replace $IP proto static"
+ " dev $INTERFACE\n")
+ interface_v4_conf = "/proc/sys/net/ipv4/conf/$INTERFACE"
+ interface_v6_conf = "/proc/sys/net/ipv6/conf/$INTERFACE"
+ script.write(" if [ -d %s ]; then\n" % interface_v4_conf)
+ script.write(" echo 1 > %s/proxy_arp\n" % interface_v4_conf)
+ script.write(" echo 1 > %s/forwarding\n" % interface_v4_conf)
+ script.write(" fi\n")
+ script.write(" if [ -d %s ]; then\n" % interface_v6_conf)
+ script.write(" echo 1 > %s/proxy_ndp\n" % interface_v6_conf)
+ script.write(" echo 1 > %s/forwarding\n" % interface_v6_conf)
+ script.write(" fi\n")
script.write("fi\n\n")
# As much as we'd like to put this in our _ROOT_DIR, that will happen to be
# mounted noexec sometimes, so we'll have to find another place.
(tmpfd, tmpfile_name) = tempfile.mkstemp()
tmpfile = os.fdopen(tmpfd, 'w')
- tmpfile.write(script.getvalue())
- tmpfile.close()
+ try:
+ tmpfile.write(script.getvalue())
+ finally:
+ tmpfile.close()
os.chmod(tmpfile_name, 0755)
return tmpfile_name
cmdline_file = "/proc/%s/cmdline" % pid
try:
- fh = open(cmdline_file, 'r')
- try:
- cmdline = fh.read()
- finally:
- fh.close()
+ cmdline = utils.ReadFile(cmdline_file)
except EnvironmentError, err:
raise errors.HypervisorError("Failed to list instance %s: %s" %
(instance_name, err))
while arg_list:
arg = arg_list.pop(0)
if arg == '-m':
- memory = arg_list.pop(0)
+ memory = int(arg_list.pop(0))
elif arg == '-smp':
- vcpus = arg_list.pop(0)
+ vcpus = int(arg_list.pop(0))
return (instance_name, pid, memory, vcpus, stat, times)
return data
- def _GenerateKVMRuntime(self, instance, block_devices, extra_args):
+ def _GenerateKVMRuntime(self, instance, block_devices):
"""Generate KVM information to start an instance.
"""
if not instance.hvparams[constants.HV_ACPI]:
kvm_cmd.extend(['-no-acpi'])
- boot_disk = (instance.hvparams[constants.HV_BOOT_ORDER] == "disk")
- boot_cdrom = (instance.hvparams[constants.HV_BOOT_ORDER] == "cdrom")
+ hvp = instance.hvparams
+ boot_disk = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_DISK
+ boot_cdrom = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_CDROM
+ boot_network = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_NETWORK
+
+ if boot_network:
+ kvm_cmd.extend(['-boot', 'n'])
+
+ disk_type = hvp[constants.HV_DISK_TYPE]
+ if disk_type == constants.HT_DISK_PARAVIRTUAL:
+ if_val = ',if=virtio'
+ else:
+ if_val = ',if=%s' % disk_type
for cfdev, dev_path in block_devices:
if cfdev.mode != constants.DISK_RDWR:
raise errors.HypervisorError("Instance has read-only disks which"
" are not supported by KVM")
# TODO: handle FD_LOOP and FD_BLKTAP (?)
if boot_disk:
+ kvm_cmd.extend(['-boot', 'c'])
boot_val = ',boot=on'
+ # We only boot from the first disk
boot_disk = False
else:
boot_val = ''
- # TODO: handle different if= types
- if_val = ',if=virtio'
-
drive_val = 'file=%s,format=raw%s%s' % (dev_path, if_val, boot_val)
kvm_cmd.extend(['-drive', drive_val])
- iso_image = instance.hvparams[constants.HV_CDROM_IMAGE_PATH]
+ iso_image = hvp[constants.HV_CDROM_IMAGE_PATH]
if iso_image:
- options = ',format=raw,if=virtio,media=cdrom'
+ options = ',format=raw,media=cdrom'
if boot_cdrom:
+ kvm_cmd.extend(['-boot', 'd'])
options = '%s,boot=on' % options
+ else:
+ options = '%s,if=virtio' % options
drive_val = 'file=%s%s' % (iso_image, options)
kvm_cmd.extend(['-drive', drive_val])
- kernel_path = instance.hvparams[constants.HV_KERNEL_PATH]
+ kernel_path = hvp[constants.HV_KERNEL_PATH]
if kernel_path:
kvm_cmd.extend(['-kernel', kernel_path])
- initrd_path = instance.hvparams[constants.HV_INITRD_PATH]
+ initrd_path = hvp[constants.HV_INITRD_PATH]
if initrd_path:
kvm_cmd.extend(['-initrd', initrd_path])
- root_append = 'root=%s ro' % instance.hvparams[constants.HV_ROOT_PATH]
- if instance.hvparams[constants.HV_SERIAL_CONSOLE]:
- kvm_cmd.extend(['-append', 'console=ttyS0,38400 %s' % root_append])
- else:
- kvm_cmd.extend(['-append', root_append])
-
- # FIXME: handle vnc password
- vnc_bind_address = instance.hvparams[constants.HV_VNC_BIND_ADDRESS]
+ root_append = ['root=%s' % hvp[constants.HV_ROOT_PATH],
+ hvp[constants.HV_KERNEL_ARGS]]
+ if hvp[constants.HV_SERIAL_CONSOLE]:
+ root_append.append('console=ttyS0,38400')
+ kvm_cmd.extend(['-append', ' '.join(root_append)])
+
+ mouse_type = hvp[constants.HV_USB_MOUSE]
+ if mouse_type:
+ kvm_cmd.extend(['-usb'])
+ kvm_cmd.extend(['-usbdevice', mouse_type])
+
+ vnc_bind_address = hvp[constants.HV_VNC_BIND_ADDRESS]
if vnc_bind_address:
- kvm_cmd.extend(['-usbdevice', 'tablet'])
if utils.IsValidIP(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
if vnc_bind_address == '0.0.0.0':
vnc_arg = ':%d' % (display)
else:
- vnc_arg = '%s:%d' % (constants.HV_VNC_BIND_ADDRESS, display)
+ 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.HT_HVM_VNC_BASE_PORT))
+ constants.VNC_BASE_PORT))
vnc_arg = 'none'
# Only allow tls and other option when not binding to a file, for now.
# kvm/qemu gets confused otherwise about the filename to use.
vnc_append = ''
- if instance.hvparams[constants.HV_VNC_TLS]:
+ if hvp[constants.HV_VNC_TLS]:
vnc_append = '%s,tls' % vnc_append
- if instance.hvparams[constants.HV_VNC_X509_VERIFY]:
+ if hvp[constants.HV_VNC_X509_VERIFY]:
vnc_append = '%s,x509verify=%s' % (vnc_append,
- instance.hvparams[constants.HV_VNC_X509])
- elif instance.hvparams[constants.HV_VNC_X509]:
+ hvp[constants.HV_VNC_X509])
+ elif hvp[constants.HV_VNC_X509]:
vnc_append = '%s,x509=%s' % (vnc_append,
- instance.hvparams[constants.HV_VNC_X509])
+ hvp[constants.HV_VNC_X509])
+ if hvp[constants.HV_VNC_PASSWORD_FILE]:
+ vnc_append = '%s,password' % vnc_append
+
vnc_arg = '%s%s' % (vnc_arg, vnc_append)
else:
else:
kvm_cmd.extend(['-nographic'])
- monitor_dev = 'unix:%s,server,nowait' % \
- self._InstanceMonitor(instance.name)
+ monitor_dev = ("unix:%s,server,nowait" %
+ self._InstanceMonitor(instance.name))
kvm_cmd.extend(['-monitor', monitor_dev])
- if instance.hvparams[constants.HV_SERIAL_CONSOLE]:
- serial_dev = 'unix:%s,server,nowait' % self._InstanceSerial(instance.name)
+ if hvp[constants.HV_SERIAL_CONSOLE]:
+ serial_dev = ('unix:%s,server,nowait' %
+ self._InstanceSerial(instance.name))
kvm_cmd.extend(['-serial', serial_dev])
else:
kvm_cmd.extend(['-serial', 'none'])
+ if hvp[constants.HV_USE_LOCALTIME]:
+ kvm_cmd.extend(['-localtime'])
+
# Save the current instance nics, but defer their expansion as parameters,
# as we'll need to generate executable temp files for them.
kvm_nics = instance.nics
+ hvparams = hvp
- return (kvm_cmd, kvm_nics)
+ return (kvm_cmd, kvm_nics, hvparams)
def _WriteKVMRuntime(self, instance_name, data):
"""Write an instance's KVM runtime
"""Save an instance's KVM runtime
"""
- kvm_cmd, kvm_nics = kvm_runtime
+ kvm_cmd, kvm_nics, hvparams = kvm_runtime
serialized_nics = [nic.ToDict() for nic in kvm_nics]
- serialized_form = serializer.Dump((kvm_cmd, serialized_nics))
+ serialized_form = serializer.Dump((kvm_cmd, serialized_nics, hvparams))
self._WriteKVMRuntime(instance.name, serialized_form)
def _LoadKVMRuntime(self, instance, serialized_runtime=None):
if not serialized_runtime:
serialized_runtime = self._ReadKVMRuntime(instance.name)
loaded_runtime = serializer.Load(serialized_runtime)
- kvm_cmd, serialized_nics = loaded_runtime
+ kvm_cmd, serialized_nics, hvparams = loaded_runtime
kvm_nics = [objects.NIC.FromDict(snic) for snic in serialized_nics]
- return (kvm_cmd, kvm_nics)
+ return (kvm_cmd, kvm_nics, hvparams)
def _ExecuteKVMRuntime(self, instance, kvm_runtime, incoming=None):
"""Execute a KVM cmd, after completing it with some last minute data
"""
pidfile, pid, alive = self._InstancePidAlive(instance.name)
+ hvp = instance.hvparams
if alive:
raise errors.HypervisorError("Failed to start instance %s: %s" %
(instance.name, "already running"))
temp_files = []
- kvm_cmd, kvm_nics = kvm_runtime
+ kvm_cmd, kvm_nics, hvparams = kvm_runtime
if not kvm_nics:
kvm_cmd.extend(['-net', 'none'])
else:
+ nic_type = hvparams[constants.HV_NIC_TYPE]
+ if nic_type == constants.HT_NIC_PARAVIRTUAL:
+ nic_model = "model=virtio"
+ else:
+ nic_model = "model=%s" % nic_type
+
for nic_seq, nic in enumerate(kvm_nics):
- nic_val = "nic,macaddr=%s,model=virtio" % nic.mac
+ nic_val = "nic,macaddr=%s,%s" % (nic.mac, nic_model)
script = self._WriteNetScript(instance, nic_seq, nic)
kvm_cmd.extend(['-net', nic_val])
kvm_cmd.extend(['-net', 'tap,script=%s' % script])
target, port = incoming
kvm_cmd.extend(['-incoming', 'tcp:%s:%s' % (target, port)])
+ vnc_pwd_file = hvp[constants.HV_VNC_PASSWORD_FILE]
+ vnc_pwd = None
+ if vnc_pwd_file:
+ try:
+ vnc_pwd = utils.ReadFile(vnc_pwd_file)
+ except EnvironmentError, err:
+ raise errors.HypervisorError("Failed to open VNC password file %s: %s"
+ % (vnc_pwd_file, err))
+
result = utils.RunCmd(kvm_cmd)
if result.failed:
raise errors.HypervisorError("Failed to start instance %s: %s (%s)" %
result.output))
if not utils.IsProcessAlive(utils.ReadPidFile(pidfile)):
- raise errors.HypervisorError("Failed to start instance %s: %s" %
+ raise errors.HypervisorError("Failed to start instance %s" %
(instance.name))
+ if vnc_pwd:
+ change_cmd = 'change vnc password %s' % vnc_pwd
+ self._CallMonitorCommand(instance.name, change_cmd)
+
for filename in temp_files:
utils.RemoveFile(filename)
- def StartInstance(self, instance, block_devices, extra_args):
+ def StartInstance(self, instance, block_devices):
"""Start an instance.
"""
raise errors.HypervisorError("Failed to start instance %s: %s" %
(instance.name, "already running"))
- kvm_runtime = self._GenerateKVMRuntime(instance, block_devices, extra_args)
+ kvm_runtime = self._GenerateKVMRuntime(instance, block_devices)
self._SaveKVMRuntime(instance, kvm_runtime)
self._ExecuteKVMRuntime(instance, kvm_runtime)
if result.failed:
msg = ("Failed to send command '%s' to instance %s."
" output: %s, error: %s, fail_reason: %s" %
- (instance.name, result.stdout, result.stderr, result.fail_reason))
+ (command, instance_name,
+ result.stdout, result.stderr, result.fail_reason))
raise errors.HypervisorError(msg)
return result
- def _RetryInstancePowerdown(self, instance, pid, timeout=30):
- """Wait for an instance to power down.
-
- """
- # Wait up to $timeout seconds
- end = time.time() + timeout
- wait = 1
- while time.time() < end and utils.IsProcessAlive(pid):
- self._CallMonitorCommand(instance.name, 'system_powerdown')
- time.sleep(wait)
- # Make wait time longer for next try
- if wait < 5:
- wait *= 1.3
-
- def StopInstance(self, instance, force=False):
+ def StopInstance(self, instance, force=False, retry=False):
"""Stop an instance.
"""
if force or not instance.hvparams[constants.HV_ACPI]:
utils.KillProcess(pid)
else:
- self._RetryInstancePowerdown(instance, pid)
+ self._CallMonitorCommand(instance.name, 'system_powerdown')
if not utils.IsProcessAlive(pid):
- utils.RemoveFile(pidfile)
- utils.RemoveFile(self._InstanceMonitor(instance.name))
- utils.RemoveFile(self._InstanceSerial(instance.name))
- utils.RemoveFile(self._InstanceKVMRuntime(instance.name))
+ self._RemoveInstanceRuntimeFiles(pidfile, instance.name)
return True
else:
return False
# to shutdown and restart.
pidfile, pid, alive = self._InstancePidAlive(instance.name)
if not alive:
- raise errors.HypervisorError("Failed to reboot instance %s: not running" %
- (instance.name))
+ raise errors.HypervisorError("Failed to reboot instance %s:"
+ " not running" % instance.name)
# StopInstance will delete the saved KVM runtime so:
# ...first load it...
kvm_runtime = self._LoadKVMRuntime(instance)
"""
kvm_runtime = self._LoadKVMRuntime(instance, serialized_runtime=info)
- incoming_address = (target, constants.KVM_MIGRATION_PORT)
+ incoming_address = (target, instance.hvparams[constants.HV_MIGRATION_PORT])
self._ExecuteKVMRuntime(instance, kvm_runtime, incoming=incoming_address)
def FinalizeMigration(self, instance, info, success):
else:
self.StopInstance(instance, force=True)
- def MigrateInstance(self, instance_name, target, live):
+ 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_name: string
- @param instance_name: name of the instance to be migrated
+ @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
"""
+ instance_name = instance.name
+ port = instance.hvparams[constants.HV_MIGRATION_PORT]
pidfile, pid, alive = self._InstancePidAlive(instance_name)
if not alive:
raise errors.HypervisorError("Instance not running, cannot migrate")
+ if not utils.TcpPing(target, port, live_port_needed=True):
+ raise errors.HypervisorError("Remote host %s not listening on port"
+ " %s, cannot migrate" % (target, port))
+
if not live:
self._CallMonitorCommand(instance_name, 'stop')
- migrate_command = ('migrate -d tcp:%s:%s' %
- (target, constants.KVM_MIGRATION_PORT))
+ migrate_command = 'migrate -d tcp:%s:%s' % (target, port)
self._CallMonitorCommand(instance_name, migrate_command)
info_command = 'info migrate'
time.sleep(2)
utils.KillProcess(pid)
- utils.RemoveFile(pidfile)
- utils.RemoveFile(self._InstanceMonitor(instance_name))
- utils.RemoveFile(self._InstanceSerial(instance_name))
- utils.RemoveFile(self._InstanceKVMRuntime(instance_name))
+ self._RemoveInstanceRuntimeFiles(pidfile, instance_name)
def GetNodeInfo(self):
"""Return information about the node.
+ This is just a wrapper over the base GetLinuxNodeInfo method.
+
@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
- memory_dom0: the memory used by the node itself, if available
"""
- # global ram usage from the xm info command
- # memory : 3583
- # free_memory : 747
- # note: in xen 3, memory has changed to total_memory
- try:
- fh = file("/proc/meminfo")
- try:
- data = fh.readlines()
- finally:
- fh.close()
- except EnvironmentError, err:
- raise errors.HypervisorError("Failed to list node info: %s" % err)
-
- result = {}
- sum_free = 0
- for line in data:
- splitfields = line.split(":", 1)
-
- if len(splitfields) > 1:
- key = splitfields[0].strip()
- val = splitfields[1].strip()
- if key == 'MemTotal':
- result['memory_total'] = int(val.split()[0])/1024
- elif key in ('MemFree', 'Buffers', 'Cached'):
- sum_free += int(val.split()[0])/1024
- elif key == 'Active':
- result['memory_dom0'] = int(val.split()[0])/1024
- result['memory_free'] = sum_free
-
- cpu_total = 0
- try:
- fh = open("/proc/cpuinfo")
- try:
- cpu_total = len(re.findall("(?m)^processor\s*:\s*[0-9]+\s*$",
- fh.read()))
- finally:
- fh.close()
- except EnvironmentError, err:
- raise errors.HypervisorError("Failed to list node info: %s" % err)
- result['cpu_total'] = cpu_total
-
- return result
+ return self.GetLinuxNodeInfo()
@classmethod
def GetShellCommandForConsole(cls, instance, hvparams, beparams):
"""
if hvparams[constants.HV_SERIAL_CONSOLE]:
- # FIXME: The socat shell is not perfect. In particular the way we start
- # it ctrl+c will close it, rather than being passed to the other end.
- # On the other hand if we pass the option 'raw' (or ignbrk=1) there
- # will be no way of exiting socat (except killing it from another shell)
- # and ctrl+c doesn't work anyway, printing ^C rather than being
- # interpreted by kvm. For now we'll leave it this way, which at least
- # allows a minimal interaction and changes on the machine.
- shell_command = ("%s STDIO,echo=0,icanon=0 UNIX-CONNECT:%s" %
- (constants.SOCAT_PATH,
+ shell_command = ("%s STDIO,%s UNIX-CONNECT:%s" %
+ (constants.SOCAT_PATH, cls._SocatUnixConsoleParams(),
utils.ShellQuote(cls._InstanceSerial(instance.name))))
else:
shell_command = "echo 'No serial shell for instance %s'" % instance.name
vnc_bind_address = hvparams[constants.HV_VNC_BIND_ADDRESS]
if 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
vnc_command = ("echo 'Instance has VNC listening on %s:%d"
" (display: %d)'" % (vnc_bind_address,
instance.network_port,
def CheckParameterSyntax(cls, hvparams):
"""Check the given parameters for validity.
- For the KVM 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
kernel_path = hvparams[constants.HV_KERNEL_PATH]
if kernel_path:
- if not os.path.isabs(hvparams[constants.HV_KERNEL_PATH]):
- raise errors.HypervisorError("The kernel path must be an absolute path"
- ", if defined")
-
if not hvparams[constants.HV_ROOT_PATH]:
- raise errors.HypervisorError("Need a root partition for the instance"
- ", if a kernel is defined")
+ raise errors.HypervisorError("Need a root partition for the instance,"
+ " if a kernel is defined")
- 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")
-
- vnc_bind_address = hvparams[constants.HV_VNC_BIND_ADDRESS]
- if vnc_bind_address:
- if not utils.IsValidIP(vnc_bind_address):
- if not os.path.isabs(vnc_bind_address):
- raise errors.HypervisorError("The VNC bind address must be either"
- " a valid IP address or an absolute"
- " pathname. '%s' given" %
- vnc_bind_address)
-
- if hvparams[constants.HV_VNC_X509_VERIFY] and \
- not hvparams[constants.HV_VNC_X509]:
- raise errors.HypervisorError("%s must be defined, if %s is" %
- (constants.HV_VNC_X509,
- constants.HV_VNC_X509_VERIFY))
-
- if hvparams[constants.HV_VNC_X509]:
- if not os.path.isabs(hvparams[constants.HV_VNC_X509]):
- raise errors.HypervisorError("The vnc x509 path must an absolute path"
- ", if defined")
-
- 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 CDROM image must be"
- " an absolute path, if defined")
+ if (hvparams[constants.HV_VNC_X509_VERIFY] and
+ not hvparams[constants.HV_VNC_X509]):
+ raise errors.HypervisorError("%s must be defined, if %s is" %
+ (constants.HV_VNC_X509,
+ constants.HV_VNC_X509_VERIFY))
boot_order = hvparams[constants.HV_BOOT_ORDER]
- if boot_order not in ('cdrom', 'disk'):
- raise errors.HypervisorError("The boot order must be 'cdrom' or 'disk'")
- def ValidateParameters(self, hvparams):
- """Check the given parameters for validity.
+ if (boot_order == constants.HT_BO_CDROM and
+ not hvparams[constants.HV_CDROM_IMAGE_PATH]):
+ raise errors.HypervisorError("Cannot boot from cdrom without an"
+ " ISO path")
+ if (boot_order == constants.HT_BO_NETWORK and
+ hvparams[constants.HV_NIC_TYPE] == constants.HT_NIC_PARAVIRTUAL):
+ raise errors.HypervisorError("Cannot boot from a paravirtual NIC. Please"
+ " change the NIC type.")
- For the KVM hypervisor, this checks the existence of the
- kernel.
+ @classmethod
+ def PowercycleNode(cls):
+ """KVM powercycle, just a wrapper over Linux powercycle.
"""
- super(KVMHypervisor, self).ValidateParameters(hvparams)
-
- kernel_path = hvparams[constants.HV_KERNEL_PATH]
- if kernel_path and 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)
-
- vnc_bind_address = hvparams[constants.HV_VNC_BIND_ADDRESS]
- if vnc_bind_address and not utils.IsValidIP(vnc_bind_address) and \
- not os.path.isdir(vnc_bind_address):
- raise errors.HypervisorError("Instance vnc bind address must be either"
- " an ip address or an existing directory")
-
- vnc_x509 = hvparams[constants.HV_VNC_X509]
- if vnc_x509 and not os.path.isdir(vnc_x509):
- raise errors.HypervisorError("Instance vnc x509 path '%s' not found"
- " or not a directory" % vnc_x509)
-
- iso_path = hvparams[constants.HV_CDROM_IMAGE_PATH]
- if iso_path and not os.path.isfile(iso_path):
- raise errors.HypervisorError("Instance cdrom image '%s' not found or"
- " not a file" % iso_path)
-
-
+ cls.LinuxPowercycle()
projects / ganeti-local / blobdiff