Merge "Add config option reserved_share_from_snapshot_percentage."

This commit is contained in:
Zuul 2021-08-30 19:46:52 +00:00 committed by Gerrit Code Review
commit b50a0bb9de
68 changed files with 351 additions and 21 deletions

@ -329,6 +329,7 @@ class FilterScheduler(base.Scheduler):
)
filter_properties['user_id'] = shr.get('user_id')
filter_properties['metadata'] = shr.get('metadata')
filter_properties['snapshot_id'] = shr.get('snapshot_id')
def schedule_create_share_group(self, context, share_group_id,
request_spec, filter_properties):

@ -42,7 +42,11 @@ class CapacityFilter(base_host.BaseHostFilter):
free_space = host_state.free_capacity_gb
total_space = host_state.total_capacity_gb
reserved = float(host_state.reserved_percentage) / 100
if filter_properties.get('snapshot_id'):
reserved = float(host_state.reserved_snapshot_percentage) / 100
else:
reserved = float(host_state.reserved_percentage) / 100
if free_space == 'unknown':
# NOTE(zhiteng) for those back-ends cannot report actual
# available capacity, we assume it is able to serve the

@ -127,6 +127,7 @@ class HostState(object):
self.total_capacity_gb = 0
self.free_capacity_gb = None
self.reserved_percentage = 0
self.reserved_snapshot_percentage = 0
self.allocated_capacity_gb = 0
# NOTE(xyang): The apparent allocated space indicating how much
# capacity has been provisioned. This could be the sum of sizes
@ -185,12 +186,13 @@ class HostState(object):
'pools':[
{
'pool_name': '1st pool', #\
'total_capacity_gb': 500, # mandatory stats
'free_capacity_gb': 230, # for pools
'allocated_capacity_gb': 270, # |
'qos': 'False', # |
'reserved_percentage': 0, #/
'pool_name': '1st pool', #\
'total_capacity_gb': 500, # mandatory stats
'free_capacity_gb': 230, # for pools
'allocated_capacity_gb': 270, # |
'qos': 'False', # |
'reserved_percentage': 0, # |
'reserved_snapshot_percentage': 0, #/
'dying_disks': 100, #\
'super_hero_1': 'spider-man', # optional custom
@ -205,6 +207,7 @@ class HostState(object):
'allocated_capacity_gb': 0,
'qos': 'False',
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'dying_disks': 200,
'super_hero_1': 'superman',
@ -434,6 +437,8 @@ class PoolState(HostState):
'allocated_capacity_gb', 0)
self.qos = capability.get('qos', False)
self.reserved_percentage = capability['reserved_percentage']
self.reserved_snapshot_percentage = (
capability['reserved_snapshot_percentage'])
self.thin_provisioning = scheduler_utils.thin_provisioning(
capability.get('thin_provisioning', False))
# NOTE(xyang): provisioned_capacity_gb is the apparent total

@ -36,6 +36,8 @@ def generate_stats(host_state, properties):
'allocated_capacity_gb': host_state.allocated_capacity_gb,
'free_capacity_gb': host_state.free_capacity_gb,
'reserved_percentage': host_state.reserved_percentage,
'reserved_snapshot_percentage':
host_state.reserved_snapshot_percentage,
'driver_handles_share_servers':
host_state.driver_handles_share_servers,
'thin_provisioning': host_state.thin_provisioning,

@ -52,7 +52,11 @@ class CapacityWeigher(base_host.BaseHostWeigher):
def _weigh_object(self, host_state, weight_properties):
"""Higher weighers win. We want spreading to be the default."""
reserved = float(host_state.reserved_percentage) / 100
if weight_properties.get('snapshot_id'):
reserved = float(host_state.reserved_snapshot_percentage) / 100
else:
reserved = float(host_state.reserved_percentage) / 100
free_space = host_state.free_capacity_gb
total_space = host_state.total_capacity_gb
if 'unknown' in (total_space, free_space):

@ -41,7 +41,17 @@ share_opts = [
cfg.IntOpt(
'reserved_share_percentage',
default=0,
help='The percentage of backend capacity reserved.'),
help="The percentage of backend capacity reserved. Used for shares "
"which are not created from the snapshot."),
cfg.IntOpt(
'reserved_share_from_snapshot_percentage',
default=0,
help="The percentage of backend capacity reserved. Used for shares "
"created from the snapshot. On some platforms, shares can only "
"be created from the snapshot on the host where snapshot was "
"taken, so we can set a lower value in this option compared to "
"reserved_share_percentage, and allow to create shares from the "
"snapshot on the same host up to a higher threshold."),
cfg.StrOpt(
'share_backend_name',
help='The backend name for a given driver implementation.'),
@ -1301,6 +1311,7 @@ class ShareDriver(object):
total_capacity_gb='unknown',
free_capacity_gb='unknown',
reserved_percentage=0,
reserved_snapshot_percentage=0,
qos=False,
pools=self.pools or None,
snapshot_support=self.snapshots_are_supported,

@ -276,6 +276,11 @@ class CephFSDriver(driver.ExecuteMixin, driver.GaneshaMixin,
'qos': 'False',
'reserved_percentage': self.configuration.safe_get(
'reserved_share_percentage'),
'reserved_snapshot_percentage':
self.configuration.safe_get(
'reserved_share_from_snapshot_percentage') or
self.configuration.safe_get(
'reserved_share_percentage'),
'dedupe': [False],
'compression': [False],
'thin_provisioning': [False]

@ -122,6 +122,9 @@ class ContainerShareDriver(driver.ShareDriver, driver.ExecuteMixin):
'storage_protocol': 'CIFS',
'reserved_percentage':
self.configuration.reserved_share_percentage,
'reserved_snapshot_percentage':
self.configuration.reserved_share_from_snapshot_percentage or
self.configuration.reserved_share_percentage,
'consistency_group_support': None,
'snapshot_support': False,
'create_share_from_snapshot_support': False,

@ -70,6 +70,7 @@ class LVMHelper(driver.ExecuteMixin):
'total_capacity_gb': float(total_size),
'free_capacity_gb': float(free_size),
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
}, ]
def _get_lv_device(self, share_name):

@ -81,6 +81,7 @@ class PowerMaxStorageConnection(driver.StorageConnection):
self.manager = None
self.pool_conf = None
self.reserved_percentage = None
self.reserved_snapshot_percentage = None
self.driver_handles_share_servers = True
self.port_conf = None
self.ipv6_implemented = True
@ -594,6 +595,11 @@ class PowerMaxStorageConnection(driver.StorageConnection):
if self.reserved_percentage is None:
self.reserved_percentage = 0
self.reserved_snapshot_percentage = config.safe_get(
'reserved_share_from_snapshot_percentage')
if self.reserved_snapshot_percentage is None:
self.reserved_snapshot_percentage = self.reserved_percentage
self.manager = manager.StorageObjectManager(config)
self.port_conf = config.safe_get('powermax_ethernet_ports')
@ -642,6 +648,8 @@ class PowerMaxStorageConnection(driver.StorageConnection):
enas_utils.mb_to_gb(total_size - used_size),
'qos': False,
'reserved_percentage': self.reserved_percentage,
'reserved_snapshot_percentage':
self.reserved_snapshot_percentage,
'snapshot_support': True,
'create_share_from_snapshot_support': True,
'revert_to_snapshot_support': False,

@ -92,6 +92,7 @@ class UnityStorageConnection(driver.StorageConnection):
self.pool_set = None
self.nas_server_pool = None
self.reserved_percentage = None
self.reserved_snapshot_percentage = None
self.max_over_subscription_ratio = None
self.port_ids_conf = None
self.unity_share_server = None
@ -129,6 +130,11 @@ class UnityStorageConnection(driver.StorageConnection):
if self.reserved_percentage is None:
self.reserved_percentage = 0
self.reserved_snapshot_percentage = config.safe_get(
'reserved_share_from_snapshot_percentage')
if self.reserved_snapshot_percentage is None:
self.reserved_snapshot_percentage = self.reserved_percentage
self.max_over_subscription_ratio = config.safe_get(
'max_over_subscription_ratio')
self.port_ids_conf = config.safe_get('unity_ethernet_ports')
@ -585,6 +591,8 @@ class UnityStorageConnection(driver.StorageConnection):
enas_utils.bytes_to_gb(pool.size_subscribed),
'qos': False,
'reserved_percentage': self.reserved_percentage,
'reserved_snapshot_percentage':
self.reserved_snapshot_percentage,
'max_over_subscription_ratio':
self.max_over_subscription_ratio,
}

