"""
+# pylint: disable-msg=E1103
+
+# E1103: %s %r has no %r member (but some types could not be
+# inferred), because the _TryOSFromDisk returns either (True, os_obj)
+# or (False, "string") which confuses pylint
+
import os
import os.path
# and now start the master and rapi daemons
if start_daemons:
- daemons_params = {
- 'ganeti-masterd': [],
- 'ganeti-rapi': [],
- }
if no_voting:
- daemons_params['ganeti-masterd'].append('--no-voting')
- daemons_params['ganeti-masterd'].append('--yes-do-it')
- for daemon in daemons_params:
- cmd = [daemon]
- cmd.extend(daemons_params[daemon])
- result = utils.RunCmd(cmd)
- if result.failed:
- msg = "Can't start daemon %s: %s" % (daemon, result.output)
- logging.error(msg)
- err_msgs.append(msg)
+ masterd_args = "--no-voting --yes-do-it"
+ else:
+ masterd_args = ""
+
+ env = {
+ "EXTRA_MASTERD_ARGS": masterd_args,
+ }
+
+ result = utils.RunCmd([constants.DAEMON_UTIL, "start-master"], env=env)
+ if result.failed:
+ msg = "Can't start Ganeti master: %s" % result.output
+ logging.error(msg)
+ err_msgs.append(msg)
if err_msgs:
_Fail("; ".join(err_msgs))
# but otherwise ignore the failure
if stop_daemons:
- # stop/kill the rapi and the master daemon
- for daemon in constants.RAPI, constants.MASTERD:
- utils.KillProcess(utils.ReadPidFile(utils.DaemonPidFileName(daemon)))
+ result = utils.RunCmd([constants.DAEMON_UTIL, "stop-master"])
+ if result.failed:
+ logging.error("Could not stop Ganeti master, command %s had exitcode %s"
+ " and error %s",
+ result.cmd, result.exit_code, result.output)
def AddNode(dsa, dsapub, rsa, rsapub, sshkey, sshpub):
utils.AddAuthorizedKey(auth_keys, sshpub)
- utils.RunCmd([constants.SSH_INITD_SCRIPT, "restart"])
+ result = utils.RunCmd([constants.DAEMON_UTIL, "reload-ssh-keys"])
+ if result.failed:
+ _Fail("Unable to reload SSH keys (command %r, exit code %s, output %r)",
+ result.cmd, result.exit_code, result.output)
-def LeaveCluster():
+def LeaveCluster(modify_ssh_setup):
"""Cleans up and remove the current node.
This function cleans up and prepares the current node to be removed
L{errors.QuitGanetiException} which is used as a special case to
shutdown the node daemon.
+ @param modify_ssh_setup: boolean
+
"""
_CleanDirectory(constants.DATA_DIR)
JobQueuePurge()
- try:
- priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.GANETI_RUNAS)
+ if modify_ssh_setup:
+ try:
+ priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.GANETI_RUNAS)
- utils.RemoveAuthorizedKey(auth_keys, utils.ReadFile(pub_key))
+ utils.RemoveAuthorizedKey(auth_keys, utils.ReadFile(pub_key))
- utils.RemoveFile(priv_key)
- utils.RemoveFile(pub_key)
- except errors.OpExecError:
- logging.exception("Error while processing ssh files")
+ utils.RemoveFile(priv_key)
+ utils.RemoveFile(pub_key)
+ except errors.OpExecError:
+ logging.exception("Error while processing ssh files")
try:
utils.RemoveFile(constants.HMAC_CLUSTER_KEY)
utils.RemoveFile(constants.RAPI_CERT_FILE)
utils.RemoveFile(constants.SSL_CERT_FILE)
- except:
+ except: # pylint: disable-msg=W0702
logging.exception("Error while removing cluster secrets")
- confd_pid = utils.ReadPidFile(utils.DaemonPidFileName(constants.CONFD))
-
- if confd_pid:
- utils.KillProcess(confd_pid, timeout=2)
+ result = utils.RunCmd([constants.DAEMON_UTIL, "stop", constants.CONFD])
+ if result.failed:
+ logging.error("Command %s failed with exitcode %s and error %s",
+ result.cmd, result.exit_code, result.output)
# Raise a custom exception (handled in ganeti-noded)
raise errors.QuitGanetiException(True, 'Shutdown scheduled')
if constants.NV_VGLIST in what:
result[constants.NV_VGLIST] = utils.ListVolumeGroups()
+ if constants.NV_PVLIST in what:
+ result[constants.NV_PVLIST] = \
+ bdev.LogicalVolume.GetPVInfo(what[constants.NV_PVLIST],
+ filter_allocatable=False)
+
if constants.NV_VERSION in what:
result[constants.NV_VERSION] = (constants.PROTOCOL_VERSION,
constants.RELEASE_VERSION)
tmpr.append("The procfs filesystem doesn't seem to be mounted"
" under /proc, missing required directory /proc/sys and"
" the file /proc/sysrq-trigger")
+
+ if constants.NV_TIME in what:
+ result[constants.NV_TIME] = utils.SplitTime(time.time())
+
return result
missing.append(bridge)
if missing:
- _Fail("Missing bridges %s", ", ".join(missing))
+ _Fail("Missing bridges %s", utils.CommaJoin(missing))
def GetInstanceList(hypervisor_list):
return output
-def InstanceOsAdd(instance, reinstall):
+def InstanceOsAdd(instance, reinstall, debug):
"""Add an OS to an instance.
@type instance: L{objects.Instance}
@param instance: Instance whose OS is to be installed
@type reinstall: boolean
@param reinstall: whether this is an instance reinstall
+ @type debug: integer
+ @param debug: debug level, passed to the OS scripts
@rtype: None
"""
inst_os = OSFromDisk(instance.os)
- create_env = OSEnvironment(instance, inst_os)
+ create_env = OSEnvironment(instance, inst_os, debug)
if reinstall:
create_env['INSTANCE_REINSTALL'] = "1"
" log file:\n%s", result.fail_reason, "\n".join(lines), log=False)
-def RunRenameInstance(instance, old_name):
+def RunRenameInstance(instance, old_name, debug):
"""Run the OS rename script for an instance.
@type instance: L{objects.Instance}
@param instance: Instance whose OS is to be installed
@type old_name: string
@param old_name: previous instance name
+ @type debug: integer
+ @param debug: debug level, passed to the OS scripts
@rtype: boolean
@return: the success of the operation
"""
inst_os = OSFromDisk(instance.os)
- rename_env = OSEnvironment(instance, inst_os)
+ rename_env = OSEnvironment(instance, inst_os, debug)
rename_env['OLD_INSTANCE_NAME'] = old_name
logfile = "%s/rename-%s-%s-%s-%d.log" % (constants.LOG_OS_DIR, instance.os,
"vg_free": int(round(float(valarr[1]), 0)),
"pv_count": int(valarr[2]),
}
- except ValueError, err:
+ except (TypeError, ValueError), err:
logging.exception("Fail to parse vgs output: %s", err)
else:
logging.error("vgs output has the wrong number of fields (expected"
"""
hv_name = instance.hypervisor
hyper = hypervisor.GetHypervisor(hv_name)
- running_instances = hyper.ListInstances()
iname = instance.name
- if iname not in running_instances:
+ if instance.name not in hyper.ListInstances():
logging.info("Instance %s not running, doing nothing", iname)
return
- start = time.time()
- end = start + timeout
- sleep_time = 1
+ class _TryShutdown:
+ def __init__(self):
+ self.tried_once = False
- tried_once = False
- while not tried_once and time.time() < end:
- try:
- hyper.StopInstance(instance, retry=tried_once)
- except errors.HypervisorError, err:
- _Fail("Failed to stop instance %s: %s", iname, err)
- tried_once = True
- time.sleep(sleep_time)
- if instance.name not in hyper.ListInstances():
- break
- if sleep_time < 5:
- # 1.2 behaves particularly good for our case:
- # it gives us 10 increasing steps and caps just slightly above 5 seconds
- sleep_time *= 1.2
- else:
+ def __call__(self):
+ if iname not in hyper.ListInstances():
+ return
+
+ try:
+ hyper.StopInstance(instance, retry=self.tried_once)
+ except errors.HypervisorError, err:
+ if iname not in hyper.ListInstances():
+ # if the instance is no longer existing, consider this a
+ # success and go to cleanup
+ return
+
+ _Fail("Failed to stop instance %s: %s", iname, err)
+
+ self.tried_once = True
+
+ raise utils.RetryAgain()
+
+ try:
+ utils.Retry(_TryShutdown(), 5, timeout)
+ except utils.RetryTimeout:
# the shutdown did not succeed
logging.error("Shutdown of '%s' unsuccessful, forcing", iname)
try:
hyper.StopInstance(instance, force=True)
except errors.HypervisorError, err:
- _Fail("Failed to force stop instance %s: %s", iname, err)
+ if iname in hyper.ListInstances():
+ # only raise an error if the instance still exists, otherwise
+ # the error could simply be "instance ... unknown"!
+ _Fail("Failed to force stop instance %s: %s", iname, err)
time.sleep(1)
- if instance.name in GetInstanceList([hv_name]):
+
+ if iname in hyper.ListInstances():
_Fail("Could not shutdown instance %s even by destroy", iname)
_RemoveBlockDevLinks(iname, instance.disks)
not accepted here, since that mode is handled differently, in
cmdlib, and translates into full stop and start of the
instance (instead of a call_instance_reboot RPC)
- @type timeout: integer
- @param timeout: maximum timeout for soft shutdown
+ @type shutdown_timeout: integer
+ @param shutdown_timeout: maximum timeout for soft shutdown
@rtype: None
"""
hyper = hypervisor.GetHypervisor(instance.hypervisor)
try:
- hyper.MigrateInstance(instance.name, target, live)
+ hyper.MigrateInstance(instance, target, live)
except errors.HypervisorError, err:
_Fail("Failed to migrate instance: %s", err, exc=True)
it's not required to return anything.
"""
+ # TODO: remove the obsolete 'size' argument
+ # pylint: disable-msg=W0613
clist = []
if disk.children:
for child in disk.children:
# we need the children open in case the device itself has to
# be assembled
try:
+ # pylint: disable-msg=E1103
crdev.Open()
except errors.BlockDeviceError, err:
_Fail("Can't make child '%s' read-write: %s", child, err)
try:
result = _RecursiveAssembleBD(disk, owner, as_primary)
if isinstance(result, bdev.BlockDev):
+ # pylint: disable-msg=E1103
result = result.dev_path
except errors.BlockDeviceError, err:
_Fail("Error while assembling disk: %s", err, exc=True)
for cf in disks:
try:
rbd = _RecursiveFindBD(cf)
- except errors.BlockDeviceError, err:
+ except errors.BlockDeviceError:
result.append(None)
continue
if rbd is None:
return detail
-def _OSOndiskAPIVersion(name, os_dir):
+def _OSOndiskAPIVersion(os_dir):
"""Compute and return the API version of a given OS.
- This function will try to read the API version of the OS given by
- the 'name' parameter and residing in the 'os_dir' directory.
+ This function will try to read the API version of the OS residing in
+ the 'os_dir' directory.
- @type name: str
- @param name: the OS name we should look for
@type os_dir: str
- @param os_dir: the directory inwhich we should look for the OS
+ @param os_dir: the directory in which we should look for the OS
@rtype: tuple
@return: tuple (status, data) with status denoting the validity and
data holding either the vaid versions or an error message
"""
if base_dir is None:
os_dir = utils.FindFile(name, constants.OS_SEARCH_PATH, os.path.isdir)
- if os_dir is None:
- return False, "Directory for OS %s not found in search path" % name
else:
- os_dir = os.path.sep.join([base_dir, name])
+ os_dir = utils.FindFile(name, [base_dir], os.path.isdir)
- status, api_versions = _OSOndiskAPIVersion(name, os_dir)
+ if os_dir is None:
+ return False, "Directory for OS %s not found in search path" % name
+
+ status, api_versions = _OSOndiskAPIVersion(os_dir)
if not status:
# push the error up
return status, api_versions
if max(api_versions) >= constants.OS_API_V15:
os_files[constants.OS_VARIANTS_FILE] = ''
- for name in os_files:
- os_files[name] = os.path.sep.join([os_dir, name])
+ for filename in os_files:
+ os_files[filename] = os.path.sep.join([os_dir, filename])
try:
- st = os.stat(os_files[name])
+ st = os.stat(os_files[filename])
except EnvironmentError, err:
return False, ("File '%s' under path '%s' is missing (%s)" %
- (name, os_dir, _ErrnoOrStr(err)))
+ (filename, os_dir, _ErrnoOrStr(err)))
if not stat.S_ISREG(stat.S_IFMT(st.st_mode)):
return False, ("File '%s' under path '%s' is not a regular file" %
- (name, os_dir))
+ (filename, os_dir))
- if name in constants.OS_SCRIPTS:
+ if filename in constants.OS_SCRIPTS:
if stat.S_IMODE(st.st_mode) & stat.S_IXUSR != stat.S_IXUSR:
return False, ("File '%s' under path '%s' is not executable" %
- (name, os_dir))
+ (filename, os_dir))
variants = None
if constants.OS_VARIANTS_FILE in os_files:
return payload
-def OSEnvironment(instance, os, debug=0):
+def OSEnvironment(instance, inst_os, debug=0):
"""Calculate the environment for an os script.
@type instance: L{objects.Instance}
@param instance: target instance for the os script run
- @type os: L{objects.OS}
- @param os: operating system for which the environment is being built
+ @type inst_os: L{objects.OS}
+ @param inst_os: operating system for which the environment is being built
@type debug: integer
@param debug: debug level (0 or 1, for OS Api 10)
@rtype: dict
"""
result = {}
- api_version = max(constants.OS_API_VERSIONS.intersection(os.api_versions))
+ api_version = \
+ max(constants.OS_API_VERSIONS.intersection(inst_os.api_versions))
result['OS_API_VERSION'] = '%d' % api_version
result['INSTANCE_NAME'] = instance.name
result['INSTANCE_OS'] = instance.os
try:
variant = instance.os.split('+', 1)[1]
except IndexError:
- variant = os.supported_variants[0]
+ variant = inst_os.supported_variants[0]
result['OS_VARIANT'] = variant
for idx, disk in enumerate(instance.disks):
real_disk = _RecursiveFindBD(disk)
@return: snapshot disk path
"""
- if disk.children:
- if len(disk.children) == 1:
- # only one child, let's recurse on it
- return BlockdevSnapshot(disk.children[0])
- else:
- # more than one child, choose one that matches
- for child in disk.children:
- if child.size == disk.size:
- # return implies breaking the loop
- return BlockdevSnapshot(child)
+ if disk.dev_type == constants.LD_DRBD8:
+ if not disk.children:
+ _Fail("DRBD device '%s' without backing storage cannot be snapshotted",
+ disk.unique_id)
+ return BlockdevSnapshot(disk.children[0])
elif disk.dev_type == constants.LD_LV:
r_dev = _RecursiveFindBD(disk)
if r_dev is not None:
+ # FIXME: choose a saner value for the snapshot size
# let's stay on the safe side and ask for the full size, for now
return r_dev.Snapshot(disk.size)
else:
disk.unique_id, disk.dev_type)
-def ExportSnapshot(disk, dest_node, instance, cluster_name, idx):
+def ExportSnapshot(disk, dest_node, instance, cluster_name, idx, debug):
"""Export a block device snapshot to a remote node.
@type disk: L{objects.Disk}
@type idx: int
@param idx: the index of the disk in the instance's disk list,
used to export to the OS scripts environment
+ @type debug: integer
+ @param debug: debug level, passed to the OS scripts
@rtype: None
"""
inst_os = OSFromDisk(instance.os)
- export_env = OSEnvironment(instance, inst_os)
+ export_env = OSEnvironment(instance, inst_os, debug)
export_script = inst_os.export_script
return config.Dumps()
-def ImportOSIntoInstance(instance, src_node, src_images, cluster_name):
+def ImportOSIntoInstance(instance, src_node, src_images, cluster_name, debug):
"""Import an os image into an instance.
@type instance: L{objects.Instance}
@param src_node: source node for the disk images
@type src_images: list of string
@param src_images: absolute paths of the disk images
+ @type debug: integer
+ @param debug: debug level, passed to the OS scripts
@rtype: list of boolean
@return: each boolean represent the success of importing the n-th disk
"""
inst_os = OSFromDisk(instance.os)
- import_env = OSEnvironment(instance, inst_os)
+ import_env = OSEnvironment(instance, inst_os, debug)
import_script = inst_os.import_script
logfile = "%s/import-%s-%s-%s.log" % (constants.LOG_OS_DIR, instance.os,
master, myself = ssconf.GetMasterAndMyself()
if master == myself:
_Fail("ssconf status shows I'm the master node, will not demote")
- pid_file = utils.DaemonPidFileName(constants.MASTERD)
- if utils.IsProcessAlive(utils.ReadPidFile(pid_file)):
+
+ result = utils.RunCmd([constants.DAEMON_UTIL, "check", constants.MASTERD])
+ if not result.failed:
_Fail("The master daemon is running, will not demote")
+
try:
if os.path.isfile(constants.CLUSTER_CONF_FILE):
utils.CreateBackup(constants.CLUSTER_CONF_FILE)
except EnvironmentError, err:
if err.errno != errno.ENOENT:
_Fail("Error while backing up cluster file: %s", err, exc=True)
+
utils.RemoveFile(constants.CLUSTER_CONF_FILE)
rd.AttachNet(multimaster)
except errors.BlockDeviceError, err:
_Fail("Can't change network configuration: %s", err)
+
# wait until the disks are connected; we need to retry the re-attach
# if the device becomes standalone, as this might happen if the one
# node disconnects and reconnects in a different mode before the
# other node reconnects; in this case, one or both of the nodes will
# decide it has wrong configuration and switch to standalone
- RECONNECT_TIMEOUT = 2 * 60
- sleep_time = 0.100 # start with 100 miliseconds
- timeout_limit = time.time() + RECONNECT_TIMEOUT
- while time.time() < timeout_limit:
+
+ def _Attach():
all_connected = True
+
for rd in bdevs:
stats = rd.GetProcStatus()
- if not (stats.is_connected or stats.is_in_resync):
- all_connected = False
+
+ all_connected = (all_connected and
+ (stats.is_connected or stats.is_in_resync))
+
if stats.is_standalone:
# peer had different config info and this node became
# standalone, even though this should not happen with the
rd.AttachNet(multimaster)
except errors.BlockDeviceError, err:
_Fail("Can't change network configuration: %s", err)
- if all_connected:
- break
- time.sleep(sleep_time)
- sleep_time = min(5, sleep_time * 1.5)
- if not all_connected:
+
+ if not all_connected:
+ raise utils.RetryAgain()
+
+ try:
+ # Start with a delay of 100 miliseconds and go up to 5 seconds
+ utils.Retry(_Attach, (0.1, 1.5, 5.0), 2 * 60)
+ except utils.RetryTimeout:
_Fail("Timeout in disk reconnecting")
+
if multimaster:
# change to primary mode
for rd in bdevs:
"""Wait until DRBDs have synchronized.
"""
+ def _helper(rd):
+ stats = rd.GetProcStatus()
+ if not (stats.is_connected or stats.is_in_resync):
+ raise utils.RetryAgain()
+ return stats
+
bdevs = _FindDisks(nodes_ip, disks)
min_resync = 100
alldone = True
for rd in bdevs:
- stats = rd.GetProcStatus()
- if not (stats.is_connected or stats.is_in_resync):
- _Fail("DRBD device %s is not in sync: stats=%s", rd, stats)
+ try:
+ # poll each second for 15 seconds
+ stats = utils.Retry(_helper, 1, 15, args=[rd])
+ except utils.RetryTimeout:
+ stats = rd.GetProcStatus()
+ # last check
+ if not (stats.is_connected or stats.is_in_resync):
+ _Fail("DRBD device %s is not in sync: stats=%s", rd, stats)
alldone = alldone and (not stats.is_in_resync)
if stats.sync_percent is not None:
min_resync = min(min_resync, stats.sync_percent)
on the master side.
"""
- RE_MASK = re.compile("^[a-zA-Z0-9_-]+$")
-
def __init__(self, hooks_base_dir=None):
"""Constructor for hooks runner.
"""
if hooks_base_dir is None:
hooks_base_dir = constants.HOOKS_BASE_DIR
- self._BASE_DIR = hooks_base_dir
+ # yeah, _BASE_DIR is not valid for attributes, we use it like a
+ # constant
+ self._BASE_DIR = hooks_base_dir # pylint: disable-msg=C0103
@staticmethod
def ExecHook(script, env):
for relname in dir_contents:
fname = os.path.join(dir_name, relname)
if not (os.path.isfile(fname) and os.access(fname, os.X_OK) and
- self.RE_MASK.match(relname) is not None):
+ constants.EXT_PLUGIN_MASK.match(relname) is not None):
rrval = constants.HKR_SKIP
output = ""
else:
the master side.
"""
- def Run(self, name, idata):
+ @staticmethod
+ def Run(name, idata):
"""Run an iallocator script.
@type name: str
projects / ganeti-local / blobdiff