_IES_CA_FILE = "ca"
#: Valid LVS output line regex
-_LVSLINE_REGEX = re.compile("^ *([^|]+)\|([^|]+)\|([0-9.]+)\|([^|]{6,})\|?$")
+_LVSLINE_REGEX = re.compile(r"^ *([^|]+)\|([^|]+)\|([0-9.]+)\|([^|]{6,})\|?$")
# Actions for the master setup script
_MASTER_START = "start"
raise errors.QuitGanetiException(True, "Shutdown scheduled")
-def _GetVgInfo(name, excl_stor):
+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], excl_stor)
+ vginfo = info_fn([name], excl_stor)
if vginfo:
vg_free = int(round(vginfo[0][0], 0))
vg_size = int(round(vginfo[0][1], 0))
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 _GetVgSpindlesInfo(name, excl_stor):
+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
"""
if excl_stor:
- (vg_free, vg_size) = bdev.LogicalVolume.GetVgSpindlesInfo(name)
+ (vg_free, vg_size) = info_fn(name)
else:
vg_free = 0
vg_size = 0
return {
"type": constants.ST_LVM_PV,
"name": name,
- "vg_free": vg_free,
- "vg_size": vg_size,
+ "storage_free": vg_free,
+ "storage_size": vg_size,
}
return map(fn, names)
-def GetNodeInfo(storage_units, hv_specs, excl_stor):
+def GetNodeInfo(storage_units, hv_specs):
"""Gives back a hash with different information about the node.
- @type storage_units: list of pairs (string, string)
- @param storage_units: List of pairs (storage unit, identifier) to ask for disk
- space information. In case of lvm-vg, the identifier is
- the VG name.
+ @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
- @type excl_stor: boolean
- @param excl_stor: Whether exclusive_storage is active
@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")
storage_info = _GetNamedNodeInfo(
storage_units,
- (lambda storage_unit: _ApplyStorageInfoFunction(storage_unit[0],
- storage_unit[1],
- excl_stor)))
+ (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)
-# pylint: disable=W0613
-def _GetFileStorageSpaceInfo(path, *args):
+def _GetFileStorageSpaceInfo(path, params):
"""Wrapper around filestorage.GetSpaceInfo.
The purpose of this wrapper is to call filestorage.GetFileStorageSpaceInfo
parameters.
"""
+ _CheckStorageParams(params, 0)
return filestorage.GetFileStorageSpaceInfo(path)
constants.ST_DISKLESS: None,
constants.ST_EXT: None,
constants.ST_FILE: _GetFileStorageSpaceInfo,
- constants.ST_LVM_PV: _GetVgSpindlesInfo,
- constants.ST_LVM_VG: _GetVgInfo,
+ constants.ST_LVM_PV: _GetLvmPvSpaceInfo,
+ constants.ST_LVM_VG: _GetLvmVgSpaceInfo,
constants.ST_RADOS: None,
}
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()
+ if what.get(constants.NV_ACCEPTED_STORAGE_PATHS) == my_name:
+ result[constants.NV_ACCEPTED_STORAGE_PATHS] = \
+ filestorage.ComputeWrongFileStoragePaths()
+
+ if what.get(constants.NV_FILE_STORAGE_PATH):
+ pathresult = filestorage.CheckFileStoragePath(
+ what[constants.NV_FILE_STORAGE_PATH])
+ if pathresult:
+ result[constants.NV_FILE_STORAGE_PATH] = pathresult
+
+ if what.get(constants.NV_SHARED_FILE_STORAGE_PATH):
+ pathresult = filestorage.CheckFileStoragePath(
+ what[constants.NV_SHARED_FILE_STORAGE_PATH])
+ if pathresult:
+ result[constants.NV_SHARED_FILE_STORAGE_PATH] = pathresult
return result
return result
-def BlockdevExport(disk, dest_node, dest_path, cluster_name):
+def BlockdevExport(disk, dest_node_ip, dest_path, cluster_name):
"""Export a block device to a remote node.
@type disk: L{objects.Disk}
@param disk: the description of the disk to export
- @type dest_node: str
- @param dest_node: the destination node to export to
+ @type dest_node_ip: str
+ @param dest_node_ip: the destination node IP to export to
@type dest_path: str
@param dest_path: the destination path on the target node
@type cluster_name: str
destcmd = utils.BuildShellCmd("dd of=%s conv=nocreat,notrunc bs=65536"
" oflag=dsync", dest_path)
- remotecmd = _GetSshRunner(cluster_name).BuildCmd(dest_node,
+ remotecmd = _GetSshRunner(cluster_name).BuildCmd(dest_node_ip,
constants.SSH_LOGIN_USER,
destcmd)
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]
- if disk.dev_type in constants.LDS_BLOCK:
+ if disk.dev_type in constants.DTS_BLOCK:
result["DISK_%d_BACKEND_TYPE" % idx] = "block"
- elif disk.dev_type == constants.LD_FILE:
+ elif disk.dev_type in [constants.DT_FILE, constants.DT_SHARED_FILE]:
result["DISK_%d_BACKEND_TYPE" % idx] = \
"file:%s" % disk.physical_id[0]
# 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]
return result
-def BlockdevGrow(disk, amount, dryrun, backingstore):
+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)
@return: snapshot disk ID as (vg, lv)
"""
- if disk.dev_type == constants.LD_DRBD8:
+ if disk.dev_type == constants.DT_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:
+ elif disk.dev_type == constants.DT_PLAIN:
r_dev = _RecursiveFindBD(disk)
if r_dev is not None:
# FIXME: choose a saner value for the snapshot size
@return: the normalized path if valid, None otherwise
"""
- if not (constants.ENABLE_FILE_STORAGE or
- constants.ENABLE_SHARED_FILE_STORAGE):
- _Fail("File storage disabled at configure time")
-
- bdev.CheckFileStoragePath(fs_dir)
+ filestorage.CheckFileStoragePath(fs_dir)
return os.path.normpath(fs_dir)
shutil.rmtree(status_dir, ignore_errors=True)
-def _FindDisks(target_node_uuid, 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
for cf in disks:
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 = []
for cf in disks:
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.