@ -78,6 +78,7 @@ class VNXStorageConnection(driver.StorageConnection):
self.manager = None
self.pool_conf = None
self.reserved_percentage = None
self.reserved_snapshot_percentage = None
self.driver_handles_share_servers = True
self.port_conf = None
self.ipv6_implemented = True
@ -588,6 +589,11 @@ class VNXStorageConnection(driver.StorageConnection):
if self.reserved_percentage is None:
self.reserved_percentage = 0
self.reserved_snapshot_percentage = config.safe_get(
'reserved_share_from_snapshot_percentage')
if self.reserved_snapshot_percentage is None:
self.reserved_snapshot_percentage = self.reserved_percentage
self.manager = manager.StorageObjectManager(config)
self.port_conf = config.safe_get('vnx_ethernet_ports')
@ -636,6 +642,8 @@ class VNXStorageConnection(driver.StorageConnection):
total_size - used_size),
qos=False,
reserved_percentage=self.reserved_percentage,
reserved_snapshot_percentage=(
self.reserved_snapshot_percentage),
)
stats_dict['pools'].append(pool_stat)

@ -635,6 +635,9 @@ class GenericShareDriver(driver.ExecuteMixin, driver.ShareDriver):
share_backend_name=self.backend_name,
storage_protocol='NFS_CIFS',
reserved_percentage=self.configuration.reserved_share_percentage,
reserved_snapshot_percentage=(
self.configuration.reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage),
)
super(GenericShareDriver, self)._update_share_stats(data)

@ -122,7 +122,10 @@ class GlusterfsShareDriver(driver.ExecuteMixin, driver.GaneshaMixin,
storage_protocol='NFS',
vendor_name='Red Hat',
share_backend_name=self.backend_name,
reserved_percentage=self.configuration.reserved_share_percentage)
reserved_percentage=self.configuration.reserved_share_percentage,
reserved_snapshot_percentage=(
self.configuration.reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage))
super(GlusterfsShareDriver, self)._update_share_stats(data)
def get_network_allocations_number(self):

@ -195,7 +195,10 @@ class GlusterfsNativeShareDriver(driver.ExecuteMixin,
vendor_name='Red Hat',
driver_version='1.1',
storage_protocol='glusterfs',
reserved_percentage=self.configuration.reserved_share_percentage)
reserved_percentage=self.configuration.reserved_share_percentage,
reserved_snapshot_percentage=(
self.configuration.reserved_share_from_snapshot_percentage or
self.configuration.reserved_share_percentage))
# We don't use a service mount to get stats data.
# Instead we use glusterfs quota feature and use that to limit

@ -427,7 +427,10 @@ class HDFSNativeShareDriver(driver.ExecuteMixin, driver.ShareDriver):
data = dict(share_backend_name=self.backend_name,
storage_protocol='HDFS',
reserved_percentage=self.configuration.
reserved_share_percentage)
reserved_share_percentage,
reserved_snapshot_percentage=self.configuration.
reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage)
total, free = self._get_available_capacity()

@ -612,6 +612,8 @@ class HitachiHNASDriver(driver.ShareDriver):
total_space, free_space, dedupe = self.hnas.get_stats()
reserved = self.configuration.safe_get('reserved_share_percentage')
reserved_snapshot = self.configuration.safe_get(
'reserved_share_from_snapshot_percentage') or reserved
data = {
'share_backend_name': self.backend_name,
@ -622,6 +624,7 @@ class HitachiHNASDriver(driver.ShareDriver):
'total_capacity_gb': total_space,
'free_capacity_gb': free_space,
'reserved_percentage': reserved,
'reserved_snapshot_percentage': reserved_snapshot,
'qos': False,
'thin_provisioning': True,
'dedupe': dedupe,

@ -67,6 +67,9 @@ class HitachiHSPDriver(driver.ShareDriver):
LOG.debug("Updating Backend Capability Information - Hitachi HSP.")
reserved = self.configuration.safe_get('reserved_share_percentage')
reserved_snapshot = (self.configuration.safe_get(
'reserved_share_from_snapshot_percentage') or
self.configuration.safe_get('reserved_share_percentage'))
max_over_subscription_ratio = self.configuration.safe_get(
'max_over_subscription_ratio')
hsp_cluster = self.hsp.get_cluster()
@ -81,6 +84,7 @@ class HitachiHSPDriver(driver.ShareDriver):
'storage_protocol': 'NFS',
'pools': [{
'reserved_percentage': reserved,
'reserved_snapshot_percentage': reserved_snapshot,
'pool_name': 'HSP',
'thin_provisioning': True,
'total_capacity_gb': total_space / units.Gi,

@ -606,6 +606,11 @@ class HPE3ParShareDriver(driver.ShareDriver):
if reserved_share_percentage is None:
reserved_share_percentage = 0
reserved_share_from_snapshot_percentage = self.configuration.safe_get(
'reserved_share_from_snapshot_percentage')
if reserved_share_from_snapshot_percentage is None:
reserved_share_from_snapshot_percentage = reserved_share_percentage
stats = {
'share_backend_name': backend_name,
'driver_handles_share_servers': self.driver_handles_share_servers,
@ -616,6 +621,8 @@ class HPE3ParShareDriver(driver.ShareDriver):
'free_capacity_gb': 0,
'provisioned_capacity_gb': 0,
'reserved_percentage': reserved_share_percentage,
'reserved_snapshot_percentage':
reserved_share_from_snapshot_percentage,
'max_over_subscription_ratio': max_over_subscription_ratio,
'qos': False,
'thin_provisioning': True, # 3PAR default is thin
@ -629,6 +636,8 @@ class HPE3ParShareDriver(driver.ShareDriver):
for fpg in self.fpgs:
fpg_status = self._hpe3par.get_fpg_status(fpg)
fpg_status['reserved_percentage'] = reserved_share_percentage
fpg_status['reserved_snapshot_percentage'] = (
reserved_share_from_snapshot_percentage)
LOG.debug("FPG status = %s.", fpg_status)
stats.setdefault('pools', []).append(fpg_status)

@ -325,6 +325,7 @@ class V3StorageConnection(driver.HuaweiBase):
allocated_capacity_gb=capacity['CONSUMEDCAPACITY'],
qos=self._get_qos_capability(),
reserved_percentage=0,
reserved_snapshot_percentage=0,
thin_provisioning=[True, False],
dedupe=[True, False],
compression=[True, False],

@ -747,7 +747,10 @@ class GPFSShareDriver(driver.ExecuteMixin, driver.GaneshaMixin,
share_backend_name=self.backend_name,
vendor_name='IBM',
storage_protocol='NFS',
reserved_percentage=self.configuration.reserved_share_percentage)
reserved_percentage=self.configuration.reserved_share_percentage,
reserved_snapshot_percentage=(
self.configuration.reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage))
free, capacity = self._get_available_capacity(
self.configuration.gpfs_mount_point_base)

@ -163,6 +163,9 @@ class InfiniboxShareDriver(driver.ShareDriver):
total_capacity_gb=float(physical_capacity_bytes) / units.Gi,
free_capacity_gb=float(free_capacity_bytes) / units.Gi,
reserved_percentage=self.configuration.reserved_share_percentage,
reserved_snapshot_percentage=(
self.configuration.reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage),
thin_provisioning=self.configuration.infinidat_thin_provision,
max_over_subscription_ratio=max_over_subscription_ratio,
provisioned_capacity_gb=provisioned_capacity_gb,

@ -120,6 +120,9 @@ class InfortrendNASDriver(driver.ShareDriver):
driver_version=self.VERSION,
storage_protocol=self.PROTOCOL,
reserved_percentage=self.configuration.reserved_share_percentage,
reserved_snapshot_percentage=(
self.configuration.reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage),
pools=self.ift_nas.update_pools_stats())
LOG.debug('Infortrend pools status: %s', data['pools'])

@ -611,6 +611,9 @@ class AS13000ShareDriver(driver.ShareDriver):
'pool_name': path,
'reserved_percentage':
self.configuration.reserved_share_percentage,
'reserved_snapshot_percentage':
self.configuration.reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage,
'max_over_subscription_ratio':
self.configuration.max_over_subscription_ratio,
'dedupe': False,

@ -123,6 +123,9 @@ class InStorageShareDriver(driver.ShareDriver):
'storage_protocol': 'NFS_CIFS',
'reserved_percentage':
self.configuration.reserved_share_percentage,
'reserved_snapshot_percentage': (
self.configuration.reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage),
'max_over_subscription_ratio':
self.configuration.max_over_subscription_ratio,
'snapshot_support': False,
@ -299,6 +302,7 @@ class InStorageAssistant(object):
'free_capacity_gb': available,
'allocated_capacity_gb': total_allocated_capacity,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'qos': False,
'dedupe': False,
'compression': False,

@ -212,6 +212,9 @@ class LVMShareDriver(LVMMixin, driver.ShareDriver):
'storage_protocol': 'NFS_CIFS',
'reserved_percentage':
self.configuration.reserved_share_percentage,
'reserved_snapshot_percentage':
(self.configuration.reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage),
'snapshot_support': True,
'create_share_from_snapshot_support': True,
'revert_to_snapshot_support': True,
@ -233,6 +236,7 @@ class LVMShareDriver(LVMMixin, driver.ShareDriver):
'total_capacity_gb': float(total_size),
'free_capacity_gb': float(free_size),
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
}, ]
def create_share(self, context, share, share_server=None):

