#
#
-# Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Google Inc.
+# Copyright (C) 2006, 2007, 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
from ganeti import ssh
from ganeti import hypervisor
from ganeti import constants
-from ganeti import bdev
+from ganeti.storage import bdev
+from ganeti.storage import drbd
+from ganeti.storage import filestorage
from ganeti import objects
from ganeti import ssconf
from ganeti import serializer
from ganeti import netutils
from ganeti import runtime
-from ganeti import mcpu
from ganeti import compat
from ganeti import pathutils
from ganeti import vcluster
+from ganeti import ht
+from ganeti.storage.base import BlockDev
+from ganeti.storage.drbd import DRBD8
+from ganeti import hooksmaster
_BOOT_ID_PATH = "/proc/sys/kernel/random/boot_id"
-_ALLOWED_CLEAN_DIRS = frozenset([
+_ALLOWED_CLEAN_DIRS = compat.UniqueFrozenset([
pathutils.DATA_DIR,
pathutils.JOB_QUEUE_ARCHIVE_DIR,
pathutils.QUEUE_DIR,
_MASTER_START = "start"
_MASTER_STOP = "stop"
+#: Maximum file permissions for restricted command directory and executables
+_RCMD_MAX_MODE = (stat.S_IRWXU |
+ stat.S_IRGRP | stat.S_IXGRP |
+ stat.S_IROTH | stat.S_IXOTH)
+
+#: Delay before returning an error for restricted commands
+_RCMD_INVALID_DELAY = 10
+
+#: How long to wait to acquire lock for restricted commands (shorter than
+#: L{_RCMD_INVALID_DELAY}) to reduce blockage of noded forks when many
+#: command requests arrive
+_RCMD_LOCK_TIMEOUT = _RCMD_INVALID_DELAY * 0.8
+
class RPCFail(Exception):
"""Class denoting RPC failure.
"""
+def _GetInstReasonFilename(instance_name):
+ """Path of the file containing the reason of the instance status change.
+
+ @type instance_name: string
+ @param instance_name: The name of the instance
+ @rtype: string
+ @return: The path of the file
+
+ """
+ return utils.PathJoin(pathutils.INSTANCE_REASON_DIR, instance_name)
+
+
+def _StoreInstReasonTrail(instance_name, trail):
+ """Serialize a reason trail related to an instance change of state to file.
+
+ The exact location of the file depends on the name of the instance and on
+ the configuration of the Ganeti cluster defined at deploy time.
+
+ @type instance_name: string
+ @param instance_name: The name of the instance
+ @rtype: None
+
+ """
+ json = serializer.DumpJson(trail)
+ filename = _GetInstReasonFilename(instance_name)
+ utils.WriteFile(filename, data=json)
+
+
def _Fail(msg, *args, **kwargs):
"""Log an error and the raise an RPCFail exception.
"""
allowed_files = set([
pathutils.CLUSTER_CONF_FILE,
- constants.ETC_HOSTS,
+ pathutils.ETC_HOSTS,
pathutils.SSH_KNOWN_HOSTS_FILE,
pathutils.VNC_PASSWORD_FILE,
pathutils.RAPI_CERT_FILE,
hv_class = hypervisor.GetHypervisorClass(hv_name)
allowed_files.update(hv_class.GetAncillaryFiles()[0])
+ assert pathutils.FILE_STORAGE_PATHS_FILE not in allowed_files, \
+ "Allowed file storage paths should never be uploaded via RPC"
+
return frozenset(allowed_files)
cfg = _GetConfig()
hr = HooksRunner()
- hm = mcpu.HooksMaster(hook_opcode, hooks_path, nodes, hr.RunLocalHooks,
- None, env_fn, logging.warning, cfg.GetClusterName(),
- cfg.GetMasterNode())
-
+ hm = hooksmaster.HooksMaster(hook_opcode, hooks_path, nodes,
+ hr.RunLocalHooks, None, env_fn,
+ logging.warning, cfg.GetClusterName(),
+ cfg.GetMasterNode())
hm.RunPhase(constants.HOOKS_PHASE_PRE)
result = fn(*args, **kwargs)
hm.RunPhase(constants.HOOKS_PHASE_POST)
result = utils.RunCmd([setup_script, action], env=env, reset_env=True)
if result.failed:
- _Fail("Failed to %s the master IP. Script return value: %s" %
- (action, result.exit_code), log=True)
+ _Fail("Failed to %s the master IP. Script return value: %s, output: '%s'" %
+ (action, result.exit_code, result.output), log=True)
@RunLocalHooks(constants.FAKE_OP_MASTER_TURNUP, "master-ip-turnup",
if modify_ssh_setup:
try:
- priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.GANETI_RUNAS)
+ priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.SSH_LOGIN_USER)
utils.RemoveAuthorizedKey(auth_keys, utils.ReadFile(pub_key))
raise errors.QuitGanetiException(True, "Shutdown scheduled")
-def _GetVgInfo(name):
+def _CheckStorageParams(params, num_params):
+ """Performs sanity checks for storage parameters.
+
+ @type params: list
+ @param params: list of storage parameters
+ @type num_params: int
+ @param num_params: expected number of parameters
+
+ """
+ if params is None:
+ raise errors.ProgrammerError("No storage parameters for storage"
+ " reporting is provided.")
+ if not isinstance(params, list):
+ raise errors.ProgrammerError("The storage parameters are not of type"
+ " list: '%s'" % params)
+ if not len(params) == num_params:
+ raise errors.ProgrammerError("Did not receive the expected number of"
+ "storage parameters: expected %s,"
+ " received '%s'" % (num_params, len(params)))
+
+
+def _CheckLvmStorageParams(params):
+ """Performs sanity check for the 'exclusive storage' flag.
+
+ @see: C{_CheckStorageParams}
+
+ """
+ _CheckStorageParams(params, 1)
+ excl_stor = params[0]
+ if not isinstance(params[0], bool):
+ raise errors.ProgrammerError("Exclusive storage parameter is not"
+ " boolean: '%s'." % excl_stor)
+ return excl_stor
+
+
+def _GetLvmVgSpaceInfo(name, params):
+ """Wrapper around C{_GetVgInfo} which checks the storage parameters.
+
+ @type name: string
+ @param name: name of the volume group
+ @type params: list
+ @param params: list of storage parameters, which in this case should be
+ containing only one for exclusive storage
+
+ """
+ excl_stor = _CheckLvmStorageParams(params)
+ return _GetVgInfo(name, excl_stor)
+
+
+def _GetVgInfo(
+ name, excl_stor, info_fn=bdev.LogicalVolume.GetVGInfo):
"""Retrieves information about a LVM volume group.
"""
# TODO: GetVGInfo supports returning information for multiple VGs at once
- vginfo = bdev.LogicalVolume.GetVGInfo([name])
+ vginfo = info_fn([name], excl_stor)
if vginfo:
vg_free = int(round(vginfo[0][0], 0))
vg_size = int(round(vginfo[0][1], 0))
vg_size = None
return {
+ "type": constants.ST_LVM_VG,
"name": name,
- "vg_free": vg_free,
- "vg_size": vg_size,
+ "storage_free": vg_free,
+ "storage_size": vg_size,
}
-def _GetHvInfo(name):
+def _GetLvmPvSpaceInfo(name, params):
+ """Wrapper around C{_GetVgSpindlesInfo} with sanity checks.
+
+ @see: C{_GetLvmVgSpaceInfo}
+
+ """
+ excl_stor = _CheckLvmStorageParams(params)
+ return _GetVgSpindlesInfo(name, excl_stor)
+
+
+def _GetVgSpindlesInfo(
+ name, excl_stor, info_fn=bdev.LogicalVolume.GetVgSpindlesInfo):
+ """Retrieves information about spindles in an LVM volume group.
+
+ @type name: string
+ @param name: VG name
+ @type excl_stor: bool
+ @param excl_stor: exclusive storage
+ @rtype: dict
+ @return: dictionary whose keys are "name", "vg_free", "vg_size" for VG name,
+ free spindles, total spindles respectively
+
+ """
+ if excl_stor:
+ (vg_free, vg_size) = info_fn(name)
+ else:
+ vg_free = 0
+ vg_size = 0
+ return {
+ "type": constants.ST_LVM_PV,
+ "name": name,
+ "storage_free": vg_free,
+ "storage_size": vg_size,
+ }
+
+
+def _GetHvInfo(name, hvparams, get_hv_fn=hypervisor.GetHypervisor):
"""Retrieves node information from a hypervisor.
The information returned depends on the hypervisor. Common items:
- memory_total is the total number of ram in MiB
- hv_version: the hypervisor version, if available
+ @type hvparams: dict of string
+ @param hvparams: the hypervisor's hvparams
+
"""
- return hypervisor.GetHypervisor(name).GetNodeInfo()
+ return get_hv_fn(name).GetNodeInfo(hvparams=hvparams)
+
+
+def _GetHvInfoAll(hv_specs, get_hv_fn=hypervisor.GetHypervisor):
+ """Retrieves node information for all hypervisors.
+
+ See C{_GetHvInfo} for information on the output.
+
+ @type hv_specs: list of pairs (string, dict of strings)
+ @param hv_specs: list of pairs of a hypervisor's name and its hvparams
+
+ """
+ if hv_specs is None:
+ return None
+
+ result = []
+ for hvname, hvparams in hv_specs:
+ result.append(_GetHvInfo(hvname, hvparams, get_hv_fn))
+ return result
def _GetNamedNodeInfo(names, fn):
return map(fn, names)
-def GetNodeInfo(vg_names, hv_names):
+def GetNodeInfo(storage_units, hv_specs):
"""Gives back a hash with different information about the node.
- @type vg_names: list of string
- @param vg_names: Names of the volume groups to ask for disk space information
- @type hv_names: list of string
- @param hv_names: Names of the hypervisors to ask for node information
+ @type storage_units: list of tuples (string, string, list)
+ @param storage_units: List of tuples (storage unit, identifier, parameters) to
+ ask for disk space information. In case of lvm-vg, the identifier is
+ the VG name. The parameters can contain additional, storage-type-specific
+ parameters, for example exclusive storage for lvm storage.
+ @type hv_specs: list of pairs (string, dict of strings)
+ @param hv_specs: list of pairs of a hypervisor's name and its hvparams
@rtype: tuple; (string, None/dict, None/dict)
@return: Tuple containing boot ID, volume group information and hypervisor
information
"""
bootid = utils.ReadFile(_BOOT_ID_PATH, size=128).rstrip("\n")
- vg_info = _GetNamedNodeInfo(vg_names, _GetVgInfo)
- hv_info = _GetNamedNodeInfo(hv_names, _GetHvInfo)
+ storage_info = _GetNamedNodeInfo(
+ storage_units,
+ (lambda (storage_type, storage_key, storage_params):
+ _ApplyStorageInfoFunction(storage_type, storage_key, storage_params)))
+ hv_info = _GetHvInfoAll(hv_specs)
+ return (bootid, storage_info, hv_info)
+
+
+def _GetFileStorageSpaceInfo(path, params):
+ """Wrapper around filestorage.GetSpaceInfo.
+
+ The purpose of this wrapper is to call filestorage.GetFileStorageSpaceInfo
+ and ignore the *args parameter to not leak it into the filestorage
+ module's code.
+
+ @see: C{filestorage.GetFileStorageSpaceInfo} for description of the
+ parameters.
+
+ """
+ _CheckStorageParams(params, 0)
+ return filestorage.GetFileStorageSpaceInfo(path)
+
+
+# FIXME: implement storage reporting for all missing storage types.
+_STORAGE_TYPE_INFO_FN = {
+ constants.ST_BLOCK: None,
+ constants.ST_DISKLESS: None,
+ constants.ST_EXT: None,
+ constants.ST_FILE: _GetFileStorageSpaceInfo,
+ constants.ST_LVM_PV: _GetLvmPvSpaceInfo,
+ constants.ST_LVM_VG: _GetLvmVgSpaceInfo,
+ constants.ST_RADOS: None,
+}
+
+
+def _ApplyStorageInfoFunction(storage_type, storage_key, *args):
+ """Looks up and applies the correct function to calculate free and total
+ storage for the given storage type.
+
+ @type storage_type: string
+ @param storage_type: the storage type for which the storage shall be reported.
+ @type storage_key: string
+ @param storage_key: identifier of a storage unit, e.g. the volume group name
+ of an LVM storage unit
+ @type args: any
+ @param args: various parameters that can be used for storage reporting. These
+ parameters and their semantics vary from storage type to storage type and
+ are just propagated in this function.
+ @return: the results of the application of the storage space function (see
+ _STORAGE_TYPE_INFO_FN) if storage space reporting is implemented for that
+ storage type
+ @raises NotImplementedError: for storage types who don't support space
+ reporting yet
+ """
+ fn = _STORAGE_TYPE_INFO_FN[storage_type]
+ if fn is not None:
+ return fn(storage_key, *args)
+ else:
+ raise NotImplementedError
+
+
+def _CheckExclusivePvs(pvi_list):
+ """Check that PVs are not shared among LVs
+
+ @type pvi_list: list of L{objects.LvmPvInfo} objects
+ @param pvi_list: information about the PVs
+
+ @rtype: list of tuples (string, list of strings)
+ @return: offending volumes, as tuples: (pv_name, [lv1_name, lv2_name...])
+
+ """
+ res = []
+ for pvi in pvi_list:
+ if len(pvi.lv_list) > 1:
+ res.append((pvi.name, pvi.lv_list))
+ return res
- return (bootid, vg_info, hv_info)
+def _VerifyHypervisors(what, vm_capable, result, all_hvparams,
+ get_hv_fn=hypervisor.GetHypervisor):
+ """Verifies the hypervisor. Appends the results to the 'results' list.
-def VerifyNode(what, cluster_name):
+ @type what: C{dict}
+ @param what: a dictionary of things to check
+ @type vm_capable: boolean
+ @param vm_capable: whether or not this node is vm capable
+ @type result: dict
+ @param result: dictionary of verification results; results of the
+ verifications in this function will be added here
+ @type all_hvparams: dict of dict of string
+ @param all_hvparams: dictionary mapping hypervisor names to hvparams
+ @type get_hv_fn: function
+ @param get_hv_fn: function to retrieve the hypervisor, to improve testability
+
+ """
+ if not vm_capable:
+ return
+
+ if constants.NV_HYPERVISOR in what:
+ result[constants.NV_HYPERVISOR] = {}
+ for hv_name in what[constants.NV_HYPERVISOR]:
+ hvparams = all_hvparams[hv_name]
+ try:
+ val = get_hv_fn(hv_name).Verify(hvparams=hvparams)
+ except errors.HypervisorError, err:
+ val = "Error while checking hypervisor: %s" % str(err)
+ result[constants.NV_HYPERVISOR][hv_name] = val
+
+
+def _VerifyHvparams(what, vm_capable, result,
+ get_hv_fn=hypervisor.GetHypervisor):
+ """Verifies the hvparams. Appends the results to the 'results' list.
+
+ @type what: C{dict}
+ @param what: a dictionary of things to check
+ @type vm_capable: boolean
+ @param vm_capable: whether or not this node is vm capable
+ @type result: dict
+ @param result: dictionary of verification results; results of the
+ verifications in this function will be added here
+ @type get_hv_fn: function
+ @param get_hv_fn: function to retrieve the hypervisor, to improve testability
+
+ """
+ if not vm_capable:
+ return
+
+ if constants.NV_HVPARAMS in what:
+ result[constants.NV_HVPARAMS] = []
+ for source, hv_name, hvparms in what[constants.NV_HVPARAMS]:
+ try:
+ logging.info("Validating hv %s, %s", hv_name, hvparms)
+ get_hv_fn(hv_name).ValidateParameters(hvparms)
+ except errors.HypervisorError, err:
+ result[constants.NV_HVPARAMS].append((source, hv_name, str(err)))
+
+
+def _VerifyInstanceList(what, vm_capable, result, all_hvparams):
+ """Verifies the instance list.
+
+ @type what: C{dict}
+ @param what: a dictionary of things to check
+ @type vm_capable: boolean
+ @param vm_capable: whether or not this node is vm capable
+ @type result: dict
+ @param result: dictionary of verification results; results of the
+ verifications in this function will be added here
+ @type all_hvparams: dict of dict of string
+ @param all_hvparams: dictionary mapping hypervisor names to hvparams
+
+ """
+ if constants.NV_INSTANCELIST in what and vm_capable:
+ # GetInstanceList can fail
+ try:
+ val = GetInstanceList(what[constants.NV_INSTANCELIST],
+ all_hvparams=all_hvparams)
+ except RPCFail, err:
+ val = str(err)
+ result[constants.NV_INSTANCELIST] = val
+
+
+def _VerifyNodeInfo(what, vm_capable, result, all_hvparams):
+ """Verifies the node info.
+
+ @type what: C{dict}
+ @param what: a dictionary of things to check
+ @type vm_capable: boolean
+ @param vm_capable: whether or not this node is vm capable
+ @type result: dict
+ @param result: dictionary of verification results; results of the
+ verifications in this function will be added here
+ @type all_hvparams: dict of dict of string
+ @param all_hvparams: dictionary mapping hypervisor names to hvparams
+
+ """
+ if constants.NV_HVINFO in what and vm_capable:
+ hvname = what[constants.NV_HVINFO]
+ hyper = hypervisor.GetHypervisor(hvname)
+ hvparams = all_hvparams[hvname]
+ result[constants.NV_HVINFO] = hyper.GetNodeInfo(hvparams=hvparams)
+
+
+def VerifyNode(what, cluster_name, all_hvparams):
"""Verify the status of the local node.
Based on the input L{what} parameter, various checks are done on the
- node-net-test: list of nodes we should check node daemon port
connectivity with
- hypervisor: list with hypervisors to run the verify for
+ @type cluster_name: string
+ @param cluster_name: the cluster's name
+ @type all_hvparams: dict of dict of strings
+ @param all_hvparams: a dictionary mapping hypervisor names to hvparams
@rtype: dict
@return: a dictionary with the same keys as the input dict, and
values representing the result of the checks
port = netutils.GetDaemonPort(constants.NODED)
vm_capable = my_name not in what.get(constants.NV_VMNODES, [])
- if constants.NV_HYPERVISOR in what and vm_capable:
- result[constants.NV_HYPERVISOR] = tmp = {}
- for hv_name in what[constants.NV_HYPERVISOR]:
- try:
- val = hypervisor.GetHypervisor(hv_name).Verify()
- except errors.HypervisorError, err:
- val = "Error while checking hypervisor: %s" % str(err)
- tmp[hv_name] = val
-
- if constants.NV_HVPARAMS in what and vm_capable:
- result[constants.NV_HVPARAMS] = tmp = []
- for source, hv_name, hvparms in what[constants.NV_HVPARAMS]:
- try:
- logging.info("Validating hv %s, %s", hv_name, hvparms)
- hypervisor.GetHypervisor(hv_name).ValidateParameters(hvparms)
- except errors.HypervisorError, err:
- tmp.append((source, hv_name, str(err)))
+ _VerifyHypervisors(what, vm_capable, result, all_hvparams)
+ _VerifyHvparams(what, vm_capable, result)
if constants.NV_FILELIST in what:
- result[constants.NV_FILELIST] = utils.FingerprintFiles(
- what[constants.NV_FILELIST])
+ fingerprints = utils.FingerprintFiles(map(vcluster.LocalizeVirtualPath,
+ what[constants.NV_FILELIST]))
+ result[constants.NV_FILELIST] = \
+ dict((vcluster.MakeVirtualPath(key), value)
+ for (key, value) in fingerprints.items())
if constants.NV_NODELIST in what:
(nodes, bynode) = what[constants.NV_NODELIST]
if constants.NV_USERSCRIPTS in what:
result[constants.NV_USERSCRIPTS] = \
[script for script in what[constants.NV_USERSCRIPTS]
- if not (os.path.exists(script) and os.access(script, os.X_OK))]
+ if not utils.IsExecutable(script)]
if constants.NV_OOB_PATHS in what:
result[constants.NV_OOB_PATHS] = tmp = []
val = str(err)
result[constants.NV_LVLIST] = val
- if constants.NV_INSTANCELIST in what and vm_capable:
- # GetInstanceList can fail
- try:
- val = GetInstanceList(what[constants.NV_INSTANCELIST])
- except RPCFail, err:
- val = str(err)
- result[constants.NV_INSTANCELIST] = val
+ _VerifyInstanceList(what, vm_capable, result, all_hvparams)
if constants.NV_VGLIST in what and vm_capable:
result[constants.NV_VGLIST] = utils.ListVolumeGroups()
if constants.NV_PVLIST in what and vm_capable:
- result[constants.NV_PVLIST] = \
- bdev.LogicalVolume.GetPVInfo(what[constants.NV_PVLIST],
- filter_allocatable=False)
+ check_exclusive_pvs = constants.NV_EXCLUSIVEPVS in what
+ val = bdev.LogicalVolume.GetPVInfo(what[constants.NV_PVLIST],
+ filter_allocatable=False,
+ include_lvs=check_exclusive_pvs)
+ if check_exclusive_pvs:
+ result[constants.NV_EXCLUSIVEPVS] = _CheckExclusivePvs(val)
+ for pvi in val:
+ # Avoid sending useless data on the wire
+ pvi.lv_list = []
+ result[constants.NV_PVLIST] = map(objects.LvmPvInfo.ToDict, val)
if constants.NV_VERSION in what:
result[constants.NV_VERSION] = (constants.PROTOCOL_VERSION,
constants.RELEASE_VERSION)
- if constants.NV_HVINFO in what and vm_capable:
- hyper = hypervisor.GetHypervisor(what[constants.NV_HVINFO])
- result[constants.NV_HVINFO] = hyper.GetNodeInfo()
+ _VerifyNodeInfo(what, vm_capable, result, all_hvparams)
+
+ if constants.NV_DRBDVERSION in what and vm_capable:
+ try:
+ drbd_version = DRBD8.GetProcInfo().GetVersionString()
+ except errors.BlockDeviceError, err:
+ logging.warning("Can't get DRBD version", exc_info=True)
+ drbd_version = str(err)
+ result[constants.NV_DRBDVERSION] = drbd_version
if constants.NV_DRBDLIST in what and vm_capable:
try:
- used_minors = bdev.DRBD8.GetUsedDevs().keys()
+ used_minors = drbd.DRBD8.GetUsedDevs()
except errors.BlockDeviceError, err:
logging.warning("Can't get used minors list", exc_info=True)
used_minors = str(err)
if constants.NV_DRBDHELPER in what and vm_capable:
status = True
try:
- payload = bdev.BaseDRBD.GetUsermodeHelper()
+ payload = drbd.DRBD8.GetUsermodeHelper()
except errors.BlockDeviceError, err:
logging.error("Can't get DRBD usermode helper: %s", str(err))
status = False
result[constants.NV_BRIDGES] = [bridge
for bridge in what[constants.NV_BRIDGES]
if not utils.BridgeExists(bridge)]
+
+ if what.get(constants.NV_FILE_STORAGE_PATHS) == my_name:
+ result[constants.NV_FILE_STORAGE_PATHS] = \
+ bdev.ComputeWrongFileStoragePaths()
+
return result
_Fail("Missing bridges %s", utils.CommaJoin(missing))
-def GetInstanceList(hypervisor_list):
+def GetInstanceListForHypervisor(hname, hvparams=None,
+ get_hv_fn=hypervisor.GetHypervisor):
+ """Provides a list of instances of the given hypervisor.
+
+ @type hname: string
+ @param hname: name of the hypervisor
+ @type hvparams: dict of strings
+ @param hvparams: hypervisor parameters for the given hypervisor
+ @type get_hv_fn: function
+ @param get_hv_fn: function that returns a hypervisor for the given hypervisor
+ name; optional parameter to increase testability
+
+ @rtype: list
+ @return: a list of all running instances on the current node
+ - instance1.example.com
+ - instance2.example.com
+
+ """
+ results = []
+ try:
+ hv = get_hv_fn(hname)
+ names = hv.ListInstances(hvparams=hvparams)
+ results.extend(names)
+ except errors.HypervisorError, err:
+ _Fail("Error enumerating instances (hypervisor %s): %s",
+ hname, err, exc=True)
+ return results
+
+
+def GetInstanceList(hypervisor_list, all_hvparams=None,
+ get_hv_fn=hypervisor.GetHypervisor):
"""Provides a list of instances.
@type hypervisor_list: list
@param hypervisor_list: the list of hypervisors to query information
+ @type all_hvparams: dict of dict of strings
+ @param all_hvparams: a dictionary mapping hypervisor types to respective
+ cluster-wide hypervisor parameters
+ @type get_hv_fn: function
+ @param get_hv_fn: function that returns a hypervisor for the given hypervisor
+ name; optional parameter to increase testability
@rtype: list
@return: a list of all running instances on the current node
"""
results = []
for hname in hypervisor_list:
- try:
- names = hypervisor.GetHypervisor(hname).ListInstances()
- results.extend(names)
- except errors.HypervisorError, err:
- _Fail("Error enumerating instances (hypervisor %s): %s",
- hname, err, exc=True)
-
+ hvparams = all_hvparams[hname]
+ results.extend(GetInstanceListForHypervisor(hname, hvparams=hvparams,
+ get_hv_fn=get_hv_fn))
return results
-def GetInstanceInfo(instance, hname):
+def GetInstanceInfo(instance, hname, hvparams=None):
"""Gives back the information about an instance as a dictionary.
@type instance: string
@param instance: the instance name
@type hname: string
@param hname: the hypervisor type of the instance
+ @type hvparams: dict of strings
+ @param hvparams: the instance's hvparams
@rtype: dict
@return: dictionary with the following keys:
- memory: memory size of instance (int)
- state: xen state of instance (string)
- time: cpu time of instance (float)
+ - vcpus: the number of vcpus (int)
"""
output = {}
- iinfo = hypervisor.GetHypervisor(hname).GetInstanceInfo(instance)
+ iinfo = hypervisor.GetHypervisor(hname).GetInstanceInfo(instance,
+ hvparams=hvparams)
if iinfo is not None:
output["memory"] = iinfo[2]
+ output["vcpus"] = iinfo[3]
output["state"] = iinfo[4]
output["time"] = iinfo[5]
def GetInstanceMigratable(instance):
- """Gives whether an instance can be migrated.
+ """Computes whether an instance can be migrated.
@type instance: L{objects.Instance}
@param instance: object representing the instance to be checked.
"""
hyper = hypervisor.GetHypervisor(instance.hypervisor)
iname = instance.name
- if iname not in hyper.ListInstances():
+ if iname not in hyper.ListInstances(instance.hvparams):
_Fail("Instance %s is not running", iname)
for idx in range(len(instance.disks)):
iname, link_name, idx)
-def GetAllInstancesInfo(hypervisor_list):
+def GetAllInstancesInfo(hypervisor_list, all_hvparams):
"""Gather data about all instances.
This is the equivalent of L{GetInstanceInfo}, except that it
@type hypervisor_list: list
@param hypervisor_list: list of hypervisors to query for instance data
+ @type all_hvparams: dict of dict of strings
+ @param all_hvparams: mapping of hypervisor names to hvparams
@rtype: dict
@return: dictionary of instance: data, with data having the following keys:
output = {}
for hname in hypervisor_list:
- iinfo = hypervisor.GetHypervisor(hname).GetAllInstancesInfo()
+ hvparams = all_hvparams[hname]
+ iinfo = hypervisor.GetHypervisor(hname).GetAllInstancesInfo(hvparams)
if iinfo:
for name, _, memory, vcpus, state, times in iinfo:
value = {
" log file:\n%s", result.fail_reason, "\n".join(lines), log=False)
-def _GetBlockDevSymlinkPath(instance_name, idx):
- return utils.PathJoin(pathutils.DISK_LINKS_DIR, "%s%s%d" %
- (instance_name, constants.DISK_SEPARATOR, idx))
+def _GetBlockDevSymlinkPath(instance_name, idx, _dir=None):
+ """Returns symlink path for block device.
+
+ """
+ if _dir is None:
+ _dir = pathutils.DISK_LINKS_DIR
+
+ return utils.PathJoin(_dir,
+ ("%s%s%s" %
+ (instance_name, constants.DISK_SEPARATOR, idx)))
def _SymlinkBlockDev(instance_name, device_path, idx):
return block_devices
-def StartInstance(instance, startup_paused):
+def StartInstance(instance, startup_paused, reason, store_reason=True):
"""Start an instance.
@type instance: L{objects.Instance}
@param instance: the instance object
@type startup_paused: bool
@param instance: pause instance at startup?
+ @type reason: list of reasons
+ @param reason: the reason trail for this startup
+ @type store_reason: boolean
+ @param store_reason: whether to store the shutdown reason trail on file
@rtype: None
"""
- running_instances = GetInstanceList([instance.hypervisor])
+ running_instances = GetInstanceListForHypervisor(instance.hypervisor,
+ instance.hvparams)
if instance.name in running_instances:
logging.info("Instance %s already running, not starting", instance.name)
block_devices = _GatherAndLinkBlockDevs(instance)
hyper = hypervisor.GetHypervisor(instance.hypervisor)
hyper.StartInstance(instance, block_devices, startup_paused)
+ if store_reason:
+ _StoreInstReasonTrail(instance.name, reason)
except errors.BlockDeviceError, err:
_Fail("Block device error: %s", err, exc=True)
except errors.HypervisorError, err:
_Fail("Hypervisor error: %s", err, exc=True)
-def InstanceShutdown(instance, timeout):
+def InstanceShutdown(instance, timeout, reason, store_reason=True):
"""Shut an instance down.
@note: this functions uses polling with a hardcoded timeout.
@param instance: the instance object
@type timeout: integer
@param timeout: maximum timeout for soft shutdown
+ @type reason: list of reasons
+ @param reason: the reason trail for this shutdown
+ @type store_reason: boolean
+ @param store_reason: whether to store the shutdown reason trail on file
@rtype: None
"""
hyper = hypervisor.GetHypervisor(hv_name)
iname = instance.name
- if instance.name not in hyper.ListInstances():
+ if instance.name not in hyper.ListInstances(instance.hvparams):
logging.info("Instance %s not running, doing nothing", iname)
return
self.tried_once = False
def __call__(self):
- if iname not in hyper.ListInstances():
+ if iname not in hyper.ListInstances(instance.hvparams):
return
try:
hyper.StopInstance(instance, retry=self.tried_once)
+ if store_reason:
+ _StoreInstReasonTrail(instance.name, reason)
except errors.HypervisorError, err:
- if iname not in hyper.ListInstances():
+ if iname not in hyper.ListInstances(instance.hvparams):
# if the instance is no longer existing, consider this a
# success and go to cleanup
return
try:
hyper.StopInstance(instance, force=True)
except errors.HypervisorError, err:
- if iname in hyper.ListInstances():
+ if iname in hyper.ListInstances(instance.hvparams):
# 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 iname in hyper.ListInstances():
+ if iname in hyper.ListInstances(instance.hvparams):
_Fail("Could not shutdown instance %s even by destroy", iname)
try:
_RemoveBlockDevLinks(iname, instance.disks)
-def InstanceReboot(instance, reboot_type, shutdown_timeout):
+def InstanceReboot(instance, reboot_type, shutdown_timeout, reason):
"""Reboot an instance.
@type instance: L{objects.Instance}
instance (instead of a call_instance_reboot RPC)
@type shutdown_timeout: integer
@param shutdown_timeout: maximum timeout for soft shutdown
+ @type reason: list of reasons
+ @param reason: the reason trail for this reboot
@rtype: None
"""
- running_instances = GetInstanceList([instance.hypervisor])
+ running_instances = GetInstanceListForHypervisor(instance.hypervisor,
+ instance.hvparams)
if instance.name not in running_instances:
_Fail("Cannot reboot instance %s that is not running", instance.name)
_Fail("Failed to soft reboot instance %s: %s", instance.name, err)
elif reboot_type == constants.INSTANCE_REBOOT_HARD:
try:
- InstanceShutdown(instance, shutdown_timeout)
- return StartInstance(instance, False)
+ InstanceShutdown(instance, shutdown_timeout, reason, store_reason=False)
+ result = StartInstance(instance, False, reason, store_reason=False)
+ _StoreInstReasonTrail(instance.name, reason)
+ return result
except errors.HypervisorError, err:
_Fail("Failed to hard reboot instance %s: %s", instance.name, err)
else:
"""
hyper = hypervisor.GetHypervisor(instance.hypervisor)
- running = hyper.ListInstances()
+ running = hyper.ListInstances(instance.hvparams)
if instance.name not in running:
logging.info("Instance %s is not running, cannot balloon", instance.name)
return
_Fail("Failed to finalize migration on the target node: %s", err, exc=True)
-def MigrateInstance(instance, target, live):
+def MigrateInstance(cluster_name, instance, target, live):
"""Migrates an instance to another node.
+ @type cluster_name: string
+ @param cluster_name: name of the cluster
@type instance: L{objects.Instance}
@param instance: the instance definition
@type target: string
hyper = hypervisor.GetHypervisor(instance.hypervisor)
try:
- hyper.MigrateInstance(instance, target, live)
+ hyper.MigrateInstance(cluster_name, instance, target, live)
except errors.HypervisorError, err:
_Fail("Failed to migrate instance: %s", err, exc=True)
_Fail("Failed to get migration status: %s", err, exc=True)
-def BlockdevCreate(disk, size, owner, on_primary, info):
+def BlockdevCreate(disk, size, owner, on_primary, info, excl_stor):
"""Creates a block device for an instance.
@type disk: L{objects.Disk}
@type info: string
@param info: string that will be sent to the physical device
creation, used for example to set (LVM) tags on LVs
+ @type excl_stor: boolean
+ @param excl_stor: Whether exclusive_storage is active
@return: the new unique_id of the device (this can sometime be
computed only after creation), or None. On secondary nodes,
clist.append(crdev)
try:
- device = bdev.Create(disk, clist)
+ device = bdev.Create(disk, clist, excl_stor)
except errors.BlockDeviceError, err:
_Fail("Can't create block device: %s", err)
@param size: The size in MiB to write
"""
+ # Internal sizes are always in Mebibytes; if the following "dd" command
+ # should use a different block size the offset and size given to this
+ # function must be adjusted accordingly before being passed to "dd".
+ block_size = 1024 * 1024
+
cmd = [constants.DD_CMD, "if=/dev/zero", "seek=%d" % offset,
- "bs=%d" % constants.WIPE_BLOCK_SIZE, "oflag=direct", "of=%s" % path,
+ "bs=%s" % block_size, "oflag=direct", "of=%s" % path,
"count=%d" % size]
result = utils.RunCmd(cmd)
_Fail("Cannot execute wipe for device %s: device not found", disk.iv_name)
# Do cross verify some of the parameters
+ if offset < 0:
+ _Fail("Negative offset")
+ if size < 0:
+ _Fail("Negative size")
if offset > rdev.size:
_Fail("Offset is bigger than device size")
if (offset + size) > rdev.size:
"""
try:
result = _RecursiveAssembleBD(disk, owner, as_primary)
- if isinstance(result, bdev.BlockDev):
+ if isinstance(result, BlockDev):
# pylint: disable=E1103
result = result.dev_path
if as_primary:
return rbd.GetSyncStatus()
-def BlockdevGetsize(disks):
+def BlockdevGetdimensions(disks):
"""Computes the size of the given disks.
If a disk is not found, returns None instead.
@param disks: the list of disk to compute the size for
@rtype: list
@return: list with elements None if the disk cannot be found,
- otherwise the size
+ otherwise the pair (size, spindles), where spindles is None if the
+ device doesn't support that
"""
result = []
if rbd is None:
result.append(None)
else:
- result.append(rbd.GetActualSize())
+ result.append(rbd.GetActualDimensions())
return result
" oflag=dsync", dest_path)
remotecmd = _GetSshRunner(cluster_name).BuildCmd(dest_node,
- constants.GANETI_RUNAS,
+ constants.SSH_LOGIN_USER,
destcmd)
# all commands have been checked, so we're safe to combine them
return result.stdout
-def WriteSsconfFiles(values):
- """Update all ssconf files.
-
- Wrapper around the SimpleStore.WriteFiles.
-
- """
- ssconf.SimpleStore().WriteFiles(values)
-
-
def _OSOndiskAPIVersion(os_dir):
"""Compute and return the API version of a given OS.
if constants.OS_VARIANTS_FILE in os_files:
variants_file = os_files[constants.OS_VARIANTS_FILE]
try:
- variants = utils.ReadFile(variants_file).splitlines()
+ variants = \
+ utils.FilterEmptyLinesAndComments(utils.ReadFile(variants_file))
except EnvironmentError, err:
# we accept missing files, but not other errors
if err.errno != errno.ENOENT:
real_disk = _OpenRealBD(disk)
result["DISK_%d_PATH" % idx] = real_disk.dev_path
result["DISK_%d_ACCESS" % idx] = disk.mode
+ result["DISK_%d_UUID" % idx] = disk.uuid
+ if disk.name:
+ result["DISK_%d_NAME" % idx] = disk.name
if constants.HV_DISK_TYPE in instance.hvparams:
result["DISK_%d_FRONTEND_TYPE" % idx] = \
instance.hvparams[constants.HV_DISK_TYPE]
# NICs
for idx, nic in enumerate(instance.nics):
result["NIC_%d_MAC" % idx] = nic.mac
+ result["NIC_%d_UUID" % idx] = nic.uuid
+ if nic.name:
+ result["NIC_%d_NAME" % idx] = nic.name
if nic.ip:
result["NIC_%d_IP" % idx] = nic.ip
result["NIC_%d_MODE" % idx] = nic.nicparams[constants.NIC_MODE]
result["NIC_%d_BRIDGE" % idx] = nic.nicparams[constants.NIC_LINK]
if nic.nicparams[constants.NIC_LINK]:
result["NIC_%d_LINK" % idx] = nic.nicparams[constants.NIC_LINK]
+ if nic.netinfo:
+ nobj = objects.Network.FromDict(nic.netinfo)
+ result.update(nobj.HooksDict("NIC_%d_" % idx))
if constants.HV_NIC_TYPE in instance.hvparams:
result["NIC_%d_FRONTEND_TYPE" % idx] = \
instance.hvparams[constants.HV_NIC_TYPE]
return result
-def BlockdevGrow(disk, amount, dryrun, backingstore):
+def DiagnoseExtStorage(top_dirs=None):
+ """Compute the validity for all ExtStorage Providers.
+
+ @type top_dirs: list
+ @param top_dirs: the list of directories in which to
+ search (if not given defaults to
+ L{pathutils.ES_SEARCH_PATH})
+ @rtype: list of L{objects.ExtStorage}
+ @return: a list of tuples (name, path, status, diagnose, parameters)
+ for all (potential) ExtStorage Providers under all
+ search paths, where:
+ - name is the (potential) ExtStorage Provider
+ - path is the full path to the ExtStorage Provider
+ - status True/False is the validity of the ExtStorage Provider
+ - diagnose is the error message for an invalid ExtStorage Provider,
+ otherwise empty
+ - parameters is a list of (name, help) parameters, if any
+
+ """
+ if top_dirs is None:
+ top_dirs = pathutils.ES_SEARCH_PATH
+
+ result = []
+ for dir_name in top_dirs:
+ if os.path.isdir(dir_name):
+ try:
+ f_names = utils.ListVisibleFiles(dir_name)
+ except EnvironmentError, err:
+ logging.exception("Can't list the ExtStorage directory %s: %s",
+ dir_name, err)
+ break
+ for name in f_names:
+ es_path = utils.PathJoin(dir_name, name)
+ status, es_inst = bdev.ExtStorageFromDisk(name, base_dir=dir_name)
+ if status:
+ diagnose = ""
+ parameters = es_inst.supported_parameters
+ else:
+ diagnose = es_inst
+ parameters = []
+ result.append((name, es_path, status, diagnose, parameters))
+
+ return result
+
+
+def BlockdevGrow(disk, amount, dryrun, backingstore, excl_stor):
"""Grow a stack of block devices.
This function is called recursively, with the childrens being the
only, or on "logical" storage only; e.g. DRBD is logical storage,
whereas LVM, file, RBD are backing storage
@rtype: (status, result)
+ @type excl_stor: boolean
+ @param excl_stor: Whether exclusive_storage is active
@return: a tuple with the status of the operation (True/False), and
the errors message if status is False
_Fail("Cannot find block device %s", disk)
try:
- r_dev.Grow(amount, dryrun, backingstore)
+ r_dev.Grow(amount, dryrun, backingstore, excl_stor)
except errors.BlockDeviceError, err:
_Fail("Failed to grow block device: %s", err, exc=True)
disk.unique_id, disk.dev_type)
+def BlockdevSetInfo(disk, info):
+ """Sets 'metadata' information on block devices.
+
+ This function sets 'info' metadata on block devices. Initial
+ information is set at device creation; this function should be used
+ for example after renames.
+
+ @type disk: L{objects.Disk}
+ @param disk: the disk to be grown
+ @type info: string
+ @param info: new 'info' metadata
+ @rtype: (status, result)
+ @return: a tuple with the status of the operation (True/False), and
+ the errors message if status is False
+
+ """
+ r_dev = _RecursiveFindBD(disk)
+ if r_dev is None:
+ _Fail("Cannot find block device %s", disk)
+
+ try:
+ r_dev.SetInfo(info)
+ except errors.BlockDeviceError, err:
+ _Fail("Failed to set information on block device: %s", err, exc=True)
+
+
def FinalizeExport(instance, snap_disks):
"""Write out the export configuration information.
config.set(constants.INISECT_INS, "nic%d_mac" %
nic_count, "%s" % nic.mac)
config.set(constants.INISECT_INS, "nic%d_ip" % nic_count, "%s" % nic.ip)
+ config.set(constants.INISECT_INS, "nic%d_network" % nic_count,
+ "%s" % nic.network)
for param in constants.NICS_PARAMETER_TYPES:
config.set(constants.INISECT_INS, "nic%d_%s" % (nic_count, param),
"%s" % nic.nicparams.get(param, None))
@return: the normalized path if valid, None otherwise
"""
- if not constants.ENABLE_FILE_STORAGE:
+ if not (constants.ENABLE_FILE_STORAGE or
+ constants.ENABLE_SHARED_FILE_STORAGE):
_Fail("File storage disabled at configure time")
- cfg = _GetConfig()
- fs_dir = os.path.normpath(fs_dir)
- base_fstore = cfg.GetFileStorageDir()
- base_shared = cfg.GetSharedFileStorageDir()
- if not (utils.IsBelowDir(base_fstore, fs_dir) or
- utils.IsBelowDir(base_shared, fs_dir)):
- _Fail("File storage directory '%s' is not under base file"
- " storage directory '%s' or shared storage directory '%s'",
- fs_dir, base_fstore, base_shared)
- return fs_dir
+
+ bdev.CheckFileStoragePath(fs_dir)
+
+ return os.path.normpath(fs_dir)
def CreateFileStorageDir(file_storage_dir):
@raises RPCFail: if the file is not valid
"""
- queue_dir = os.path.normpath(pathutils.QUEUE_DIR)
- result = (os.path.commonprefix([queue_dir, file_name]) == queue_dir)
-
- if not result:
+ if not utils.IsBelowDir(pathutils.QUEUE_DIR, file_name):
_Fail("Passed job queue file '%s' does not belong to"
- " the queue directory '%s'", file_name, queue_dir)
+ " the queue directory '%s'", file_name, pathutils.QUEUE_DIR)
def JobQueueUpdate(file_name, content):
# Write and replace the file atomically
utils.WriteFile(file_name, data=_Decompress(content), uid=getents.masterd_uid,
- gid=getents.masterd_gid)
+ gid=getents.daemons_gid, mode=constants.JOB_QUEUE_FILES_PERMS)
def JobQueueRename(old, new):
getents = runtime.GetEnts()
- utils.RenameFile(old, new, mkdir=True, mkdir_mode=0700,
- dir_uid=getents.masterd_uid, dir_gid=getents.masterd_gid)
+ utils.RenameFile(old, new, mkdir=True, mkdir_mode=0750,
+ dir_uid=getents.masterd_uid, dir_gid=getents.daemons_gid)
def BlockdevClose(instance_name, disks):
shutil.rmtree(status_dir, ignore_errors=True)
-def _FindDisks(nodes_ip, disks):
- """Sets the physical ID on disks and returns the block devices.
+def _SetPhysicalId(target_node_uuid, nodes_ip, disks):
+ """Sets the correct physical ID on all passed disks.
"""
- # set the correct physical ID
- my_name = netutils.Hostname.GetSysName()
for cf in disks:
- cf.SetPhysicalID(my_name, nodes_ip)
+ cf.SetPhysicalID(target_node_uuid, nodes_ip)
+
+
+def _FindDisks(target_node_uuid, nodes_ip, disks):
+ """Sets the physical ID on disks and returns the block devices.
+
+ """
+ _SetPhysicalId(target_node_uuid, nodes_ip, disks)
bdevs = []
return bdevs
-def DrbdDisconnectNet(nodes_ip, disks):
+def DrbdDisconnectNet(target_node_uuid, nodes_ip, disks):
"""Disconnects the network on a list of drbd devices.
"""
- bdevs = _FindDisks(nodes_ip, disks)
+ bdevs = _FindDisks(target_node_uuid, nodes_ip, disks)
# disconnect disks
for rd in bdevs:
err, exc=True)
-def DrbdAttachNet(nodes_ip, disks, instance_name, multimaster):
+def DrbdAttachNet(target_node_uuid, nodes_ip, disks, instance_name,
+ multimaster):
"""Attaches the network on a list of drbd devices.
"""
- bdevs = _FindDisks(nodes_ip, disks)
+ bdevs = _FindDisks(target_node_uuid, nodes_ip, disks)
if multimaster:
for idx, rd in enumerate(bdevs):
_Fail("Can't change to primary mode: %s", err)
-def DrbdWaitSync(nodes_ip, disks):
+def DrbdWaitSync(target_node_uuid, nodes_ip, disks):
"""Wait until DRBDs have synchronized.
"""
raise utils.RetryAgain()
return stats
- bdevs = _FindDisks(nodes_ip, disks)
+ bdevs = _FindDisks(target_node_uuid, nodes_ip, disks)
min_resync = 100
alldone = True
return (alldone, min_resync)
+def DrbdNeedsActivation(target_node_uuid, nodes_ip, disks):
+ """Checks which of the passed disks needs activation and returns their UUIDs.
+
+ """
+ _SetPhysicalId(target_node_uuid, nodes_ip, disks)
+ faulty_disks = []
+
+ for disk in disks:
+ rd = _RecursiveFindBD(disk)
+ if rd is None:
+ faulty_disks.append(disk)
+ continue
+
+ stats = rd.GetProcStatus()
+ if stats.is_standalone or stats.is_diskless:
+ faulty_disks.append(disk)
+
+ return [disk.uuid for disk in faulty_disks]
+
+
def GetDrbdUsermodeHelper():
"""Returns DRBD usermode helper currently configured.
"""
try:
- return bdev.BaseDRBD.GetUsermodeHelper()
+ return drbd.DRBD8.GetUsermodeHelper()
except errors.BlockDeviceError, err:
_Fail(str(err))
-def PowercycleNode(hypervisor_type):
+def PowercycleNode(hypervisor_type, hvparams=None):
"""Hard-powercycle the node.
Because we need to return first, and schedule the powercycle in the
except Exception: # pylint: disable=W0703
pass
time.sleep(5)
- hyper.PowercycleNode()
+ hyper.PowercycleNode(hvparams=hvparams)
+
+
+def _VerifyRestrictedCmdName(cmd):
+ """Verifies a restricted command name.
+
+ @type cmd: string
+ @param cmd: Command name
+ @rtype: tuple; (boolean, string or None)
+ @return: The tuple's first element is the status; if C{False}, the second
+ element is an error message string, otherwise it's C{None}
+
+ """
+ if not cmd.strip():
+ return (False, "Missing command name")
+
+ if os.path.basename(cmd) != cmd:
+ return (False, "Invalid command name")
+
+ if not constants.EXT_PLUGIN_MASK.match(cmd):
+ return (False, "Command name contains forbidden characters")
+
+ return (True, None)
+
+
+def _CommonRestrictedCmdCheck(path, owner):
+ """Common checks for restricted command file system directories and files.
+
+ @type path: string
+ @param path: Path to check
+ @param owner: C{None} or tuple containing UID and GID
+ @rtype: tuple; (boolean, string or C{os.stat} result)
+ @return: The tuple's first element is the status; if C{False}, the second
+ element is an error message string, otherwise it's the result of C{os.stat}
+
+ """
+ if owner is None:
+ # Default to root as owner
+ owner = (0, 0)
+
+ try:
+ st = os.stat(path)
+ except EnvironmentError, err:
+ return (False, "Can't stat(2) '%s': %s" % (path, err))
+
+ if stat.S_IMODE(st.st_mode) & (~_RCMD_MAX_MODE):
+ return (False, "Permissions on '%s' are too permissive" % path)
+
+ if (st.st_uid, st.st_gid) != owner:
+ (owner_uid, owner_gid) = owner
+ return (False, "'%s' is not owned by %s:%s" % (path, owner_uid, owner_gid))
+
+ return (True, st)
+
+
+def _VerifyRestrictedCmdDirectory(path, _owner=None):
+ """Verifies restricted command directory.
+
+ @type path: string
+ @param path: Path to check
+ @rtype: tuple; (boolean, string or None)
+ @return: The tuple's first element is the status; if C{False}, the second
+ element is an error message string, otherwise it's C{None}
+
+ """
+ (status, value) = _CommonRestrictedCmdCheck(path, _owner)
+
+ if not status:
+ return (False, value)
+
+ if not stat.S_ISDIR(value.st_mode):
+ return (False, "Path '%s' is not a directory" % path)
+
+ return (True, None)
+
+
+def _VerifyRestrictedCmd(path, cmd, _owner=None):
+ """Verifies a whole restricted command and returns its executable filename.
+
+ @type path: string
+ @param path: Directory containing restricted commands
+ @type cmd: string
+ @param cmd: Command name
+ @rtype: tuple; (boolean, string)
+ @return: The tuple's first element is the status; if C{False}, the second
+ element is an error message string, otherwise the second element is the
+ absolute path to the executable
+
+ """
+ executable = utils.PathJoin(path, cmd)
+
+ (status, msg) = _CommonRestrictedCmdCheck(executable, _owner)
+
+ if not status:
+ return (False, msg)
+
+ if not utils.IsExecutable(executable):
+ return (False, "access(2) thinks '%s' can't be executed" % executable)
+
+ return (True, executable)
+
+
+def _PrepareRestrictedCmd(path, cmd,
+ _verify_dir=_VerifyRestrictedCmdDirectory,
+ _verify_name=_VerifyRestrictedCmdName,
+ _verify_cmd=_VerifyRestrictedCmd):
+ """Performs a number of tests on a restricted command.
+
+ @type path: string
+ @param path: Directory containing restricted commands
+ @type cmd: string
+ @param cmd: Command name
+ @return: Same as L{_VerifyRestrictedCmd}
+
+ """
+ # Verify the directory first
+ (status, msg) = _verify_dir(path)
+ if status:
+ # Check command if everything was alright
+ (status, msg) = _verify_name(cmd)
+
+ if not status:
+ return (False, msg)
+
+ # Check actual executable
+ return _verify_cmd(path, cmd)
+
+
+def RunRestrictedCmd(cmd,
+ _lock_timeout=_RCMD_LOCK_TIMEOUT,
+ _lock_file=pathutils.RESTRICTED_COMMANDS_LOCK_FILE,
+ _path=pathutils.RESTRICTED_COMMANDS_DIR,
+ _sleep_fn=time.sleep,
+ _prepare_fn=_PrepareRestrictedCmd,
+ _runcmd_fn=utils.RunCmd,
+ _enabled=constants.ENABLE_RESTRICTED_COMMANDS):
+ """Executes a restricted command after performing strict tests.
+
+ @type cmd: string
+ @param cmd: Command name
+ @rtype: string
+ @return: Command output
+ @raise RPCFail: In case of an error
+
+ """
+ logging.info("Preparing to run restricted command '%s'", cmd)
+
+ if not _enabled:
+ _Fail("Restricted commands disabled at configure time")
+
+ lock = None
+ try:
+ cmdresult = None
+ try:
+ lock = utils.FileLock.Open(_lock_file)
+ lock.Exclusive(blocking=True, timeout=_lock_timeout)
+
+ (status, value) = _prepare_fn(_path, cmd)
+
+ if status:
+ cmdresult = _runcmd_fn([value], env={}, reset_env=True,
+ postfork_fn=lambda _: lock.Unlock())
+ else:
+ logging.error(value)
+ except Exception: # pylint: disable=W0703
+ # Keep original error in log
+ logging.exception("Caught exception")
+
+ if cmdresult is None:
+ logging.info("Sleeping for %0.1f seconds before returning",
+ _RCMD_INVALID_DELAY)
+ _sleep_fn(_RCMD_INVALID_DELAY)
+
+ # Do not include original error message in returned error
+ _Fail("Executing command '%s' failed" % cmd)
+ elif cmdresult.failed or cmdresult.fail_reason:
+ _Fail("Restricted command '%s' failed: %s; output: %s",
+ cmd, cmdresult.fail_reason, cmdresult.output)
+ else:
+ return cmdresult.output
+ finally:
+ if lock is not None:
+ # Release lock at last
+ lock.Close()
+ lock = None
+
+
+def SetWatcherPause(until, _filename=pathutils.WATCHER_PAUSEFILE):
+ """Creates or removes the watcher pause file.
+
+ @type until: None or number
+ @param until: Unix timestamp saying until when the watcher shouldn't run
+
+ """
+ if until is None:
+ logging.info("Received request to no longer pause watcher")
+ utils.RemoveFile(_filename)
+ else:
+ logging.info("Received request to pause watcher until %s", until)
+
+ if not ht.TNumber(until):
+ _Fail("Duration must be numeric")
+
+ utils.WriteFile(_filename, data="%d\n" % (until, ), mode=0644)
class HooksRunner(object):