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),
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+)',
"""
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
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(" /sbin/ip route replace $IP/32 table $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/32 dev $INTERFACE\n")
- interface_proxy_arp = "/proc/sys/net/ipv4/conf/$INTERFACE/proxy_arp"
- interface_forwarding = "/proc/sys/net/ipv4/conf/$INTERFACE/forwarding"
- script.write(" /bin/echo 1 > %s\n" % interface_proxy_arp)
- script.write(" /bin/echo 1 > %s\n" % interface_forwarding)
+ 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.
kvm_cmd.extend(['-usb'])
kvm_cmd.extend(['-usbdevice', mouse_type])
- # FIXME: handle vnc password
vnc_bind_address = hvp[constants.HV_VNC_BIND_ADDRESS]
if vnc_bind_address:
if utils.IsValidIP(vnc_bind_address):
elif hvp[constants.HV_VNC_X509]:
vnc_append = '%s,x509=%s' % (vnc_append,
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 hvp[constants.HV_SERIAL_CONSOLE]:
serial_dev = ('unix:%s,server,nowait' %
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
"""
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"))
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)
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):
self._RemoveInstanceRuntimeFiles(pidfile, instance.name)
# 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'
"""
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
projects / ganeti-local / blobdiff