@ -422,6 +422,9 @@ class NetAppCmodeFileStorageLibrary(object):
for aggr_name in sorted(aggregates):
reserved_percentage = self.configuration.reserved_share_percentage
reserved_snapshot_percentage = (
self.configuration.reserved_share_from_snapshot_percentage or
reserved_percentage)
max_over_ratio = self.configuration.max_over_subscription_ratio
total_capacity_gb = na_utils.round_down(float(
@ -443,6 +446,7 @@ class NetAppCmodeFileStorageLibrary(object):
'allocated_capacity_gb': allocated_capacity_gb,
'qos': qos_support,
'reserved_percentage': reserved_percentage,
'reserved_snapshot_percentage': reserved_snapshot_percentage,
'max_over_subscription_ratio': max_over_ratio,
'dedupe': [True, False],
'compression': [True, False],

@ -216,6 +216,9 @@ class NFSHelper(object):
'free_capacity_gb': free,
'reserved_percentage':
self.configuration.reserved_share_percentage,
'reserved_snapshot_percentage':
(self.configuration.reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage),
'compression': compression,
'dedupe': dedupe,
'max_over_subscription_ratio': (

@ -519,6 +519,9 @@ class NexentaNasDriver(driver.ShareDriver):
'free_capacity_gb': free,
'reserved_percentage': (
self.configuration.reserved_share_percentage),
'reserved_snapshot_percentage':
(self.configuration.reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage),
'max_over_subscription_ratio': (
self.configuration.safe_get(
'max_over_subscription_ratio')),

@ -146,11 +146,17 @@ class FlashBladeShareDriver(driver.ShareDriver):
) = self._get_available_capacity()
reserved_share_percentage = self.configuration.safe_get(
"reserved_safe_percentage"
"reserved_share_percentage"
)
if reserved_share_percentage is None:
reserved_share_percentage = 0
reserved_share_from_snapshot_percentage = self.configuration.safe_get(
"reserved_share_from_snapshot_percentage"
)
if reserved_share_from_snapshot_percentage is None:
reserved_share_from_snapshot_percentage = reserved_share_percentage
data = dict(
share_backend_name=self._backend_name,
vendor_name="PURE STORAGE",
@ -158,6 +164,8 @@ class FlashBladeShareDriver(driver.ShareDriver):
storage_protocol="NFS",
data_reduction=data_reduction,
reserved_percentage=reserved_share_percentage,
reserved_snapshot_percentage=(
reserved_share_from_snapshot_percentage),
total_capacity_gb=float(physical_capacity_bytes) / units.Gi,
free_capacity_gb=float(free_capacity_bytes) / units.Gi,
provisioned_capacity_gb=float(provisioned_cap_bytes) / units.Gi,

@ -259,6 +259,9 @@ class QnapShareDriver(driver.ShareDriver):
reserved_percentage = self.configuration.safe_get(
'reserved_share_percentage')
reserved_snapshot_percentage = self.configuration.safe_get(
'reserved_share_from_snapshot_percentage') or reserved_percentage
# single pool now, need support multiple pools in the future
single_pool = {
"pool_name": self.configuration.qnap_poolname,
@ -266,6 +269,7 @@ class QnapShareDriver(driver.ShareDriver):
"free_capacity_gb": free_capacity_gb,
"allocated_capacity_gb": alloc_capacity_gb,
"reserved_percentage": reserved_percentage,
"reserved_snapshot_percentage": reserved_snapshot_percentage,
"qos": False,
"dedupe": [True, False],
"compression": [True, False],

@ -142,7 +142,10 @@ class QuobyteShareDriver(driver.ExecuteMixin, driver.ShareDriver,):
driver_version=self.DRIVER_VERSION,
total_capacity_gb=total_gb,
free_capacity_gb=free_gb,
reserved_percentage=self.configuration.reserved_share_percentage)
reserved_percentage=self.configuration.reserved_share_percentage,
reserved_snapshot_percentage=(
self.configuration.reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage))
super(QuobyteShareDriver, self)._update_share_stats(data)
def _get_capacities(self):

@ -447,6 +447,9 @@ class TegileShareDriver(driver.ShareDriver):
pool['qos'] = pool.pop('QoS_support', False)
pool['reserved_percentage'] = (
self.configuration.reserved_share_percentage)
pool['reserved_snapshot_percentage'] = (
self.configuration.reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage)
pool['dedupe'] = True
pool['compression'] = True
pool['thin_provisioning'] = True

@ -622,6 +622,7 @@ class ACCESSShareDriver(driver.ExecuteMixin, driver.ShareDriver):
'total_capacity_gb': total_capacity,
'free_capacity_gb': free_capacity,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'QoS_support': False,
'snapshot_support': True,
'create_share_from_snapshot_support': True

@ -495,6 +495,9 @@ class ZadaraVPSAShareDriver(driver.ShareDriver):
allocated_capacity_gb=(total - free),
provisioned_capacity_gb=provisioned,
reserved_percentage=self.configuration.reserved_share_percentage,
reserved_snapshot_percentage=(
self.configuration.reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage),
compression=[True, False],
dedupe=[True, False],
thin_provisioning=True

@ -358,6 +358,9 @@ class ZFSonLinuxShareDriver(zfs_utils.ExecuteMixin, driver.ShareDriver):
'free_capacity_gb': float(free_size),
'reserved_percentage':
self.configuration.reserved_share_percentage,
'reserved_snapshot_percentage': (
self.configuration.reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage),
}
pool.update(self.common_capabilities)
if self.configuration.replication_domain:
@ -372,6 +375,9 @@ class ZFSonLinuxShareDriver(zfs_utils.ExecuteMixin, driver.ShareDriver):
'storage_protocol': 'NFS',
'reserved_percentage':
self.configuration.reserved_share_percentage,
'reserved_snapshot_percentage': (
self.configuration.reserved_share_from_snapshot_percentage
or self.configuration.reserved_share_percentage),
'snapshot_support': True,
'create_share_from_snapshot_support': True,
'driver_name': 'ZFS',

@ -46,6 +46,7 @@ SERVICE_STATES_NO_POOLS = {
'host1': dict(share_backend_name='AAA',
total_capacity_gb=512, free_capacity_gb=200,
timestamp=None, reserved_percentage=0,
reserved_snapshot_percentage=0,
provisioned_capacity_gb=312,
max_over_subscription_ratio=1.0,
thin_provisioning=False,
@ -57,6 +58,7 @@ SERVICE_STATES_NO_POOLS = {
'host2@back1': dict(share_backend_name='BBB',
total_capacity_gb=256, free_capacity_gb=100,
timestamp=None, reserved_percentage=0,
reserved_snapshot_percentage=0,
provisioned_capacity_gb=400,
max_over_subscription_ratio=2.0,
thin_provisioning=True,
@ -68,6 +70,7 @@ SERVICE_STATES_NO_POOLS = {
'host2@back2': dict(share_backend_name='CCC',
total_capacity_gb=10000, free_capacity_gb=700,
timestamp=None, reserved_percentage=0,
reserved_snapshot_percentage=0,
provisioned_capacity_gb=50000,
max_over_subscription_ratio=20.0,
thin_provisioning=True,
@ -103,6 +106,7 @@ SHARE_SERVICES_WITH_POOLS = [
SHARE_SERVICE_STATES_WITH_POOLS = {
'host1@AAA': dict(share_backend_name='AAA',
timestamp=None, reserved_percentage=0,
reserved_snapshot_percentage=0,
driver_handles_share_servers=False,
snapshot_support=True,
create_share_from_snapshot_support=True,
@ -112,11 +116,13 @@ SHARE_SERVICE_STATES_WITH_POOLS = {
total_capacity_gb=51,
free_capacity_gb=41,
reserved_percentage=0,
reserved_snapshot_percentage=0,
provisioned_capacity_gb=10,
max_over_subscription_ratio=1.0,
thin_provisioning=False)]),
'host2@BBB': dict(share_backend_name='BBB',
timestamp=None, reserved_percentage=0,
reserved_snapshot_percentage=0,
driver_handles_share_servers=False,
snapshot_support=True,
create_share_from_snapshot_support=True,
@ -126,11 +132,13 @@ SHARE_SERVICE_STATES_WITH_POOLS = {
total_capacity_gb=52,
free_capacity_gb=42,
reserved_percentage=0,
reserved_snapshot_percentage=0,
provisioned_capacity_gb=60,
max_over_subscription_ratio=2.0,
thin_provisioning=True)]),
'host3@CCC': dict(share_backend_name='CCC',
timestamp=None, reserved_percentage=0,
reserved_snapshot_percentage=0,
driver_handles_share_servers=False,
snapshot_support=True,
create_share_from_snapshot_support=True,
@ -140,11 +148,13 @@ SHARE_SERVICE_STATES_WITH_POOLS = {
total_capacity_gb=53,
free_capacity_gb=43,
reserved_percentage=0,
reserved_snapshot_percentage=0,
provisioned_capacity_gb=100,
max_over_subscription_ratio=20.0,
thin_provisioning=True)]),
'host4@DDD': dict(share_backend_name='DDD',
timestamp=None, reserved_percentage=0,
reserved_snapshot_percentage=0,
driver_handles_share_servers=False,
snapshot_support=True,
create_share_from_snapshot_support=True,
@ -154,6 +164,7 @@ SHARE_SERVICE_STATES_WITH_POOLS = {
total_capacity_gb=541,
free_capacity_gb=441,
reserved_percentage=0,
reserved_snapshot_percentage=0,
provisioned_capacity_gb=800,
max_over_subscription_ratio=2.0,
thin_provisioning=True),
@ -161,11 +172,13 @@ SHARE_SERVICE_STATES_WITH_POOLS = {
total_capacity_gb=542,
free_capacity_gb=442,
reserved_percentage=0,
reserved_snapshot_percentage=0,
provisioned_capacity_gb=2000,
max_over_subscription_ratio=10.0,
thin_provisioning=True)]),
'host5@EEE': dict(share_backend_name='EEE',
timestamp=None, reserved_percentage=0,
reserved_snapshot_percentage=0,
driver_handles_share_servers=False,
snapshot_support=True,
create_share_from_snapshot_support=True,
@ -175,6 +188,7 @@ SHARE_SERVICE_STATES_WITH_POOLS = {
total_capacity_gb=551,
free_capacity_gb=451,
reserved_percentage=0,
reserved_snapshot_percentage=0,
provisioned_capacity_gb=100,
max_over_subscription_ratio=1.0,
thin_provisioning=False),
@ -182,11 +196,13 @@ SHARE_SERVICE_STATES_WITH_POOLS = {
total_capacity_gb=552,
free_capacity_gb=452,
reserved_percentage=0,
reserved_snapshot_percentage=0,
provisioned_capacity_gb=100,
max_over_subscription_ratio=1.0,
thin_provisioning=False)]),
'host6@FFF': dict(share_backend_name='FFF',
timestamp=None, reserved_percentage=0,
reserved_snapshot_percentage=0,
driver_handles_share_servers=False,
snapshot_support=True,
create_share_from_snapshot_support=True,
@ -196,6 +212,7 @@ SHARE_SERVICE_STATES_WITH_POOLS = {
total_capacity_gb='unknown',
free_capacity_gb='unknown',
reserved_percentage=0,
reserved_snapshot_percentage=0,
provisioned_capacity_gb=100,
max_over_subscription_ratio=1.0,
thin_provisioning=False),
@ -203,6 +220,7 @@ SHARE_SERVICE_STATES_WITH_POOLS = {
total_capacity_gb='unknown',
free_capacity_gb='unknown',
reserved_percentage=0,
reserved_snapshot_percentage=0,
provisioned_capacity_gb=100,
max_over_subscription_ratio=1.0,
thin_provisioning=False)]),
@ -225,6 +243,7 @@ class FakeHostManager(host_manager.HostManager):
'allocated_capacity_gb': 0,
'thin_provisioning': False,
'reserved_percentage': 10,
'reserved_snapshot_percentage': 5,
'timestamp': None,
'snapshot_support': True,
'create_share_from_snapshot_support': True,
@ -239,6 +258,7 @@ class FakeHostManager(host_manager.HostManager):
'max_over_subscription_ratio': 2.0,
'thin_provisioning': True,
'reserved_percentage': 10,
'reserved_snapshot_percentage': 5,
'timestamp': None,
'snapshot_support': True,
'create_share_from_snapshot_support': True,
@ -253,6 +273,7 @@ class FakeHostManager(host_manager.HostManager):
'max_over_subscription_ratio': 2.0,
'thin_provisioning': [False],
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'snapshot_support': True,
'create_share_from_snapshot_support': True,
'timestamp': None,
@ -265,6 +286,7 @@ class FakeHostManager(host_manager.HostManager):
'max_over_subscription_ratio': 1.0,
'thin_provisioning': [True],
'reserved_percentage': 5,
'reserved_snapshot_percentage': 2,
'timestamp': None,
'snapshot_support': True,
'create_share_from_snapshot_support': True,
@ -279,6 +301,7 @@ class FakeHostManager(host_manager.HostManager):
'max_over_subscription_ratio': 1.5,
'thin_provisioning': [True, False],
'reserved_percentage': 5,
'reserved_snapshot_percentage': 2,
'timestamp': None,
'snapshot_support': True,
'create_share_from_snapshot_support': True,
@ -290,6 +313,7 @@ class FakeHostManager(host_manager.HostManager):
'allocated_capacity_gb': 1548,
'thin_provisioning': False,
'reserved_percentage': 5,
'reserved_snapshot_percentage': 2,
'snapshot_support': True,
'create_share_from_snapshot_support': True,
'timestamp': None,

@ -71,6 +71,48 @@ class HostFiltersTestCase(test.TestCase):
'service': service})
self.assertFalse(self.filter.host_passes(host, filter_properties))
@ddt.data(
{'free_capacity': 120, 'total_capacity': 200,
'reserved': 20, 'reserved_snapshot': 5})
@ddt.unpack
def test_capacity_filter_passes_snapshot_reserved(self, free_capacity,
total_capacity,
reserved,
reserved_snapshot):
self._stub_service_is_up(True)
filter_properties = {'size': 100, 'snapshot_id': 1234}
service = {'disabled': False}
host = fakes.FakeHostState('host1',
{'total_capacity_gb': total_capacity,
'free_capacity_gb': free_capacity,
'reserved_percentage': reserved,
'reserved_snapshot_percentage':
reserved_snapshot,
'updated_at': None,
'service': service})
self.assertTrue(self.filter.host_passes(host, filter_properties))
@ddt.data(
{'free_capacity': 120, 'total_capacity': 200,
'reserved': 20, 'reserved_snapshot': 15})
@ddt.unpack
def test_capacity_filter_fails_snapshot_reserved(self, free_capacity,
total_capacity,
reserved,
reserved_snapshot):
self._stub_service_is_up(True)
filter_properties = {'size': 100, 'snapshot_id': 1234}
service = {'disabled': False}
host = fakes.FakeHostState('host1',
{'total_capacity_gb': total_capacity,
'free_capacity_gb': free_capacity,
'reserved_percentage': reserved,
'reserved_snapshot_percentage':
reserved_snapshot,
'updated_at': None,
'service': service})
self.assertFalse(self.filter.host_passes(host, filter_properties))
def test_capacity_filter_passes_unknown(self):
free = 'unknown'
self._stub_service_is_up(True)
@ -183,6 +225,7 @@ class HostFiltersTestCase(test.TestCase):
self._stub_service_is_up(True)
filter_properties = {
'size': size,
'snapshot_id': None,
'share_type': {
'extra_specs': {
cap_thin_key: cap_thin,

@ -197,6 +197,7 @@ class HostManagerTestCase(test.TestCase):
'driver_version': None,
'total_capacity_gb': 512,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'provisioned_capacity_gb': 312,
'max_over_subscription_ratio': 1.0,
'thin_provisioning': False,
@ -226,6 +227,7 @@ class HostManagerTestCase(test.TestCase):
'driver_version': None,
'total_capacity_gb': 256,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'provisioned_capacity_gb': 400,
'max_over_subscription_ratio': 2.0,
'thin_provisioning': True,
@ -255,6 +257,7 @@ class HostManagerTestCase(test.TestCase):
'driver_version': None,
'total_capacity_gb': 10000,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'provisioned_capacity_gb': 50000,
'max_over_subscription_ratio': 20.0,
'thin_provisioning': True,
@ -306,6 +309,7 @@ class HostManagerTestCase(test.TestCase):
'driver_version': None,
'total_capacity_gb': 51,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'provisioned_capacity_gb': 10,
'max_over_subscription_ratio': 1.0,
'thin_provisioning': False,
@ -336,6 +340,7 @@ class HostManagerTestCase(test.TestCase):
'driver_version': None,
'total_capacity_gb': 52,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'provisioned_capacity_gb': 60,
'max_over_subscription_ratio': 2.0,
'thin_provisioning': True,
@ -366,6 +371,7 @@ class HostManagerTestCase(test.TestCase):
'driver_version': None,
'total_capacity_gb': 53,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'provisioned_capacity_gb': 100,
'max_over_subscription_ratio': 20.0,
'thin_provisioning': True,
@ -396,6 +402,7 @@ class HostManagerTestCase(test.TestCase):
'driver_version': None,
'total_capacity_gb': 541,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'provisioned_capacity_gb': 800,
'max_over_subscription_ratio': 2.0,
'thin_provisioning': True,
@ -426,6 +433,7 @@ class HostManagerTestCase(test.TestCase):
'driver_version': None,
'total_capacity_gb': 542,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'provisioned_capacity_gb': 2000,
'max_over_subscription_ratio': 10.0,
'thin_provisioning': True,
@ -494,6 +502,7 @@ class HostManagerTestCase(test.TestCase):
'driver_version': None,
'total_capacity_gb': 512,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'vendor_name': None,
'storage_protocol': None,
'provisioned_capacity_gb': 312,
@ -523,6 +532,7 @@ class HostManagerTestCase(test.TestCase):
'driver_version': None,
'total_capacity_gb': 256,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'vendor_name': None,
'storage_protocol': None,
'provisioned_capacity_gb': 400,
@ -580,6 +590,7 @@ class HostManagerTestCase(test.TestCase):
'driver_version': None,
'total_capacity_gb': 52,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'provisioned_capacity_gb': 60,
'max_over_subscription_ratio': 2.0,
'thin_provisioning': True,
@ -644,6 +655,7 @@ class HostStateTestCase(test.TestCase):
share_capability = {'total_capacity_gb': 0,
'free_capacity_gb': 100,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'timestamp': None,
'ipv4_support': True,
'ipv6_support': False}
@ -696,6 +708,7 @@ class HostStateTestCase(test.TestCase):
'allocated_capacity_gb': 270,
'qos': 'False',
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'dying_disks': 100,
'super_hero_1': 'spider-man',
'super_hero_2': 'flash',
@ -707,6 +720,7 @@ class HostStateTestCase(test.TestCase):
'allocated_capacity_gb': 0,
'qos': 'False',
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'dying_disks': 200,
'super_hero_1': 'superman',
'super_hero_2': 'Hulk',
@ -752,6 +766,7 @@ class HostStateTestCase(test.TestCase):
'allocated_capacity_gb': 0,
'qos': 'False',
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
},
],
'timestamp': None,
@ -778,6 +793,7 @@ class HostStateTestCase(test.TestCase):
'free_capacity_gb': 'unknown',
'allocated_capacity_gb': 1,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'timestamp': None
}
fake_context = context.RequestContext('user', 'project', is_admin=True)
@ -806,6 +822,7 @@ class HostStateTestCase(test.TestCase):
'provisioned_capacity_gb': provisioned_capacity_gb,
'allocated_capacity_gb': provisioned_capacity_gb,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'timestamp': None
}
fake_host = host_manager.PoolState('host1', share_capability, '_pool0')
@ -827,6 +844,7 @@ class HostStateTestCase(test.TestCase):
'provisioned_capacity_gb': None,
'allocated_capacity_gb': 0,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'timestamp': None
}
fake_context = context.RequestContext('user', 'project', is_admin=True)
@ -864,6 +882,7 @@ class HostStateTestCase(test.TestCase):
'allocated_capacity_gb': 5000,
'timestamp': None,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
}
fake_context = context.RequestContext('user', 'project', is_admin=True)
fake_host = host_manager.HostState('host1')
@ -886,6 +905,7 @@ class PoolStateTestCase(test.TestCase):
'share_capability':
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'reserved_percentage': 0, 'timestamp': None,
'reserved_snapshot_percentage': 0,
'thin_provisioning': True,
'cap1': 'val1', 'cap2': 'val2'},
'instances':
@ -908,6 +928,7 @@ class PoolStateTestCase(test.TestCase):
'share_capability':
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'reserved_percentage': 0, 'timestamp': None,
'reserved_snapshot_percentage': 0,
'thin_provisioning': False, 'cap1': 'val1', 'cap2': 'val2'},
'instances':
[
@ -929,6 +950,7 @@ class PoolStateTestCase(test.TestCase):
'share_capability':
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'reserved_percentage': 0, 'timestamp': None,
'reserved_snapshot_percentage': 0,
'thin_provisioning': [False], 'cap1': 'val1', 'cap2': 'val2'},
'instances':
[
@ -950,6 +972,7 @@ class PoolStateTestCase(test.TestCase):
'share_capability':
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'reserved_percentage': 0, 'timestamp': None,
'reserved_snapshot_percentage': 0,
'thin_provisioning': [True, False], 'cap1': 'val1',
'cap2': 'val2'},
'instances':
@ -972,6 +995,7 @@ class PoolStateTestCase(test.TestCase):
'share_capability':
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'reserved_percentage': 0, 'timestamp': None,
'reserved_snapshot_percentage': 0,
'cap1': 'val1', 'cap2': 'val2', 'ipv4_support': True,
'ipv6_support': False},
'instances': []
@ -980,6 +1004,7 @@ class PoolStateTestCase(test.TestCase):
'share_capability':
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'reserved_percentage': 0, 'timestamp': None,
'reserved_snapshot_percentage': 0,
'thin_provisioning': True, 'cap1': 'val1', 'cap2': 'val2',
'ipv4_support': True, 'ipv6_support': False},
'instances': []
@ -988,6 +1013,7 @@ class PoolStateTestCase(test.TestCase):
'share_capability':
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'reserved_percentage': 0, 'timestamp': None,
'reserved_snapshot_percentage': 0,
'thin_provisioning': [False], 'cap1': 'val1', 'cap2': 'val2',
'ipv4_support': True, 'ipv6_support': False},
'instances': []
@ -996,6 +1022,7 @@ class PoolStateTestCase(test.TestCase):
'share_capability':
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'reserved_percentage': 0, 'timestamp': None,
'reserved_snapshot_percentage': 0,
'thin_provisioning': [True, False], 'cap1': 'val1',
'cap2': 'val2', 'ipv4_support': True, 'ipv6_support': False},
'instances': []
@ -1004,6 +1031,7 @@ class PoolStateTestCase(test.TestCase):
'share_capability':
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'allocated_capacity_gb': 256, 'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'timestamp': None, 'cap1': 'val1', 'cap2': 'val2',
'ipv4_support': False, 'ipv6_support': True
},
@ -1021,6 +1049,7 @@ class PoolStateTestCase(test.TestCase):
'share_capability':
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'allocated_capacity_gb': 256, 'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'timestamp': None, 'cap1': 'val1', 'cap2': 'val2',
'ipv4_support': True, 'ipv6_support': True},
'instances': []
@ -1029,6 +1058,7 @@ class PoolStateTestCase(test.TestCase):
'share_capability':
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'provisioned_capacity_gb': 256, 'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'timestamp': None, 'cap1': 'val1', 'cap2': 'val2',
'ipv4_support': False, 'ipv6_support': False
},
@ -1047,6 +1077,7 @@ class PoolStateTestCase(test.TestCase):
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'allocated_capacity_gb': 256, 'provisioned_capacity_gb': 1,
'thin_provisioning': True, 'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'timestamp': None, 'cap1': 'val1', 'cap2': 'val2'},
'instances':
[
@ -1063,6 +1094,7 @@ class PoolStateTestCase(test.TestCase):
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'allocated_capacity_gb': 256, 'provisioned_capacity_gb': 1,
'thin_provisioning': [False], 'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'timestamp': None, 'cap1': 'val1', 'cap2': 'val2'},
'instances':
[
@ -1079,6 +1111,7 @@ class PoolStateTestCase(test.TestCase):
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'allocated_capacity_gb': 256, 'provisioned_capacity_gb': 1,
'thin_provisioning': [True, False], 'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'timestamp': None, 'cap1': 'val1', 'cap2': 'val2'},
'instances':
[
@ -1095,6 +1128,7 @@ class PoolStateTestCase(test.TestCase):
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'allocated_capacity_gb': 256, 'provisioned_capacity_gb': 256,
'thin_provisioning': False, 'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'timestamp': None, 'cap1': 'val1', 'cap2': 'val2'},
'instances':
[
@ -1111,6 +1145,7 @@ class PoolStateTestCase(test.TestCase):
{'total_capacity_gb': 1024, 'free_capacity_gb': 512,
'allocated_capacity_gb': 256, 'provisioned_capacity_gb': 256,
'thin_provisioning': [False], 'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'timestamp': None, 'cap1': 'val1', 'cap2': 'val2'},
'instances':
[

@ -542,11 +542,14 @@ class CephFSDriverTestCase(test.TestCase):
self._driver.get_configured_ip_versions = mock.Mock(return_value=[4])
self._driver.configuration.local_conf.set_override(
'reserved_share_percentage', 5)
self._driver.configuration.local_conf.set_override(
'reserved_share_from_snapshot_percentage', 2)
self._driver._update_share_stats()
result = self._driver._stats
self.assertEqual(5, result['pools'][0]['reserved_percentage'])
self.assertEqual(2, result['pools'][0]['reserved_snapshot_percentage'])
self.assertEqual(164.94, result['pools'][0]['total_capacity_gb'])
self.assertEqual(149.84, result['pools'][0]['free_capacity_gb'])
self.assertTrue(result['ipv4_support'])

@ -102,6 +102,8 @@ class ContainerShareDriverTestCase(test.TestCase):
self.assertEqual('Docker', self._driver._stats['share_backend_name'])
self.assertEqual('CIFS', self._driver._stats['storage_protocol'])
self.assertEqual(0, self._driver._stats['reserved_percentage'])
self.assertEqual(0,
self._driver._stats['reserved_snapshot_percentage'])
self.assertIsNone(self._driver._stats['consistency_group_support'])
self.assertEqual(False, self._driver._stats['snapshot_support'])
self.assertEqual('ContainerShareDriver',

@ -55,6 +55,7 @@ class LVMHelperTestCase(test.TestCase):
@ddt.data("62.50g 72.50g", " 72.50g 62.50g\n", " <62.50g <72.50g\n")
def test_get_share_server_pools(self, ret_vgs):
expected_result = [{'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'pool_name': 'manila_docker_volumes',
'total_capacity_gb': 72.5,
'free_capacity_gb': 62.5}]

@ -350,6 +350,7 @@ def do_connection_connect(conn, res):
conn.pool_conf = ['pool_1', 'pool_2']
conn.pool_set = set(['pool_1', 'pool_2'])
conn.reserved_percentage = 0
conn.reserved_snapshot_percentage = 0
conn.max_over_subscription_ratio = 20
conn.port_set = set(['spa_eth1', 'spa_eth2'])
conn.nas_server_pool = StorageObjectMock(res['nas_server_pool'])

@ -302,6 +302,7 @@ class TestConnection(test.TestCase):
self.assertEqual(
enas_utils.bytes_to_gb(10000.0), pool['allocated_capacity_gb'])
self.assertEqual(0, pool['reserved_percentage'])
self.assertEqual(0, pool['reserved_snapshot_percentage'])
self.assertTrue(pool['thin_provisioning'])
self.assertEqual(
enas_utils.bytes_to_gb(490000.0), pool['free_capacity_gb'])

@ -127,6 +127,7 @@ class EMCShareFrameworkTestCase(test.TestCase):
data['total_capacity_gb'] = 'unknown'
data['free_capacity_gb'] = 'unknown'
data['reserved_percentage'] = 0
data['reserved_snapshot_percentage'] = 0
data['qos'] = False
data['pools'] = None
data['snapshot_support'] = True

@ -432,7 +432,10 @@ class DummyDriver(driver.ShareDriver):
"pool_name": "fake_pool_for_%s" % self.backend_name,
"total_capacity_gb": 1230.0,
"free_capacity_gb": 1210.0,
"reserved_percentage": self.configuration.reserved_share_percentage
"reserved_percentage":
self.configuration.reserved_share_percentage,
"reserved_snapshot_percentage":
self.configuration.reserved_share_from_snapshot_percentage
}]
if self.configuration.replication_domain:
pools[0]["replication_type"] = "readable"
@ -446,6 +449,8 @@ class DummyDriver(driver.ShareDriver):
"storage_protocol": "NFS_CIFS",
"reserved_percentage":
self.configuration.reserved_share_percentage,
"reserved_snapshot_percentage":
self.configuration.reserved_share_from_snapshot_percentage,
"snapshot_support": True,
"create_share_from_snapshot_support": True,
"revert_to_snapshot_support": True,

@ -252,6 +252,7 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase):
'driver_version': '1.1',
'storage_protocol': 'glusterfs',
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'qos': False,
'total_capacity_gb': 'unknown',
'free_capacity_gb': 'unknown',

@ -971,6 +971,8 @@ class HitachiHNASTestCase(test.TestCase):
'total_capacity_gb': 1000,
'free_capacity_gb': 200,
'reserved_percentage': driver.CONF.reserved_share_percentage,
'reserved_snapshot_percentage':
driver.CONF.reserved_share_from_snapshot_percentage,
'qos': False,
'thin_provisioning': True,
'dedupe': True,

@ -73,6 +73,7 @@ stats_data = {
'storage_protocol': 'NFS',
'pools': [{
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'pool_name': 'HSP',
'thin_provisioning': True,
'total_capacity_gb': 100,

@ -727,6 +727,7 @@ class HPE3ParDriverTestCase(test.TestCase):
'free_capacity_gb': 0,
'max_over_subscription_ratio': None,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'provisioned_capacity_gb': 0,
'share_backend_name': 'HPE_3PAR',
'snapshot_support': True,
@ -788,6 +789,7 @@ class HPE3ParDriverTestCase(test.TestCase):
'hpe3par_flash_cache': False,
'hp3par_flash_cache': False,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'provisioned_capacity_gb': expected_capacity
}
@ -801,6 +803,7 @@ class HPE3ParDriverTestCase(test.TestCase):
'free_capacity_gb': 0,
'provisioned_capacity_gb': 0,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'max_over_subscription_ratio': None,
'max_share_server_size': -1,
'max_shares_per_share_server': -1,
@ -815,6 +818,7 @@ class HPE3ParDriverTestCase(test.TestCase):
'hpe3par_flash_cache': False,
'hp3par_flash_cache': False,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'provisioned_capacity_gb': expected_capacity}],
'snapshot_support': True,
'create_share_from_snapshot_support': True,
@ -858,6 +862,7 @@ class HPE3ParDriverTestCase(test.TestCase):
'pools': None,
'provisioned_capacity_gb': 0,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'share_backend_name': 'HPE_3PAR',
'storage_protocol': 'NFS_CIFS',
'thin_provisioning': True,

@ -2420,6 +2420,7 @@ class HuaweiShareDriverTestCase(test.TestCase):
"driver_version": "1.3",
"storage_protocol": "NFS_CIFS",
"reserved_percentage": 0,
'reserved_snapshot_percentage': 0,
"total_capacity_gb": 0.0,
"free_capacity_gb": 0.0,
"qos": True,
@ -2447,6 +2448,7 @@ class HuaweiShareDriverTestCase(test.TestCase):
allocated_capacity_gb=1.0,
qos=True,
reserved_percentage=0,
reserved_snapshot_percentage=0,
compression=[True, False],
dedupe=[True, False],
max_over_subscription_ratio=1,

@ -102,6 +102,7 @@ class InfiniboxDriverTestCaseBase(test.TestCase):
self.configuration.admin_network_config_group = (
'test_admin_network_config_group')
self.configuration.reserved_share_percentage = 0
self.configuration.reserved_share_from_snapshot_percentage = 0
self.configuration.filter_function = None
self.configuration.goodness_function = None
self.configuration.driver_handles_share_servers = False

@ -59,6 +59,8 @@ class FakeConfig(object):
self.config_group = kwargs.get("config_group", "fake_config_group")
self.reserved_share_percentage = kwargs.get(
"reserved_share_percentage", 0)
self.reserved_share_from_snapshot_percentage = kwargs.get(
"reserved_share_from_snapshot_percentage", 0)
self.max_over_subscription_ratio = kwargs.get(
"max_over_subscription_ratio", 20.0)
self.filter_function = kwargs.get("filter_function", None)
@ -881,6 +883,7 @@ class AS13000ShareDriverTestCase(test.TestCase):
pool = dict()
pool['pool_name'] = 'fakepath'
pool['reserved_percentage'] = 0
pool['reserved_snapshot_percentage'] = 0
pool['max_over_subscription_ratio'] = 20.0
pool['dedupe'] = False
pool['compression'] = False

@ -59,6 +59,8 @@ class FakeConfig(object):
self.config_group = kwargs.get("config_group", "fake_config_group")
self.reserved_share_percentage = kwargs.get(
"reserved_share_percentage", 0)
self.reserved_share_from_snapshot_percentage = kwargs.get(
"reserved_share_from_snapshot_percentage", 0)
self.max_over_subscription_ratio = kwargs.get(
"max_over_subscription_ratio", 0)
self.filter_function = kwargs.get("filter_function", None)
@ -137,6 +139,7 @@ class InStorageShareDriverTestCase(test.TestCase):
'free_capacity_gb': 100,
'allocated_capacity_gb': 10,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'qos': False,
'dedupe': False,
'compression': False,
@ -160,6 +163,7 @@ class InStorageShareDriverTestCase(test.TestCase):
'driver_version': '1.0.0',
'storage_protocol': 'NFS_CIFS',
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'max_over_subscription_ratio': 0,
'snapshot_support': False,
'create_share_from_snapshot_support': False,
@ -905,6 +909,7 @@ class InStorageAssistantTestCase(test.TestCase):
'allocated_capacity_gb': 10,
'qos': False,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'dedupe': False,
'compression': False,
'thin_provisioning': False,

@ -709,7 +709,8 @@ class MapRFSNativeShareDriverTestCase(test.TestCase):
'qos', 'driver_version', 'share_backend_name',
'free_capacity_gb', 'total_capacity_gb',
'driver_handles_share_servers',
'reserved_percentage', 'vendor_name', 'storage_protocol',
'reserved_percentage', 'reserved_snapshot_percentage',
'vendor_name', 'storage_protocol',
]
for key in expected_keys:
self.assertIn(key, result)

@ -896,6 +896,7 @@ POOLS = [
'free_capacity_gb': 1.1,
'allocated_capacity_gb': 2.2,
'reserved_percentage': 5,
'reserved_snapshot_percentage': 2,
'max_over_subscription_ratio': 2.0,
'dedupe': [True, False],
'compression': [True, False],
@ -920,6 +921,7 @@ POOLS = [
'free_capacity_gb': 2.0,
'allocated_capacity_gb': 4.0,
'reserved_percentage': 5,
'reserved_snapshot_percentage': 2,
'max_over_subscription_ratio': 2.0,
'dedupe': [True, False],
'compression': [True, False],
@ -947,6 +949,7 @@ POOLS_VSERVER_CREDS = [
'free_capacity_gb': 1.1,
'allocated_capacity_gb': 0.0,
'reserved_percentage': 5,
'reserved_snapshot_percentage': 2,
'max_over_subscription_ratio': 2.0,
'dedupe': [True, False],
'compression': [True, False],
@ -968,6 +971,7 @@ POOLS_VSERVER_CREDS = [
'free_capacity_gb': 2.0,
'allocated_capacity_gb': 0.0,
'reserved_percentage': 5,
'reserved_snapshot_percentage': 2,
'max_over_subscription_ratio': 2.0,
'dedupe': [True, False],
'compression': [True, False],
@ -1693,6 +1697,7 @@ def get_config_cmode():
config = na_fakes.create_configuration_cmode()
config.local_conf.set_override('share_backend_name', BACKEND_NAME)
config.reserved_share_percentage = 5
config.reserved_share_from_snapshot_percentage = 2
config.max_over_subscription_ratio = 2.0
config.netapp_login = CLIENT_KWARGS['username']
config.netapp_password = CLIENT_KWARGS['password']

@ -89,6 +89,7 @@ class TestNexentaNasDriver(test.TestCase):
self.cfg.safe_get = mock.Mock(side_effect=_safe_get)
self.cfg.nexenta_rest_port = 1000
self.cfg.reserved_share_percentage = 0
self.cfg.reserved_share_from_snapshot_percentage = 0
self.cfg.max_over_subscription_ratio = 0
self.cfg.nexenta_rest_protocol = 'auto'
self.cfg.nexenta_volume = 'volume'
@ -593,6 +594,8 @@ class TestNexentaNasDriver(test.TestCase):
'pool_name': 'volume',
'reserved_percentage': (
self.cfg.reserved_share_percentage),
'reserved_snapshot_percentage': (
self.cfg.reserved_share_from_snapshot_percentage),
'compression': True,
'dedupe': True,
'thin_provisioning': self.cfg.nexenta_thin_provisioning,

@ -54,6 +54,7 @@ class TestNexentaNasDriver(test.TestCase):
self.cfg.nexenta_pool = 'pool1'
self.cfg.nexenta_dataset_record_size = 131072
self.cfg.reserved_share_percentage = 0
self.cfg.reserved_share_from_snapshot_percentage = 0
self.cfg.nexenta_folder = 'nfs_share'
self.cfg.nexenta_user = 'user'
self.cfg.share_backend_name = 'NexentaStor5'
@ -391,6 +392,8 @@ class TestNexentaNasDriver(test.TestCase):
'max_over_subscription_ratio': 20.0,
'reserved_percentage': (
self.cfg.reserved_share_percentage),
'reserved_snapshot_percentage': (
self.cfg.reserved_share_from_snapshot_percentage),
'thin_provisioning': self.cfg.nexenta_thin_provisioning,
}],
}

@ -343,7 +343,8 @@ class QuobyteShareDriverTestCase(test.TestCase):
driver_version=self._driver.DRIVER_VERSION,
total_capacity_gb=42,
free_capacity_gb=23,
reserved_percentage=0))
reserved_percentage=0,
reserved_snapshot_percentage=0))
def test_get_capacities_gb(self):
capval = 42115548133

