os-brick add cinder local_dev lvm code
This patch adds the local LVM control code from Cinder into os-brick. Nova has it's own copy of code that does basically the same thing. This patch is the first step to migrating both Cinder and Nova to using the same exact code for managing local lvm volume groups and volumes. This is NOT a replacement for the Cinder lvm volume driver, but the low level lvm management code. Change-Id: I80a1ac859b9f3aa50262a8d0db750a00cb3e2dc4 implements blueprint: local-dev-lvm-to-os-brick
This commit is contained in:
Walter A. Boring IV
parent
a1d690bde2
commit
d3b9696f0d
@ -67,3 +67,39 @@ vgc-cluster: CommandFilter, vgc-cluster, root
|
||||
|
||||
# initiator/linuxscsi.py
|
||||
scsi_id: CommandFilter, /lib/udev/scsi_id, root
|
||||
|
||||
# local_dev lvm related commands
|
||||
|
||||
# LVM related show commands
|
||||
pvs: EnvFilter, env, root, LC_ALL=C, pvs
|
||||
vgs: EnvFilter, env, root, LC_ALL=C, vgs
|
||||
lvs: EnvFilter, env, root, LC_ALL=C, lvs
|
||||
lvdisplay: EnvFilter, env, root, LC_ALL=C, lvdisplay
|
||||
|
||||
# local_dev/lvm.py: 'vgcreate', vg_name, pv_list
|
||||
vgcreate: CommandFilter, vgcreate, root
|
||||
|
||||
# local_dev/lvm.py: 'lvcreate', '-L', sizestr, '-n', volume_name,..
|
||||
# local_dev/lvm.py: 'lvcreate', '-L', ...
|
||||
lvcreate: EnvFilter, env, root, LC_ALL=C, lvcreate
|
||||
lvcreate_lvmconf: EnvFilter, env, root, LVM_SYSTEM_DIR=, LC_ALL=C, lvcreate
|
||||
|
||||
# local_dev/lvm.py: 'lvextend', '-L' '%(new_size)s', '%(lv_name)s' ...
|
||||
# local_dev/lvm.py: 'lvextend', '-L' '%(new_size)s', '%(thin_pool)s' ...
|
||||
lvextend: EnvFilter, env, root, LC_ALL=C, lvextend
|
||||
lvextend_lvmconf: EnvFilter, env, root, LVM_SYSTEM_DIR=, LC_ALL=C, lvextend
|
||||
|
||||
# local_dev/lvm.py: 'lvremove', '-f', %s/%s % ...
|
||||
lvremove: CommandFilter, lvremove, root
|
||||
|
||||
# local_dev/lvm.py: 'lvrename', '%(vg)s', '%(orig)s' '(new)s'...
|
||||
lvrename: CommandFilter, lvrename, root
|
||||
|
||||
# local_dev/lvm.py: 'lvchange -a y -K <lv>'
|
||||
lvchange: CommandFilter, lvchange, root
|
||||
|
||||
# local_dev/lvm.py: 'lvconvert', '--merge', snapshot_name
|
||||
lvconvert: CommandFilter, lvconvert, root
|
||||
|
||||
# local_dev/lvm.py: 'udevadm', 'settle'
|
||||
udevadm: CommandFilter, udevadm, root
|
||||
|
||||
@ -116,3 +116,11 @@ class FailedISCSITargetPortalLogin(BrickException):
|
||||
|
||||
class BlockDeviceReadOnly(BrickException):
|
||||
message = _("Block device %(device)s is Read-Only.")
|
||||
|
||||
|
||||
class VolumeGroupNotFound(BrickException):
|
||||
message = _("Unable to find Volume Group: %(vg_name)s")
|
||||
|
||||
|
||||
class VolumeGroupCreationFailed(BrickException):
|
||||
message = _("Failed to create Volume Group: %(vg_name)s")
|
||||
|
||||
0
os_brick/local_dev/__init__.py
Normal file
0
os_brick/local_dev/__init__.py
Normal file
782
os_brick/local_dev/lvm.py
Normal file
782
os_brick/local_dev/lvm.py
Normal file
@ -0,0 +1,782 @@
|
||||
# Copyright 2013 OpenStack Foundation.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
# not use this file except in compliance with the License. You may obtain
|
||||
# a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
"""
|
||||
LVM class for performing LVM operations.
|
||||
"""
|
||||
|
||||
import math
|
||||
import os
|
||||
import re
|
||||
|
||||
from os_brick import exception
|
||||
from os_brick import executor
|
||||
from os_brick.i18n import _LE, _LI
|
||||
from os_brick import utils
|
||||
from oslo_concurrency import processutils as putils
|
||||
from oslo_log import log as logging
|
||||
from oslo_utils import excutils
|
||||
from six import moves
|
||||
|
||||
|
||||
LOG = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class LVM(executor.Executor):
|
||||
"""LVM object to enable various LVM related operations."""
|
||||
|
||||
LVM_CMD_PREFIX = ['env', 'LC_ALL=C']
|
||||
|
||||
def __init__(self, vg_name, root_helper, create_vg=False,
|
||||
physical_volumes=None, lvm_type='default',
|
||||
executor=putils.execute, lvm_conf=None):
|
||||
|
||||
"""Initialize the LVM object.
|
||||
|
||||
The LVM object is based on an LVM VolumeGroup, one instantiation
|
||||
for each VolumeGroup you have/use.
|
||||
|
||||
:param vg_name: Name of existing VG or VG to create
|
||||
:param root_helper: Execution root_helper method to use
|
||||
:param create_vg: Indicates the VG doesn't exist
|
||||
and we want to create it
|
||||
:param physical_volumes: List of PVs to build VG on
|
||||
:param lvm_type: VG and Volume type (default, or thin)
|
||||
:param executor: Execute method to use, None uses common/processutils
|
||||
|
||||
"""
|
||||
super(LVM, self).__init__(execute=executor, root_helper=root_helper)
|
||||
self.vg_name = vg_name
|
||||
self.pv_list = []
|
||||
self.vg_size = 0.0
|
||||
self.vg_free_space = 0.0
|
||||
self.vg_lv_count = 0
|
||||
self.vg_uuid = None
|
||||
self.vg_thin_pool = None
|
||||
self.vg_thin_pool_size = 0.0
|
||||
self.vg_thin_pool_free_space = 0.0
|
||||
self._supports_snapshot_lv_activation = None
|
||||
self._supports_lvchange_ignoreskipactivation = None
|
||||
self.vg_provisioned_capacity = 0.0
|
||||
|
||||
# Ensure LVM_SYSTEM_DIR has been added to LVM.LVM_CMD_PREFIX
|
||||
# before the first LVM command is executed, and use the directory
|
||||
# where the specified lvm_conf file is located as the value.
|
||||
if lvm_conf and os.path.isfile(lvm_conf):
|
||||
lvm_sys_dir = os.path.dirname(lvm_conf)
|
||||
LVM.LVM_CMD_PREFIX = ['env',
|
||||
'LC_ALL=C',
|
||||
'LVM_SYSTEM_DIR=' + lvm_sys_dir]
|
||||
|
||||
if create_vg and physical_volumes is not None:
|
||||
self.pv_list = physical_volumes
|
||||
|
||||
try:
|
||||
self._create_vg(physical_volumes)
|
||||
except putils.ProcessExecutionError as err:
|
||||
LOG.exception(_LE('Error creating Volume Group'))
|
||||
LOG.error(_LE('Cmd :%s'), err.cmd)
|
||||
LOG.error(_LE('StdOut :%s'), err.stdout)
|
||||
LOG.error(_LE('StdErr :%s'), err.stderr)
|
||||
raise exception.VolumeGroupCreationFailed(vg_name=self.vg_name)
|
||||
|
||||
if self._vg_exists() is False:
|
||||
LOG.error(_LE('Unable to locate Volume Group %s'), vg_name)
|
||||
raise exception.VolumeGroupNotFound(vg_name=vg_name)
|
||||
|
||||
# NOTE: we assume that the VG has been activated outside of Cinder
|
||||
|
||||
if lvm_type == 'thin':
|
||||
pool_name = "%s-pool" % self.vg_name
|
||||
if self.get_volume(pool_name) is None:
|
||||
try:
|
||||
self.create_thin_pool(pool_name)
|
||||
except putils.ProcessExecutionError:
|
||||
# Maybe we just lost the race against another copy of
|
||||
# this driver being in init in parallel - e.g.
|
||||
# cinder-volume and cinder-backup starting in parallel
|
||||
if self.get_volume(pool_name) is None:
|
||||
raise
|
||||
|
||||
self.vg_thin_pool = pool_name
|
||||
self.activate_lv(self.vg_thin_pool)
|
||||
self.pv_list = self.get_all_physical_volumes(root_helper, vg_name)
|
||||
|
||||
def _vg_exists(self):
|
||||
"""Simple check to see if VG exists.
|
||||
|
||||
:returns: True if vg specified in object exists, else False
|
||||
|
||||
"""
|
||||
exists = False
|
||||
cmd = LVM.LVM_CMD_PREFIX + ['vgs', '--noheadings',
|
||||
'-o', 'name', self.vg_name]
|
||||
(out, _err) = self._execute(*cmd,
|
||||
root_helper=self._root_helper,
|
||||
run_as_root=True)
|
||||
|
||||
if out is not None:
|
||||
volume_groups = out.split()
|
||||
if self.vg_name in volume_groups:
|
||||
exists = True
|
||||
|
||||
return exists
|
||||
|
||||
def _create_vg(self, pv_list):
|
||||
cmd = ['vgcreate', self.vg_name, ','.join(pv_list)]
|
||||
self._execute(*cmd, root_helper=self._root_helper, run_as_root=True)
|
||||
|
||||
def _get_vg_uuid(self):
|
||||
cmd = LVM.LVM_CMD_PREFIX + ['vgs', '--noheadings',
|
||||
'-o', 'uuid', self.vg_name]
|
||||
(out, _err) = self._execute(*cmd,
|
||||
root_helper=self._root_helper,
|
||||
run_as_root=True)
|
||||
if out is not None:
|
||||
return out.split()
|
||||
else:
|
||||
return []
|
||||
|
||||
def _get_thin_pool_free_space(self, vg_name, thin_pool_name):
|
||||
"""Returns available thin pool free space.
|
||||
|
||||
:param vg_name: the vg where the pool is placed
|
||||
:param thin_pool_name: the thin pool to gather info for
|
||||
:returns: Free space in GB (float), calculated using data_percent
|
||||
|
||||
"""
|
||||
cmd = LVM.LVM_CMD_PREFIX + ['lvs', '--noheadings', '--unit=g',
|
||||
'-o', 'size,data_percent', '--separator',
|
||||
':', '--nosuffix']
|
||||
# NOTE(gfidente): data_percent only applies to some types of LV so we
|
||||
# make sure to append the actual thin pool name
|
||||
cmd.append("/dev/%s/%s" % (vg_name, thin_pool_name))
|
||||
|
||||
free_space = 0.0
|
||||
|
||||
try:
|
||||
(out, err) = self._execute(*cmd,
|
||||
root_helper=self._root_helper,
|
||||
run_as_root=True)
|
||||
if out is not None:
|
||||
out = out.strip()
|
||||
data = out.split(':')
|
||||
pool_size = float(data[0])
|
||||
data_percent = float(data[1])
|
||||
consumed_space = pool_size / 100 * data_percent
|
||||
free_space = pool_size - consumed_space
|
||||
free_space = round(free_space, 2)
|
||||
except putils.ProcessExecutionError as err:
|
||||
LOG.exception(_LE('Error querying thin pool about data_percent'))
|
||||
LOG.error(_LE('Cmd :%s'), err.cmd)
|
||||
LOG.error(_LE('StdOut :%s'), err.stdout)
|
||||
LOG.error(_LE('StdErr :%s'), err.stderr)
|
||||
|
||||
return free_space
|
||||
|
||||
@staticmethod
|
||||
def get_lvm_version(root_helper):
|
||||
"""Static method to get LVM version from system.
|
||||
|
||||
:param root_helper: root_helper to use for execute
|
||||
:returns: version 3-tuple
|
||||
|
||||
"""
|
||||
|
||||
cmd = LVM.LVM_CMD_PREFIX + ['vgs', '--version']
|
||||
(out, _err) = putils.execute(*cmd,
|
||||
root_helper=root_helper,
|
||||
run_as_root=True)
|
||||
lines = out.split('\n')
|
||||
|
||||
for line in lines:
|
||||
if 'LVM version' in line:
|
||||
version_list = line.split()
|
||||
# NOTE(gfidente): version is formatted as follows:
|
||||
# major.minor.patchlevel(library API version)[-customisation]
|
||||
version = version_list[2]
|
||||
version_filter = r"(\d+)\.(\d+)\.(\d+).*"
|
||||
r = re.search(version_filter, version)
|
||||
version_tuple = tuple(map(int, r.group(1, 2, 3)))
|
||||
return version_tuple
|
||||
|
||||
@staticmethod
|
||||
def supports_thin_provisioning(root_helper):
|
||||
"""Static method to check for thin LVM support on a system.
|
||||
|
||||
:param root_helper: root_helper to use for execute
|
||||
:returns: True if supported, False otherwise
|
||||
|
||||
"""
|
||||
|
||||
return LVM.get_lvm_version(root_helper) >= (2, 2, 95)
|
||||
|
||||
@property
|
||||
def supports_snapshot_lv_activation(self):
|
||||
"""Property indicating whether snap activation changes are supported.
|
||||
|
||||
Check for LVM version >= 2.02.91.
|
||||
(LVM2 git: e8a40f6 Allow to activate snapshot)
|
||||
|
||||
:returns: True/False indicating support
|
||||
"""
|
||||
|
||||
if self._supports_snapshot_lv_activation is not None:
|
||||
return self._supports_snapshot_lv_activation
|
||||
|
||||
self._supports_snapshot_lv_activation = (
|
||||
self.get_lvm_version(self._root_helper) >= (2, 2, 91))
|
||||
|
||||
return self._supports_snapshot_lv_activation
|
||||
|
||||
@property
|
||||
def supports_lvchange_ignoreskipactivation(self):
|
||||
"""Property indicating whether lvchange can ignore skip activation.
|
||||
|
||||
Check for LVM version >= 2.02.99.
|
||||
(LVM2 git: ab789c1bc add --ignoreactivationskip to lvchange)
|
||||
"""
|
||||
|
||||
if self._supports_lvchange_ignoreskipactivation is not None:
|
||||
return self._supports_lvchange_ignoreskipactivation
|
||||
|
||||
self._supports_lvchange_ignoreskipactivation = (
|
||||
self.get_lvm_version(self._root_helper) >= (2, 2, 99))
|
||||
|
||||
return self._supports_lvchange_ignoreskipactivation
|
||||
|
||||
@staticmethod
|
||||
def get_lv_info(root_helper, vg_name=None, lv_name=None):
|
||||
"""Retrieve info about LVs (all, in a VG, or a single LV).
|
||||
|
||||
:param root_helper: root_helper to use for execute
|
||||
:param vg_name: optional, gathers info for only the specified VG
|
||||
:param lv_name: optional, gathers info for only the specified LV
|
||||
:returns: List of Dictionaries with LV info
|
||||
|
||||
"""
|
||||
|
||||
cmd = LVM.LVM_CMD_PREFIX + ['lvs', '--noheadings', '--unit=g',
|
||||
'-o', 'vg_name,name,size', '--nosuffix']
|
||||
if lv_name is not None and vg_name is not None:
|
||||
cmd.append("%s/%s" % (vg_name, lv_name))
|
||||
elif vg_name is not None:
|
||||
cmd.append(vg_name)
|
||||
|
||||
try:
|
||||
(out, _err) = putils.execute(*cmd,
|
||||
root_helper=root_helper,
|
||||
run_as_root=True)
|
||||
except putils.ProcessExecutionError as err:
|
||||
with excutils.save_and_reraise_exception(reraise=True) as ctx:
|
||||
if "not found" in err.stderr or "Failed to find" in err.stderr:
|
||||
ctx.reraise = False
|
||||
LOG.info(_LI("Logical Volume not found when querying "
|
||||
"LVM info. (vg_name=%(vg)s, lv_name=%(lv)s"),
|
||||
{'vg': vg_name, 'lv': lv_name})
|
||||
out = None
|
||||
|
||||
lv_list = []
|
||||
if out is not None:
|
||||
volumes = out.split()
|
||||
iterator = moves.zip(*[iter(volumes)] * 3) # pylint: disable=E1101
|
||||
for vg, name, size in iterator:
|
||||
lv_list.append({"vg": vg, "name": name, "size": size})
|
||||
|
||||
return lv_list
|
||||
|
||||
def get_volumes(self, lv_name=None):
|
||||
"""Get all LV's associated with this instantiation (VG).
|
||||
|
||||
:returns: List of Dictionaries with LV info
|
||||
|
||||
"""
|
||||
return self.get_lv_info(self._root_helper,
|
||||
self.vg_name,
|
||||
lv_name)
|
||||
|
||||
def get_volume(self, name):
|
||||
"""Get reference object of volume specified by name.
|
||||
|
||||
:returns: dict representation of Logical Volume if exists
|
||||
|
||||
"""
|
||||
ref_list = self.get_volumes(name)
|
||||
for r in ref_list:
|
||||
if r['name'] == name:
|
||||
return r
|
||||
return None
|
||||
|
||||
@staticmethod
|
||||
def get_all_physical_volumes(root_helper, vg_name=None):
|
||||
"""Static method to get all PVs on a system.
|
||||
|
||||
:param root_helper: root_helper to use for execute
|
||||
:param vg_name: optional, gathers info for only the specified VG
|
||||
:returns: List of Dictionaries with PV info
|
||||
|
||||
"""
|
||||
field_sep = '|'
|
||||
cmd = LVM.LVM_CMD_PREFIX + ['pvs', '--noheadings',
|
||||
'--unit=g',
|
||||
'-o', 'vg_name,name,size,free',
|
||||
'--separator', field_sep,
|
||||
'--nosuffix']
|
||||
(out, _err) = putils.execute(*cmd,
|
||||
root_helper=root_helper,
|
||||
run_as_root=True)
|
||||
|
||||
pvs = out.split()
|
||||
if vg_name is not None:
|
||||
pvs = [pv for pv in pvs if vg_name == pv.split(field_sep)[0]]
|
||||
|
||||
pv_list = []
|
||||
for pv in pvs:
|
||||
fields = pv.split(field_sep)
|
||||
pv_list.append({'vg': fields[0],
|
||||
'name': fields[1],
|
||||
'size': float(fields[2]),
|
||||
'available': float(fields[3])})
|
||||
return pv_list
|
||||
|
||||
def get_physical_volumes(self):
|
||||
"""Get all PVs associated with this instantiation (VG).
|
||||
|
||||
:returns: List of Dictionaries with PV info
|
||||
|
||||
"""
|
||||
self.pv_list = self.get_all_physical_volumes(self._root_helper,
|
||||
self.vg_name)
|
||||
return self.pv_list
|
||||
|
||||
@staticmethod
|
||||
def get_all_volume_groups(root_helper, vg_name=None):
|
||||
"""Static method to get all VGs on a system.
|
||||
|
||||
:param root_helper: root_helper to use for execute
|
||||
:param vg_name: optional, gathers info for only the specified VG
|
||||
:returns: List of Dictionaries with VG info
|
||||
|
||||
"""
|
||||
cmd = LVM.LVM_CMD_PREFIX + ['vgs', '--noheadings',
|
||||
'--unit=g', '-o',
|
||||
'name,size,free,lv_count,uuid',
|
||||
'--separator', ':',
|
||||
'--nosuffix']
|
||||
if vg_name is not None:
|
||||
cmd.append(vg_name)
|
||||
|
||||
(out, _err) = putils.execute(*cmd,
|
||||
root_helper=root_helper,
|
||||
run_as_root=True)
|
||||
vg_list = []
|
||||
if out is not None:
|
||||
vgs = out.split()
|
||||
for vg in vgs:
|
||||
fields = vg.split(':')
|
||||
vg_list.append({'name': fields[0],
|
||||
'size': float(fields[1]),
|
||||
'available': float(fields[2]),
|
||||
'lv_count': int(fields[3]),
|
||||
'uuid': fields[4]})
|
||||
|
||||
return vg_list
|
||||
|
||||
def update_volume_group_info(self):
|
||||
"""Update VG info for this instantiation.
|
||||
|
||||
Used to update member fields of object and
|
||||
provide a dict of info for caller.
|
||||
|
||||
:returns: Dictionaries of VG info
|
||||
|
||||
"""
|
||||
vg_list = self.get_all_volume_groups(self._root_helper, self.vg_name)
|
||||
|
||||
if len(vg_list) != 1:
|
||||
LOG.error(_LE('Unable to find VG: %s'), self.vg_name)
|
||||
raise exception.VolumeGroupNotFound(vg_name=self.vg_name)
|
||||
|
||||
self.vg_size = float(vg_list[0]['size'])
|
||||
self.vg_free_space = float(vg_list[0]['available'])
|
||||
self.vg_lv_count = int(vg_list[0]['lv_count'])
|
||||
self.vg_uuid = vg_list[0]['uuid']
|
||||
|
||||
total_vols_size = 0.0
|
||||
if self.vg_thin_pool is not None:
|
||||
# NOTE(xyang): If providing only self.vg_name,
|
||||
# get_lv_info will output info on the thin pool and all
|
||||
# individual volumes.
|
||||
# get_lv_info(self._root_helper, 'stack-vg')
|
||||
# sudo lvs --noheadings --unit=g -o vg_name,name,size
|
||||
# --nosuffix stack-vg
|
||||
# stack-vg stack-pool 9.51
|
||||
# stack-vg volume-13380d16-54c3-4979-9d22-172082dbc1a1 1.00
|
||||
# stack-vg volume-629e13ab-7759-46a5-b155-ee1eb20ca892 1.00
|
||||
# stack-vg volume-e3e6281c-51ee-464c-b1a7-db6c0854622c 1.00
|
||||
#
|
||||
# If providing both self.vg_name and self.vg_thin_pool,
|
||||
# get_lv_info will output only info on the thin pool, but not
|
||||
# individual volumes.
|
||||
# get_lv_info(self._root_helper, 'stack-vg', 'stack-pool')
|
||||
# sudo lvs --noheadings --unit=g -o vg_name,name,size
|
||||
# --nosuffix stack-vg/stack-pool
|
||||
# stack-vg stack-pool 9.51
|
||||
#
|
||||
# We need info on both the thin pool and the volumes,
|
||||
# therefore we should provide only self.vg_name, but not
|
||||
# self.vg_thin_pool here.
|
||||
for lv in self.get_lv_info(self._root_helper,
|
||||
self.vg_name):
|
||||
lvsize = lv['size']
|
||||
# get_lv_info runs "lvs" command with "--nosuffix".
|
||||
# This removes "g" from "1.00g" and only outputs "1.00".
|
||||
# Running "lvs" command without "--nosuffix" will output
|
||||
# "1.00g" if "g" is the unit.
|
||||
# Remove the unit if it is in lv['size'].
|
||||
if not lv['size'][-1].isdigit():
|
||||
lvsize = lvsize[:-1]
|
||||
if lv['name'] == self.vg_thin_pool:
|
||||
self.vg_thin_pool_size = lvsize
|
||||
tpfs = self._get_thin_pool_free_space(self.vg_name,
|
||||
self.vg_thin_pool)
|
||||
self.vg_thin_pool_free_space = tpfs
|
||||
else:
|
||||
total_vols_size = total_vols_size + float(lvsize)
|
||||
total_vols_size = round(total_vols_size, 2)
|
||||
|
||||
self.vg_provisioned_capacity = total_vols_size
|
||||
|
||||
def _calculate_thin_pool_size(self):
|
||||
"""Calculates the correct size for a thin pool.
|
||||
|
||||
Ideally we would use 100% of the containing volume group and be done.
|
||||
But the 100%VG notation to lvcreate is not implemented and thus cannot
|
||||
be used. See https://bugzilla.redhat.com/show_bug.cgi?id=998347
|
||||
|
||||
Further, some amount of free space must remain in the volume group for
|
||||
metadata for the contained logical volumes. The exact amount depends
|
||||
on how much volume sharing you expect.
|
||||
|
||||
:returns: An lvcreate-ready string for the number of calculated bytes.
|
||||
"""
|
||||
|
||||
# make sure volume group information is current
|
||||
self.update_volume_group_info()
|
||||
|
||||
# leave 5% free for metadata
|
||||
return "%sg" % (self.vg_free_space * 0.95)
|
||||
|
||||
def create_thin_pool(self, name=None, size_str=None):
|
||||
"""Creates a thin provisioning pool for this VG.
|
||||
|
||||
The syntax here is slightly different than the default
|
||||
lvcreate -T, so we'll just write a custom cmd here
|
||||
and do it.
|
||||
|
||||
:param name: Name to use for pool, default is "<vg-name>-pool"
|
||||
:param size_str: Size to allocate for pool, default is entire VG
|
||||
:returns: The size string passed to the lvcreate command
|
||||
|
||||
"""
|
||||
|
||||
if not self.supports_thin_provisioning(self._root_helper):
|
||||
LOG.error(_LE('Requested to setup thin provisioning, '
|
||||
'however current LVM version does not '
|
||||
'support it.'))
|
||||
return None
|
||||
|
||||
if name is None:
|
||||
name = '%s-pool' % self.vg_name
|
||||
|
||||
vg_pool_name = '%s/%s' % (self.vg_name, name)
|
||||
|
||||
if not size_str:
|
||||
size_str = self._calculate_thin_pool_size()
|
||||
|
||||
cmd = LVM.LVM_CMD_PREFIX + ['lvcreate', '-T', '-L', size_str,
|
||||
vg_pool_name]
|
||||
LOG.debug("Creating thin pool '%(pool)s' with size %(size)s of "
|
||||
"total %(free)sg", {'pool': vg_pool_name,
|
||||
'size': size_str,
|
||||
'free': self.vg_free_space})
|
||||
|
||||
self._execute(*cmd,
|
||||
root_helper=self._root_helper,
|
||||
run_as_root=True)
|
||||
|
||||
self.vg_thin_pool = name
|
||||
return size_str
|
||||
|
||||
def create_volume(self, name, size_str, lv_type='default', mirror_count=0):
|
||||
"""Creates a logical volume on the object's VG.
|
||||
|
||||
:param name: Name to use when creating Logical Volume
|
||||
:param size_str: Size to use when creating Logical Volume
|
||||
:param lv_type: Type of Volume (default or thin)
|
||||
:param mirror_count: Use LVM mirroring with specified count
|
||||
|
||||
"""
|
||||
|
||||
if lv_type == 'thin':
|
||||
pool_path = '%s/%s' % (self.vg_name, self.vg_thin_pool)
|
||||
cmd = LVM.LVM_CMD_PREFIX + ['lvcreate', '-T', '-V', size_str, '-n',
|
||||
name, pool_path]
|
||||
else:
|
||||
cmd = LVM.LVM_CMD_PREFIX + ['lvcreate', '-n', name, self.vg_name,
|
||||
'-L', size_str]
|
||||
|
||||
if mirror_count > 0:
|
||||
cmd.extend(['-m', mirror_count, '--nosync',
|
||||
'--mirrorlog', 'mirrored'])
|
||||
terras = int(size_str[:-1]) / 1024.0
|
||||
if terras >= 1.5:
|
||||
rsize = int(2 ** math.ceil(math.log(terras) / math.log(2)))
|
||||
# NOTE(vish): Next power of two for region size. See:
|
||||
# http://red.ht/U2BPOD
|
||||
cmd.extend(['-R', str(rsize)])
|
||||
|
||||
try:
|
||||
self._execute(*cmd,
|
||||
root_helper=self._root_helper,
|
||||
run_as_root=True)
|
||||
except putils.ProcessExecutionError as err:
|
||||
LOG.exception(_LE('Error creating Volume'))
|
||||
LOG.error(_LE('Cmd :%s'), err.cmd)
|
||||
LOG.error(_LE('StdOut :%s'), err.stdout)
|
||||
LOG.error(_LE('StdErr :%s'), err.stderr)
|
||||
raise
|
||||
|
||||
@utils.retry(putils.ProcessExecutionError)
|
||||
def create_lv_snapshot(self, name, source_lv_name, lv_type='default'):
|
||||
"""Creates a snapshot of a logical volume.
|
||||
|
||||
:param name: Name to assign to new snapshot
|
||||
:param source_lv_name: Name of Logical Volume to snapshot
|
||||
:param lv_type: Type of LV (default or thin)
|
||||
|
||||
"""
|
||||
source_lvref = self.get_volume(source_lv_name)
|
||||
if source_lvref is None:
|
||||
LOG.error(_LE("Trying to create snapshot by non-existent LV: %s"),
|
||||
source_lv_name)
|
||||
raise exception.VolumeDeviceNotFound(device=source_lv_name)
|
||||
cmd = LVM.LVM_CMD_PREFIX + ['lvcreate', '--name', name, '--snapshot',
|
||||
'%s/%s' % (self.vg_name, source_lv_name)]
|
||||
if lv_type != 'thin':
|
||||
size = source_lvref['size']
|
||||
cmd.extend(['-L', '%sg' % (size)])
|
||||
|
||||
try:
|
||||
self._execute(*cmd,
|
||||
root_helper=self._root_helper,
|
||||
run_as_root=True)
|
||||
except putils.ProcessExecutionError as err:
|
||||
LOG.exception(_LE('Error creating snapshot'))
|
||||
LOG.error(_LE('Cmd :%s'), err.cmd)
|
||||
LOG.error(_LE('StdOut :%s'), err.stdout)
|
||||
LOG.error(_LE('StdErr :%s'), err.stderr)
|
||||
raise
|
||||
|
||||
def _mangle_lv_name(self, name):
|
||||
# Linux LVM reserves name that starts with snapshot, so that
|
||||
# such volume name can't be created. Mangle it.
|
||||
if not name.startswith('snapshot'):
|
||||
return name
|
||||
return '_' + name
|
||||
|
||||
def deactivate_lv(self, name):
|
||||
lv_path = self.vg_name + '/' + self._mangle_lv_name(name)
|
||||
cmd = ['lvchange', '-a', 'n']
|
||||
cmd.append(lv_path)
|
||||
try:
|
||||
self._execute(*cmd,
|
||||
root_helper=self._root_helper,
|
||||
run_as_root=True)
|
||||
except putils.ProcessExecutionError as err:
|
||||
LOG.exception(_LE('Error deactivating LV'))
|
||||
LOG.error(_LE('Cmd :%s'), err.cmd)
|
||||
LOG.error(_LE('StdOut :%s'), err.stdout)
|
||||
LOG.error(_LE('StdErr :%s'), err.stderr)
|
||||
raise
|
||||
|
||||
def activate_lv(self, name, is_snapshot=False, permanent=False):
|
||||
"""Ensure that logical volume/snapshot logical volume is activated.
|
||||
|
||||
:param name: Name of LV to activate
|
||||
:param is_snapshot: whether LV is a snapshot
|
||||
:param permanent: whether we should drop skipactivation flag
|
||||
:raises: putils.ProcessExecutionError
|
||||
"""
|
||||
|
||||
# This is a no-op if requested for a snapshot on a version
|
||||
# of LVM that doesn't support snapshot activation.
|
||||
# (Assume snapshot LV is always active.)
|
||||
if is_snapshot and not self.supports_snapshot_lv_activation:
|
||||
return
|
||||
|
||||
lv_path = self.vg_name + '/' + self._mangle_lv_name(name)
|
||||
|
||||
# Must pass --yes to activate both the snap LV and its origin LV.
|
||||
# Otherwise lvchange asks if you would like to do this interactively,
|
||||
# and fails.
|
||||
cmd = ['lvchange', '-a', 'y', '--yes']
|
||||
|
||||
if self.supports_lvchange_ignoreskipactivation:
|
||||
cmd.append('-K')
|
||||
# If permanent=True is specified, drop the skipactivation flag in
|
||||
# order to make this LV automatically activated after next reboot.
|
||||
if permanent:
|
||||
cmd += ['-k', 'n']
|
||||
|
||||
cmd.append(lv_path)
|
||||
|
||||
try:
|
||||
self._execute(*cmd,
|
||||
root_helper=self._root_helper,
|
||||
run_as_root=True)
|
||||
except putils.ProcessExecutionError as err:
|
||||
LOG.exception(_LE('Error activating LV'))
|
||||
LOG.error(_LE('Cmd :%s'), err.cmd)
|
||||
LOG.error(_LE('StdOut :%s'), err.stdout)
|
||||
LOG.error(_LE('StdErr :%s'), err.stderr)
|
||||
raise
|
||||
|
||||
@utils.retry(putils.ProcessExecutionError)
|
||||
def delete(self, name):
|
||||
"""Delete logical volume or snapshot.
|
||||
|
||||
:param name: Name of LV to delete
|
||||
|
||||
"""
|
||||
|
||||
def run_udevadm_settle():
|
||||
self._execute('udevadm', 'settle',
|
||||
root_helper=self._root_helper, run_as_root=True,
|
||||
check_exit_code=False)
|
||||
|
||||
# LV removal seems to be a race with other writers or udev in
|
||||
# some cases (see LP #1270192), so we enable retry deactivation
|
||||
LVM_CONFIG = 'activation { retry_deactivation = 1} '
|
||||
|
||||
try:
|
||||
self._execute(
|
||||
'lvremove',
|
||||
'--config', LVM_CONFIG,
|
||||
'-f',
|
||||
'%s/%s' % (self.vg_name, name),
|
||||
root_helper=self._root_helper, run_as_root=True)
|
||||
except putils.ProcessExecutionError as err:
|
||||
LOG.debug('Error reported running lvremove: CMD: %(command)s, '
|
||||
'RESPONSE: %(response)s',
|
||||
{'command': err.cmd, 'response': err.stderr})
|
||||
|
||||
LOG.debug('Attempting udev settle and retry of lvremove...')
|
||||
run_udevadm_settle()
|
||||
|
||||
# The previous failing lvremove -f might leave behind
|
||||
# suspended devices; when lvmetad is not available, any
|
||||
# further lvm command will block forever.
|
||||
# Therefore we need to skip suspended devices on retry.
|
||||
LVM_CONFIG += 'devices { ignore_suspended_devices = 1}'
|
||||
|
||||
self._execute(
|
||||
'lvremove',
|
||||
'--config', LVM_CONFIG,
|
||||
'-f',
|
||||
'%s/%s' % (self.vg_name, name),
|
||||
root_helper=self._root_helper, run_as_root=True)
|
||||
LOG.debug('Successfully deleted volume: %s after '
|
||||
'udev settle.', name)
|
||||
|
||||
def revert(self, snapshot_name):
|
||||
"""Revert an LV from snapshot.
|
||||
|
||||
:param snapshot_name: Name of snapshot to revert
|
||||
|
||||
"""
|
||||
self._execute('lvconvert', '--merge',
|
||||
snapshot_name, root_helper=self._root_helper,
|
||||
run_as_root=True)
|
||||
|
||||
def lv_has_snapshot(self, name):
|
||||
cmd = LVM.LVM_CMD_PREFIX + ['lvdisplay', '--noheading', '-C', '-o',
|
||||
'Attr', '%s/%s' % (self.vg_name, name)]
|
||||
out, _err = self._execute(*cmd,
|
||||
root_helper=self._root_helper,
|
||||
run_as_root=True)
|
||||
if out:
|
||||
out = out.strip()
|
||||
if (out[0] == 'o') or (out[0] == 'O'):
|
||||
return True
|
||||
return False
|
||||
|
||||
def extend_volume(self, lv_name, new_size):
|
||||
"""Extend the size of an existing volume."""
|
||||
# Volumes with snaps have attributes 'o' or 'O' and will be
|
||||
# deactivated, but Thin Volumes with snaps have attribute 'V'
|
||||
# and won't be deactivated because the lv_has_snapshot method looks
|
||||
# for 'o' or 'O'
|
||||
if self.lv_has_snapshot(lv_name):
|
||||
self.deactivate_lv(lv_name)
|
||||
try:
|
||||
cmd = LVM.LVM_CMD_PREFIX + ['lvextend', '-L', new_size,
|
||||
'%s/%s' % (self.vg_name, lv_name)]
|
||||
self._execute(*cmd, root_helper=self._root_helper,
|
||||
run_as_root=True)
|
||||
except putils.ProcessExecutionError as err:
|
||||
LOG.exception(_LE('Error extending Volume'))
|
||||
LOG.error(_LE('Cmd :%s'), err.cmd)
|
||||
LOG.error(_LE('StdOut :%s'), err.stdout)
|
||||
LOG.error(_LE('StdErr :%s'), err.stderr)
|
||||
raise
|
||||
|
||||
def vg_mirror_free_space(self, mirror_count):
|
||||
free_capacity = 0.0
|
||||
|
||||
disks = []
|
||||
for pv in self.pv_list:
|
||||
disks.append(float(pv['available']))
|
||||
|
||||
while True:
|
||||
disks = sorted([a for a in disks if a > 0.0], reverse=True)
|
||||
if len(disks) <= mirror_count:
|
||||
break
|
||||
# consume the smallest disk
|
||||
disk = disks[-1]
|
||||
disks = disks[:-1]
|
||||
# match extents for each mirror on the largest disks
|
||||
for index in list(range(mirror_count)):
|
||||
disks[index] -= disk
|
||||
free_capacity += disk
|
||||
|
||||
return free_capacity
|
||||
|
||||
def vg_mirror_size(self, mirror_count):
|
||||
return (self.vg_free_space / (mirror_count + 1))
|
||||
|
||||
def rename_volume(self, lv_name, new_name):
|
||||
"""Change the name of an existing volume."""
|
||||
|
||||
try:
|
||||
self._execute('lvrename', self.vg_name, lv_name, new_name,
|
||||
root_helper=self._root_helper,
|
||||
run_as_root=True)
|
||||
except putils.ProcessExecutionError as err:
|
||||
LOG.exception(_LE('Error renaming logical volume'))
|
||||
LOG.error(_LE('Cmd :%s'), err.cmd)
|
||||
LOG.error(_LE('StdOut :%s'), err.stdout)
|
||||
LOG.error(_LE('StdErr :%s'), err.stderr)
|
||||
raise
|
||||
0
os_brick/tests/local_dev/__init__.py
Normal file
0
os_brick/tests/local_dev/__init__.py
Normal file
63
os_brick/tests/local_dev/fake_lvm.py
Normal file
63
os_brick/tests/local_dev/fake_lvm.py
Normal file
@ -0,0 +1,63 @@
|
||||
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
# not use this file except in compliance with the License. You may obtain
|
||||
# a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
|
||||
class FakeBrickLVM(object):
|
||||
"""Logs and records calls, for unit tests."""
|
||||
|
||||
def __init__(self, vg_name, create, pv_list, vtype, execute=None):
|
||||
super(FakeBrickLVM, self).__init__()
|
||||
self.vg_size = '5.00'
|
||||
self.vg_free_space = '5.00'
|
||||
self.vg_name = vg_name
|
||||
|
||||
def supports_thin_provisioning():
|
||||
return False
|
||||
|
||||
def get_volumes(self):
|
||||
return ['fake-volume']
|
||||
|
||||
def get_volume(self, name):
|
||||
return ['name']
|
||||
|
||||
def get_all_physical_volumes(vg_name=None):
|
||||
return []
|
||||
|
||||
def get_physical_volumes(self):
|
||||
return []
|
||||
|
||||
def update_volume_group_info(self):
|
||||
pass
|
||||
|
||||
def create_thin_pool(self, name=None, size_str=0):
|
||||
pass
|
||||
|
||||
def create_volume(self, name, size_str, lv_type='default', mirror_count=0):
|
||||
pass
|
||||
|
||||
def create_lv_snapshot(self, name, source_lv_name, lv_type='default'):
|
||||
pass
|
||||
|
||||
def delete(self, name):
|
||||
pass
|
||||
|
||||
def revert(self, snapshot_name):
|
||||
pass
|
||||
|
||||
def lv_has_snapshot(self, name):
|
||||
return False
|
||||
|
||||
def activate_lv(self, lv, is_snapshot=False, permanent=False):
|
||||
pass
|
||||
|
||||
def rename_volume(self, lv_name, new_name):
|
||||
pass
|
||||
365
os_brick/tests/local_dev/test_brick_lvm.py
Normal file
365
os_brick/tests/local_dev/test_brick_lvm.py
Normal file
@ -0,0 +1,365 @@
|
||||
# Copyright 2012 OpenStack Foundation
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
# not use this file except in compliance with the License. You may obtain
|
||||
# a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
import mock
|
||||
from oslo_concurrency import processutils
|
||||
|
||||
from os_brick import exception
|
||||
from os_brick.local_dev import lvm as brick
|
||||
from os_brick.tests import base
|
||||
|
||||
|
||||
class BrickLvmTestCase(base.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
super(BrickLvmTestCase, self).setUp()
|
||||
self.volume_group_name = 'fake-vg'
|
||||
|
||||
# Stub processutils.execute for static methods
|
||||
self.mock_object(processutils, 'execute',
|
||||
self.fake_execute)
|
||||
self.vg = brick.LVM(self.volume_group_name,
|
||||
'sudo',
|
||||
create_vg=False,
|
||||
physical_volumes=None,
|
||||
lvm_type='default',
|
||||
executor=self.fake_execute)
|
||||
|
||||
def failed_fake_execute(obj, *cmd, **kwargs):
|
||||
return ("\n", "fake-error")
|
||||
|
||||
def fake_pretend_lvm_version(obj, *cmd, **kwargs):
|
||||
return (" LVM version: 2.03.00 (2012-03-06)\n", "")
|
||||
|
||||
def fake_old_lvm_version(obj, *cmd, **kwargs):
|
||||
# Does not support thin prov or snap activation
|
||||
return (" LVM version: 2.02.65(2) (2012-03-06)\n", "")
|
||||
|
||||
def fake_customised_lvm_version(obj, *cmd, **kwargs):
|
||||
return (" LVM version: 2.02.100(2)-RHEL6 (2013-09-12)\n", "")
|
||||
|
||||
def fake_execute(obj, *cmd, **kwargs):
|
||||
cmd_string = ', '.join(cmd)
|
||||
data = "\n"
|
||||
|
||||
if ('env, LC_ALL=C, vgs, --noheadings, --unit=g, -o, name' ==
|
||||
cmd_string):
|
||||
data = " fake-vg\n"
|
||||
data += " some-other-vg\n"
|
||||
elif ('env, LC_ALL=C, vgs, --noheadings, -o, name, fake-vg' ==
|
||||
cmd_string):
|
||||
data = " fake-vg\n"
|
||||
elif 'env, LC_ALL=C, vgs, --version' in cmd_string:
|
||||
data = " LVM version: 2.02.95(2) (2012-03-06)\n"
|
||||
elif ('env, LC_ALL=C, vgs, --noheadings, -o, uuid, fake-vg' in
|
||||
cmd_string):
|
||||
data = " kVxztV-dKpG-Rz7E-xtKY-jeju-QsYU-SLG6Z1\n"
|
||||
elif 'env, LC_ALL=C, vgs, --noheadings, --unit=g, ' \
|
||||
'-o, name,size,free,lv_count,uuid, ' \
|
||||
'--separator, :, --nosuffix' in cmd_string:
|
||||
data = (" test-prov-cap-vg-unit:10.00:10.00:0:"
|
||||
"mXzbuX-dKpG-Rz7E-xtKY-jeju-QsYU-SLG8Z4\n")
|
||||
if 'test-prov-cap-vg-unit' in cmd_string:
|
||||
return (data, "")
|
||||
data = (" test-prov-cap-vg-no-unit:10.00:10.00:0:"
|
||||
"mXzbuX-dKpG-Rz7E-xtKY-jeju-QsYU-SLG8Z4\n")
|
||||
if 'test-prov-cap-vg-no-unit' in cmd_string:
|
||||
return (data, "")
|
||||
data = " fake-vg:10.00:10.00:0:"\
|
||||
"kVxztV-dKpG-Rz7E-xtKY-jeju-QsYU-SLG6Z1\n"
|
||||
if 'fake-vg' in cmd_string:
|
||||
return (data, "")
|
||||
data += " fake-vg-2:10.00:10.00:0:"\
|
||||
"lWyauW-dKpG-Rz7E-xtKY-jeju-QsYU-SLG7Z2\n"
|
||||
data += " fake-vg-3:10.00:10.00:0:"\
|
||||
"mXzbuX-dKpG-Rz7E-xtKY-jeju-QsYU-SLG8Z3\n"
|
||||
elif ('env, LC_ALL=C, lvs, --noheadings, '
|
||||
'--unit=g, -o, vg_name,name,size, --nosuffix, '
|
||||
'fake-vg/lv-nothere' in cmd_string):
|
||||
raise processutils.ProcessExecutionError(
|
||||
stderr="One or more specified logical volume(s) not found.")
|
||||
elif ('env, LC_ALL=C, lvs, --noheadings, '
|
||||
'--unit=g, -o, vg_name,name,size, --nosuffix, '
|
||||
'fake-vg/lv-newerror' in cmd_string):
|
||||
raise processutils.ProcessExecutionError(
|
||||
stderr="Failed to find logical volume \"fake-vg/lv-newerror\"")
|
||||
elif ('env, LC_ALL=C, lvs, --noheadings, '
|
||||
'--unit=g, -o, vg_name,name,size' in cmd_string):
|
||||
if 'fake-unknown' in cmd_string:
|
||||
raise processutils.ProcessExecutionError(
|
||||
stderr="One or more volume(s) not found."
|
||||
)
|
||||
if 'test-prov-cap-vg-unit' in cmd_string:
|
||||
data = " fake-vg test-prov-cap-pool-unit 9.50g\n"
|
||||
data += " fake-vg fake-volume-1 1.00g\n"
|
||||
data += " fake-vg fake-volume-2 2.00g\n"
|
||||
elif 'test-prov-cap-vg-no-unit' in cmd_string:
|
||||
data = " fake-vg test-prov-cap-pool-no-unit 9.50\n"
|
||||
data += " fake-vg fake-volume-1 1.00\n"
|
||||
data += " fake-vg fake-volume-2 2.00\n"
|
||||
elif 'test-found-lv-name' in cmd_string:
|
||||
data = " fake-vg test-found-lv-name 9.50\n"
|
||||
else:
|
||||
data = " fake-vg fake-1 1.00g\n"
|
||||
data += " fake-vg fake-2 1.00g\n"
|
||||
elif ('env, LC_ALL=C, lvdisplay, --noheading, -C, -o, Attr' in
|
||||
cmd_string):
|
||||
if 'test-volumes' in cmd_string:
|
||||
data = ' wi-a-'
|
||||
else:
|
||||
data = ' owi-a-'
|
||||
elif 'env, LC_ALL=C, pvs, --noheadings' in cmd_string:
|
||||
data = " fake-vg|/dev/sda|10.00|1.00\n"
|
||||
data += " fake-vg|/dev/sdb|10.00|1.00\n"
|
||||
data += " fake-vg|/dev/sdc|10.00|8.99\n"
|
||||
data += " fake-vg-2|/dev/sdd|10.00|9.99\n"
|
||||
elif 'env, LC_ALL=C, lvs, --noheadings, --unit=g' \
|
||||
', -o, size,data_percent, --separator, :' in cmd_string:
|
||||
if 'test-prov-cap-pool' in cmd_string:
|
||||
data = " 9.5:20\n"
|
||||
else:
|
||||
data = " 9:12\n"
|
||||
elif 'lvcreate, -T, -L, ' in cmd_string:
|
||||
pass
|
||||
elif 'lvcreate, -T, -V, ' in cmd_string:
|
||||
pass
|
||||
elif 'lvcreate, -n, ' in cmd_string:
|
||||
pass
|
||||
elif 'lvcreate, --name, ' in cmd_string:
|
||||
pass
|
||||
elif 'lvextend, -L, ' in cmd_string:
|
||||
pass
|
||||
else:
|
||||
raise AssertionError('unexpected command called: %s' % cmd_string)
|
||||
|
||||
return (data, "")
|
||||
|
||||
def test_create_lv_snapshot(self):
|
||||
self.assertIsNone(self.vg.create_lv_snapshot('snapshot-1', 'fake-1'))
|
||||
|
||||
with mock.patch.object(self.vg, 'get_volume', return_value=None):
|
||||
try:
|
||||
self.vg.create_lv_snapshot('snapshot-1', 'fake-non-existent')
|
||||
except exception.VolumeDeviceNotFound as e:
|
||||
self.assertEqual('fake-non-existent', e.kwargs['device'])
|
||||
else:
|
||||
self.fail("Exception not raised")
|
||||
|
||||
def test_vg_exists(self):
|
||||
self.assertTrue(self.vg._vg_exists())
|
||||
|
||||
def test_get_vg_uuid(self):
|
||||
self.assertEqual('kVxztV-dKpG-Rz7E-xtKY-jeju-QsYU-SLG6Z1',
|
||||
self.vg._get_vg_uuid()[0])
|
||||
|
||||
def test_get_all_volumes(self):
|
||||
out = self.vg.get_volumes()
|
||||
|
||||
self.assertEqual('fake-1', out[0]['name'])
|
||||
self.assertEqual('1.00g', out[0]['size'])
|
||||
self.assertEqual('fake-vg', out[0]['vg'])
|
||||
|
||||
def test_get_volume(self):
|
||||
self.assertEqual('fake-1', self.vg.get_volume('fake-1')['name'])
|
||||
|
||||
def test_get_volume_none(self):
|
||||
self.assertIsNone(self.vg.get_volume('fake-unknown'))
|
||||
|
||||
def test_get_lv_info_notfound(self):
|
||||
# lv-nothere will raise lvm < 2.102.112 exception
|
||||
self.assertEqual(
|
||||
[],
|
||||
self.vg.get_lv_info(
|
||||
'sudo', vg_name='fake-vg', lv_name='lv-nothere')
|
||||
)
|
||||
# lv-newerror will raise lvm > 2.102.112 exception
|
||||
self.assertEqual(
|
||||
[],
|
||||
self.vg.get_lv_info(
|
||||
'sudo', vg_name='fake-vg', lv_name='lv-newerror')
|
||||
)
|
||||
|
||||
def test_get_lv_info_found(self):
|
||||
lv_info = [{'size': '9.50', 'name': 'test-found-lv-name',
|
||||
'vg': 'fake-vg'}]
|
||||
self.assertEqual(
|
||||
lv_info,
|
||||
self.vg.get_lv_info(
|
||||
'sudo', vg_name='fake-vg',
|
||||
lv_name='test-found-lv-name')
|
||||
)
|
||||
|
||||
def test_get_lv_info_no_lv_name(self):
|
||||
lv_info = [{'name': 'fake-1', 'size': '1.00g', 'vg': 'fake-vg'},
|
||||
{'name': 'fake-2', 'size': '1.00g', 'vg': 'fake-vg'}]
|
||||
self.assertEqual(
|
||||
lv_info,
|
||||
self.vg.get_lv_info(
|
||||
'sudo', vg_name='fake-vg')
|
||||
)
|
||||
|
||||
def test_get_all_physical_volumes(self):
|
||||
# Filtered VG version
|
||||
pvs = self.vg.get_all_physical_volumes('sudo', 'fake-vg')
|
||||
self.assertEqual(3, len(pvs))
|
||||
|
||||
# Non-Filtered, all VG's
|
||||
pvs = self.vg.get_all_physical_volumes('sudo')
|
||||
self.assertEqual(4, len(pvs))
|
||||
|
||||
def test_get_physical_volumes(self):
|
||||
pvs = self.vg.get_physical_volumes()
|
||||
self.assertEqual(3, len(pvs))
|
||||
|
||||
def test_get_volume_groups(self):
|
||||
self.assertEqual(3, len(self.vg.get_all_volume_groups('sudo')))
|
||||
self.assertEqual(1,
|
||||
len(self.vg.get_all_volume_groups('sudo', 'fake-vg')))
|
||||
|
||||
def test_thin_support(self):
|
||||
# lvm.supports_thin() is a static method and doesn't
|
||||
# use the self._executor fake we pass in on init
|
||||
# so we need to stub processutils.execute appropriately
|
||||
|
||||
with mock.patch.object(processutils, 'execute',
|
||||
side_effect=self.fake_execute):
|
||||
self.assertTrue(self.vg.supports_thin_provisioning('sudo'))
|
||||
|
||||
with mock.patch.object(processutils, 'execute',
|
||||
side_effect=self.fake_pretend_lvm_version):
|
||||
self.assertTrue(self.vg.supports_thin_provisioning('sudo'))
|
||||
|
||||
with mock.patch.object(processutils, 'execute',
|
||||
side_effect=self.fake_old_lvm_version):
|
||||
self.assertFalse(self.vg.supports_thin_provisioning('sudo'))
|
||||
|
||||
with mock.patch.object(processutils, 'execute',
|
||||
side_effect=self.fake_customised_lvm_version):
|
||||
self.assertTrue(self.vg.supports_thin_provisioning('sudo'))
|
||||
|
||||
def test_snapshot_lv_activate_support(self):
|
||||
self.vg._supports_snapshot_lv_activation = None
|
||||
with mock.patch.object(processutils, 'execute',
|
||||
side_effect=self.fake_execute):
|
||||
self.assertTrue(self.vg.supports_snapshot_lv_activation)
|
||||
|
||||
self.vg._supports_snapshot_lv_activation = None
|
||||
with mock.patch.object(processutils, 'execute',
|
||||
side_effect=self.fake_old_lvm_version):
|
||||
self.assertFalse(self.vg.supports_snapshot_lv_activation)
|
||||
|
||||
self.vg._supports_snapshot_lv_activation = None
|
||||
|
||||
def test_lvchange_ignskipact_support_yes(self):
|
||||
"""Tests if lvchange -K is available via a lvm2 version check."""
|
||||
|
||||
self.vg._supports_lvchange_ignoreskipactivation = None
|
||||
with mock.patch.object(processutils, 'execute',
|
||||
side_effect=self.fake_pretend_lvm_version):
|
||||
self.assertTrue(self.vg.supports_lvchange_ignoreskipactivation)
|
||||
|
||||
self.vg._supports_lvchange_ignoreskipactivation = None
|
||||
with mock.patch.object(processutils, 'execute',
|
||||
side_effect=self.fake_old_lvm_version):
|
||||
self.assertFalse(self.vg.supports_lvchange_ignoreskipactivation)
|
||||
|
||||
self.vg._supports_lvchange_ignoreskipactivation = None
|
||||
|
||||
def test_thin_pool_creation(self):
|
||||
|
||||
# The size of fake-vg volume group is 10g, so the calculated thin
|
||||
# pool size should be 9.5g (95% of 10g).
|
||||
self.assertEqual("9.5g", self.vg.create_thin_pool())
|
||||
|
||||
# Passing a size parameter should result in a thin pool of that exact
|
||||
# size.
|
||||
for size in ("1g", "1.2g", "1.75g"):
|
||||
self.assertEqual(size, self.vg.create_thin_pool(size_str=size))
|
||||
|
||||
def test_thin_pool_provisioned_capacity(self):
|
||||
self.vg.vg_thin_pool = "test-prov-cap-pool-unit"
|
||||
self.vg.vg_name = 'test-prov-cap-vg-unit'
|
||||
self.assertEqual(
|
||||
"9.5g",
|
||||
self.vg.create_thin_pool(name=self.vg.vg_thin_pool))
|
||||
self.assertEqual("9.50", self.vg.vg_thin_pool_size)
|
||||
self.assertEqual(7.6, self.vg.vg_thin_pool_free_space)
|
||||
self.assertEqual(3.0, self.vg.vg_provisioned_capacity)
|
||||
|
||||
self.vg.vg_thin_pool = "test-prov-cap-pool-no-unit"
|
||||
self.vg.vg_name = 'test-prov-cap-vg-no-unit'
|
||||
self.assertEqual(
|
||||
"9.5g",
|
||||
self.vg.create_thin_pool(name=self.vg.vg_thin_pool))
|
||||
self.assertEqual("9.50", self.vg.vg_thin_pool_size)
|
||||
self.assertEqual(7.6, self.vg.vg_thin_pool_free_space)
|
||||
self.assertEqual(3.0, self.vg.vg_provisioned_capacity)
|
||||
|
||||
def test_thin_pool_free_space(self):
|
||||
# The size of fake-vg-pool is 9g and the allocated data sums up to
|
||||
# 12% so the calculated free space should be 7.92
|
||||
self.assertEqual(float("7.92"),
|
||||
self.vg._get_thin_pool_free_space("fake-vg",
|
||||
"fake-vg-pool"))
|
||||
|
||||
def test_volume_create_after_thin_creation(self):
|
||||
"""Test self.vg.vg_thin_pool is set to pool_name
|
||||
|
||||
See bug #1220286 for more info.
|
||||
"""
|
||||
|
||||
vg_name = "vg-name"
|
||||
pool_name = vg_name + "-pool"
|
||||
pool_path = "%s/%s" % (vg_name, pool_name)
|
||||
|
||||
def executor(obj, *cmd, **kwargs):
|
||||
self.assertEqual(pool_path, cmd[-1])
|
||||
|
||||
self.vg._executor = executor
|
||||
self.vg.create_thin_pool(pool_name, "1G")
|
||||
self.vg.create_volume("test", "1G", lv_type='thin')
|
||||
|
||||
self.assertEqual(pool_name, self.vg.vg_thin_pool)
|
||||
|
||||
def test_lv_has_snapshot(self):
|
||||
self.assertTrue(self.vg.lv_has_snapshot('fake-vg'))
|
||||
self.assertFalse(self.vg.lv_has_snapshot('test-volumes'))
|
||||
|
||||
def test_activate_lv(self):
|
||||
self.vg._supports_lvchange_ignoreskipactivation = True
|
||||
|
||||
with mock.patch.object(self.vg, '_execute') as mock_exec:
|
||||
self.vg.activate_lv('my-lv')
|
||||
expected = [mock.call('lvchange', '-a', 'y', '--yes', '-K',
|
||||
'fake-vg/my-lv', root_helper='sudo',
|
||||
run_as_root=True)]
|
||||
self.assertEqual(expected, mock_exec.call_args_list)
|
||||
|
||||
def test_get_mirrored_available_capacity(self):
|
||||
self.assertEqual(2.0, self.vg.vg_mirror_free_space(1))
|
||||
|
||||
def test_lv_extend(self):
|
||||
self.vg.deactivate_lv = mock.MagicMock()
|
||||
|
||||
# Extend lv with snapshot and make sure deactivate called
|
||||
self.vg.create_volume("test", "1G")
|
||||
self.vg.extend_volume("test", "2G")
|
||||
self.vg.deactivate_lv.assert_called_once_with('test')
|
||||
self.vg.deactivate_lv.reset_mock()
|
||||
|
||||
# Extend lv without snapshot so deactivate should not be called
|
||||
self.vg.create_volume("test", "1G")
|
||||
self.vg.vg_name = "test-volumes"
|
||||
self.vg.extend_volume("test", "2G")
|
||||
self.assertFalse(self.vg.deactivate_lv.called)
|
||||
Loading…
Reference in New Issue
Block a user