@ -38,6 +38,7 @@ test_config.tegile_nas_server = 'some-ip'
test_config.tegile_nas_login = 'some-user'
test_config.tegile_nas_password = 'some-password'
test_config.reserved_share_percentage = 10
test_config.reserved_share_from_snapshot_percentage = 5
test_config.max_over_subscription_ratio = 30.0
test_share = {
@ -82,6 +83,7 @@ array_stats = {
'QoS_support': False,
'free_capacity_gb': 911.812650680542,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'pool_name': 'pyramid',
},
{
@ -89,6 +91,7 @@ array_stats = {
'QoS_support': False,
'free_capacity_gb': 2740.148867149747,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'pool_name': 'cobalt',
},
{
@ -96,6 +99,7 @@ array_stats = {
'QoS_support': False,
'free_capacity_gb': 913.4198722839355,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'pool_name': 'test',
},
],
@ -447,6 +451,7 @@ class TegileShareDriverTestCase(test.TestCase):
'pool_name': 'pyramid',
'qos': False,
'reserved_percentage': 10,
'reserved_snapshot_percentage': 5,
'thin_provisioning': True,
'max_over_subscription_ratio': 30.0,
'total_capacity_gb': 913.5},
@ -458,6 +463,7 @@ class TegileShareDriverTestCase(test.TestCase):
'pool_name': 'cobalt',
'qos': False,
'reserved_percentage': 10,
'reserved_snapshot_percentage': 5,
'thin_provisioning': True,
'max_over_subscription_ratio': 30.0,
'total_capacity_gb': 2742.1996604874
@ -470,11 +476,13 @@ class TegileShareDriverTestCase(test.TestCase):
'pool_name': 'test',
'qos': False,
'reserved_percentage': 10,
'reserved_snapshot_percentage': 5,
'thin_provisioning': True,
'max_over_subscription_ratio': 30.0,
'total_capacity_gb': 913.5}, ],
'qos': False,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'replication_domain': None,
'share_backend_name': 'Tegile',
'snapshot_support': True,

@ -1332,7 +1332,8 @@ class GenericShareDriverTestCase(test.TestCase):
'qos', 'driver_version', 'share_backend_name',
'free_capacity_gb', 'total_capacity_gb',
'driver_handles_share_servers',
'reserved_percentage', 'vendor_name', 'storage_protocol',
'reserved_percentage', 'reserved_snapshot_percentage',
'vendor_name', 'storage_protocol',
]
result = self._driver.get_share_stats(True)

@ -64,6 +64,7 @@ class GlusterfsShareDriverTestCase(test.TestCase):
self.addCleanup(fake_utils.fake_execute_clear_log)
CONF.set_default('reserved_share_percentage', 50)
CONF.set_default('reserved_share_from_snapshot_percentage', 30)
CONF.set_default('driver_handles_share_servers', False)
self.fake_conf = config.Configuration(None)
@ -155,7 +156,8 @@ class GlusterfsShareDriverTestCase(test.TestCase):
assert_called_once_with({'storage_protocol': 'NFS',
'vendor_name': 'Red Hat',
'share_backend_name': 'GlusterFS',
'reserved_percentage': 50}))
'reserved_percentage': 50,
'reserved_snapshot_percentage': 30}))
def test_get_network_allocations_number(self):
self.assertEqual(0, self._driver.get_network_allocations_number())

@ -92,6 +92,7 @@ class LVMShareDriverTestCase(test.TestCase):
CONF.set_default('lvm_share_export_ips', ['10.0.0.1', '10.0.0.2'])
CONF.set_default('driver_handles_share_servers', False)
CONF.set_default('reserved_share_percentage', 50)
CONF.set_default('reserved_share_from_snapshot_percentage', 30)
self._helper_cifs = mock.Mock()
self._helper_nfs = mock.Mock()
@ -531,6 +532,7 @@ class LVMShareDriverTestCase(test.TestCase):
'total_capacity_gb': 33,
'free_capacity_gb': 22,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
}, ]
self.mock_object(
self._driver,

@ -432,6 +432,7 @@ class ACCESSShareDriverTestCase(test.TestCase):
'total_capacity_gb': 10,
'free_capacity_gb': 9,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'QoS_support': False,
'create_share_from_snapshot_support': True,
'driver_handles_share_servers': False,

@ -736,6 +736,7 @@ class ZadaraVPSAShareDriverTestCase(test.TestCase):
self.configuration.admin_network_config_group = (
'fake_admin_network_config_group')
self.configuration.reserved_percentage = 0
self.configuration.reserved_snapshot_percentage = 0
self.configuration.zadara_use_iser = True
self.configuration.zadara_vpsa_host = '192.168.5.5'
self.configuration.zadara_vpsa_port = '80'
@ -755,6 +756,7 @@ class ZadaraVPSAShareDriverTestCase(test.TestCase):
self.configuration.zadara_gen3_vol_dedupe = True
self.configuration.share_backend_name = 'zadaravpsa'
self.configuration.reserved_share_percentage = '0'
self.configuration.reserved_share_from_snapshot_percentage = '0'
self.configuration.replication_domain = None
self.configuration.filter_function = None
self.configuration.goodness_function = None
@ -959,6 +961,8 @@ class ZadaraVPSAShareDriverTestCase(test.TestCase):
self.assertEqual('unknown', data['free_capacity_gb'])
self.assertEqual(data['reserved_percentage'],
self.configuration.reserved_percentage)
self.assertEqual(data['reserved_snapshot_percentage'],
self.configuration.reserved_snapshot_percentage)
self.assertEqual(data['snapshot_support'], True)
self.assertEqual(data['create_share_from_snapshot_support'], True)
self.assertEqual(data['revert_to_snapshot_support'], False)

@ -62,6 +62,8 @@ class FakeConfig(object):
self.config_group = kwargs.get("config_group", "fake_config_group")
self.reserved_share_percentage = kwargs.get(
"reserved_share_percentage", 0)
self.reserved_share_from_snapshot_percentage = kwargs.get(
"reserved_share_from_snapshot_percentage", 0)
self.max_over_subscription_ratio = kwargs.get(
"max_over_subscription_ratio", 15.0)
self.filter_function = kwargs.get("filter_function", None)
@ -279,6 +281,7 @@ class ZFSonLinuxShareDriverTestCase(test.TestCase):
expected = [
{'pool_name': 'foo', 'total_capacity_gb': 3.0,
'free_capacity_gb': 2.0, 'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'compression': [True, False],
'dedupe': [True, False],
'thin_provisioning': [True],
@ -287,6 +290,7 @@ class ZFSonLinuxShareDriverTestCase(test.TestCase):
'qos': [False]},
{'pool_name': 'bar', 'total_capacity_gb': 4.0,
'free_capacity_gb': 5.0, 'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'compression': [True, False],
'dedupe': [True, False],
'thin_provisioning': [True],
@ -355,6 +359,7 @@ class ZFSonLinuxShareDriverTestCase(test.TestCase):
'qos': False,
'replication_domain': replication_domain,
'reserved_percentage': 0,
'reserved_snapshot_percentage': 0,
'share_backend_name': self.driver.backend_name,
'share_group_stats': {'consistent_snapshot_support': None},
'snapshot_support': True,

@ -140,7 +140,8 @@ class ShareDriverTestCase(test.TestCase):
'qos', 'driver_version', 'share_backend_name',
'free_capacity_gb', 'total_capacity_gb',
'driver_handles_share_servers',
'reserved_percentage', 'vendor_name', 'storage_protocol',
'reserved_percentage', 'reserved_snapshot_percentage',
'vendor_name', 'storage_protocol',
'snapshot_support', 'mount_snapshot_support',
]
share_driver = driver.ShareDriver(True, configuration=conf)

@ -0,0 +1,10 @@
---
features:
- |
'reserved_share_from_snapshot_percentage' backend config option allows
Manila to consider different reservation percentage for shares that are
being created from the snapshot.
In case this config option is not set, the shares created from snapshot
will use reservation percentage value set in 'reserved_share_percentage'.
This will be useful for users who want to keep same reservation percentage
for both non-snapshot/regular and snapshot shares.