Browse Source

Check 'thin_provisioning' in extra specs

Currently in the capacity filter and weigher of the scheduler,
we use the logic to evaluate whether there is enough capacity
to thin provision a share on a backend if the driver reports
thin_provisioning to be True. However, a driver may be able to
support both thin and thick provisioning. The logic does not
check whether the user wants the share to be provisioned as thin
or not.

In this patch, we check 'thin_provisioning' in extra specs of the
share type and decide whether to use the logic for thin or thick.
In the following two cases, we will use the thin logic:
1) 'thin_provisioning' is not set in extra specs. This is to
   provide backward compatibility.
2) 'thin_provisioning' is set in extra specs and it is
   '<is> True' or 'True'.

To provision a thick share on a backend that supports both
thin and thick, set one of the following in extra specs:
    {'thin_provisioning': 'False'}
    {'thin_provisioning': '<is> False'}
    {'capabilities:thin_provisioning': 'False'}
    {'capabilities:thin_provisioning': '<is> False'}

DocImpact
Change-Id: I238a7962425ea35c356c5ed2e31b8f68462b3769
Closes-Bug: #1578718
changes/66/315266/12
xing-yang 5 years ago
committed by Goutham Pacha Ravi
parent
commit
83c93c7767
  1. 15
      manila/scheduler/filters/capacity.py
  2. 50
      manila/scheduler/utils.py
  3. 10
      manila/scheduler/weighers/capacity.py
  4. 6
      manila/tests/scheduler/fakes.py
  5. 133
      manila/tests/scheduler/filters/test_capacity.py
  6. 64
      manila/tests/scheduler/test_utils.py
  7. 151
      manila/tests/scheduler/weighers/test_capacity.py
  8. 7
      releasenotes/notes/check-thin-provisioning-4bb702535f6b10b6.yaml

15
manila/scheduler/filters/capacity.py

@ -24,6 +24,7 @@ from oslo_log import log
from manila.i18n import _LE
from manila.i18n import _LW
from manila.scheduler.filters import base_host
from manila.scheduler import utils
LOG = log.getLogger(__name__)
@ -77,14 +78,19 @@ class CapacityFilter(base_host.BaseHostFilter):
"on host %(host)s (requested / avail): "
"%(requested)s/%(available)s", msg_args)
share_type = filter_properties.get('share_type', {})
use_thin_logic = utils.use_thin_logic(share_type)
thin_provisioning = utils.thin_provisioning(
host_state.thin_provisioning)
# NOTE(xyang): Only evaluate using max_over_subscription_ratio
# if thin_provisioning is True. Check if the ratio of
# provisioned capacity over total capacity would exceed
# if use_thin_logic and thin_provisioning are True. Check if the
# ratio of provisioned capacity over total capacity would exceed
# subscription ratio.
# If max_over_subscription_ratio = 1, the provisioned_ratio
# should still be limited by the max_over_subscription_ratio;
# otherwise, it could result in infinite provisioning.
if (host_state.thin_provisioning and
if (use_thin_logic and thin_provisioning and
host_state.max_over_subscription_ratio >= 1):
provisioned_ratio = ((host_state.provisioned_capacity_gb +
share_size) / total)
@ -105,7 +111,8 @@ class CapacityFilter(base_host.BaseHostFilter):
adjusted_free_virtual = (
free * host_state.max_over_subscription_ratio)
return adjusted_free_virtual >= share_size
elif host_state.thin_provisioning:
elif (use_thin_logic and thin_provisioning and
host_state.max_over_subscription_ratio < 1):
LOG.error(_LE("Invalid max_over_subscription_ratio: %(ratio)s. "
"Valid value should be >= 1."),
{"ratio": host_state.max_over_subscription_ratio})

50
manila/scheduler/utils.py

@ -1,4 +1,6 @@
# Copyright (c) 2014 Hewlett-Packard Development Company, L.P.
# Copyright (c) 2016 EMC Corporation
#
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
@ -13,6 +15,10 @@
# License for the specific language governing permissions and limitations
# under the License.
from oslo_utils import strutils
from manila.scheduler.filters import extra_specs_ops
def generate_stats(host_state, properties):
"""Generates statistics from host and share data."""
@ -61,3 +67,47 @@ def generate_stats(host_state, properties):
}
return stats
def use_thin_logic(share_type):
# NOTE(xyang): To preserve the existing behavior, we use thin logic
# to evaluate in two cases:
# 1) 'thin_provisioning' is not set in extra specs (This is for
# backward compatibility. If not set, the scheduler behaves
# the same as before this bug fix).
# 2) 'thin_provisioning' is set in extra specs and it is
# '<is> True' or 'True'.
# Otherwise we use the thick logic to evaluate.
use_thin_logic = True
thin_spec = None
try:
thin_spec = share_type.get('extra_specs', {}).get(
'thin_provisioning')
if thin_spec is None:
thin_spec = share_type.get('extra_specs', {}).get(
'capabilities:thin_provisioning')
# NOTE(xyang) 'use_thin_logic' and 'thin_provisioning' are NOT
# the same thing. The first purpose of "use_thin_logic" is to
# preserve the existing scheduler behavior if 'thin_provisioning'
# is NOT in extra_specs (if thin_spec is None, use_thin_logic
# should be True). The second purpose of 'use_thin_logic'
# is to honor 'thin_provisioning' if it is in extra specs (if
# thin_spec is set to True, use_thin_logic should be True; if
# thin_spec is set to False, use_thin_logic should be False).
use_thin_logic = strutils.bool_from_string(
thin_spec, strict=True) if thin_spec is not None else True
except ValueError:
# Check if the value of thin_spec is '<is> True'.
if thin_spec is not None and not extra_specs_ops.match(
True, thin_spec):
use_thin_logic = False
return use_thin_logic
def thin_provisioning(host_state_thin_provisioning):
# NOTE(xyang): host_state_thin_provisioning is reported by driver.
# It can be either bool (True or False) or
# list ([True, False], [True], [False]).
thin_capability = [host_state_thin_provisioning] if not isinstance(
host_state_thin_provisioning, list) else host_state_thin_provisioning
return True in thin_capability

10
manila/scheduler/weighers/capacity.py

@ -31,7 +31,7 @@ import math
from oslo_config import cfg
from manila.scheduler import utils
from manila.scheduler.weighers import base_host
capacity_weight_opts = [
@ -63,7 +63,13 @@ class CapacityWeigher(base_host.BaseHostWeigher):
free = float('inf')
else:
total = float(total_space)
if host_state.thin_provisioning:
share_type = weight_properties.get('share_type', {})
use_thin_logic = utils.use_thin_logic(share_type)
thin_provisioning = utils.thin_provisioning(
host_state.thin_provisioning)
if use_thin_logic and thin_provisioning:
# NOTE(xyang): Calculate virtual free capacity for thin
# provisioning.
free = math.floor(

6
manila/tests/scheduler/fakes.py

@ -212,7 +212,7 @@ class FakeHostManager(host_manager.HostManager):
'allocated_capacity_gb': 256,
'provisioned_capacity_gb': 256,
'max_over_subscription_ratio': 2.0,
'thin_provisioning': False,
'thin_provisioning': [False],
'consistency_group_support': 'host',
'reserved_percentage': 0,
'snapshot_support': True,
@ -223,7 +223,7 @@ class FakeHostManager(host_manager.HostManager):
'allocated_capacity_gb': 1848,
'provisioned_capacity_gb': 1848,
'max_over_subscription_ratio': 1.0,
'thin_provisioning': True,
'thin_provisioning': [True],
'reserved_percentage': 5,
'timestamp': None,
'snapshot_support': True,
@ -235,7 +235,7 @@ class FakeHostManager(host_manager.HostManager):
'allocated_capacity_gb': 1548,
'provisioned_capacity_gb': 1548,
'max_over_subscription_ratio': 1.5,
'thin_provisioning': True,
'thin_provisioning': [True, False],
'reserved_percentage': 5,
'timestamp': None,
'snapshot_support': True,

133
manila/tests/scheduler/filters/test_capacity.py

@ -121,31 +121,76 @@ class HostFiltersTestCase(test.TestCase):
@ddt.data(
{'size': 100, 'cap_thin': '<is> True',
'total': 500, 'free': 200, 'provisioned': 500,
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': True},
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': True,
'cap_thin_key': 'capabilities:thin_provisioning'},
{'size': 3000, 'cap_thin': '<is> True',
'total': 500, 'free': 200, 'provisioned': 7000,
'max_ratio': 20, 'reserved': 5, 'thin_prov': True},
'max_ratio': 20, 'reserved': 5, 'thin_prov': True,
'cap_thin_key': 'thin_provisioning'},
{'size': 100, 'cap_thin': '<is> False',
'total': 500, 'free': 200, 'provisioned': 300,
'max_ratio': 1.0, 'reserved': 5, 'thin_prov': False},
'max_ratio': 1.0, 'reserved': 5, 'thin_prov': False,
'cap_thin_key': 'capabilities:thin_provisioning'},
{'size': 100, 'cap_thin': '<is> True',
'total': 500, 'free': 200, 'provisioned': 400,
'max_ratio': 1.0, 'reserved': 5, 'thin_prov': True},
'max_ratio': 1.0, 'reserved': 5, 'thin_prov': True,
'cap_thin_key': 'thin_provisioning'},
{'size': 100, 'cap_thin': '<is> True',
'total': 500, 'free': 125, 'provisioned': 400,
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': True},
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': True,
'cap_thin_key': 'capabilities:thin_provisioning'},
{'size': 100, 'cap_thin': '<is> True',
'total': 500, 'free': 80, 'provisioned': 600,
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': True},
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': True,
'cap_thin_key': 'thin_provisioning'},
{'size': 100, 'cap_thin': '<is> True',
'total': 500, 'free': 100, 'provisioned': 400,
'max_ratio': 2.0, 'reserved': 0, 'thin_prov': True})
'max_ratio': 2.0, 'reserved': 0, 'thin_prov': True,
'cap_thin_key': 'capabilities:thin_provisioning'},
{'size': 100, 'cap_thin': '<is> True',
'total': 500, 'free': 200, 'provisioned': 500,
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': [True, False],
'cap_thin_key': 'thin_provisioning'},
{'size': 3000, 'cap_thin': '<is> True',
'total': 500, 'free': 200, 'provisioned': 7000,
'max_ratio': 20, 'reserved': 5, 'thin_prov': [True],
'cap_thin_key': 'capabilities:thin_provisioning'},
{'size': 100, 'cap_thin': '<is> False',
'total': 500, 'free': 200, 'provisioned': 300,
'max_ratio': 1.0, 'reserved': 5, 'thin_prov': [False],
'cap_thin_key': 'thin_provisioning'},
{'size': 100, 'cap_thin': 'True',
'total': 500, 'free': 200, 'provisioned': 400,
'max_ratio': 1.0, 'reserved': 5, 'thin_prov': [False, True],
'cap_thin_key': 'capabilities:thin_provisioning'},
{'size': 100, 'cap_thin': 'False',
'total': 500, 'free': 200, 'provisioned': 300,
'max_ratio': 1.0, 'reserved': 5, 'thin_prov': False,
'cap_thin_key': 'thin_provisioning'},
{'size': 100, 'cap_thin': 'true',
'total': 500, 'free': 125, 'provisioned': 400,
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': [True, ],
'cap_thin_key': 'capabilities:thin_provisioning'},
{'size': 100, 'cap_thin': 'false',
'total': 500, 'free': 200, 'provisioned': 300,
'max_ratio': 1.0, 'reserved': 5, 'thin_prov': [False, ],
'cap_thin_key': 'thin_provisioning'},
{'size': 100, 'cap_thin': None,
'total': 500, 'free': 80, 'provisioned': 600,
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': True,
'cap_thin_key': None},)
@ddt.unpack
def test_filter_thin_passes(self, size, cap_thin, total, free, provisioned,
max_ratio, reserved, thin_prov):
max_ratio, reserved, thin_prov, cap_thin_key):
self._stub_service_is_up(True)
filter_properties = {'size': size,
'capabilities:thin_provisioning': cap_thin}
filter_properties = {
'size': size,
'share_type': {
'extra_specs': {
cap_thin_key: cap_thin,
}
}
}
service = {'disabled': False}
host = fakes.FakeHostState('host1',
{'total_capacity_gb': total,
@ -161,34 +206,80 @@ class HostFiltersTestCase(test.TestCase):
@ddt.data(
{'size': 200, 'cap_thin': '<is> True',
'total': 500, 'free': 100, 'provisioned': 400,
'max_ratio': 0.8, 'reserved': 0, 'thin_prov': True},
'max_ratio': 0.8, 'reserved': 0, 'thin_prov': True,
'cap_thin_key': 'capabilities:thin_provisioning'},
{'size': 100, 'cap_thin': '<is> True',
'total': 500, 'free': 200, 'provisioned': 700,
'max_ratio': 1.5, 'reserved': 5, 'thin_prov': True},
'max_ratio': 1.5, 'reserved': 5, 'thin_prov': True,
'cap_thin_key': 'thin_provisioning'},
{'size': 2000, 'cap_thin': '<is> True',
'total': 500, 'free': 30, 'provisioned': 9000,
'max_ratio': 20.0, 'reserved': 0, 'thin_prov': True},
'max_ratio': 20.0, 'reserved': 0, 'thin_prov': True,
'cap_thin_key': 'capabilities:thin_provisioning'},
{'size': 100, 'cap_thin': '<is> True',
'total': 500, 'free': 100, 'provisioned': 1000,
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': True},
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': True,
'cap_thin_key': 'thin_provisioning'},
{'size': 100, 'cap_thin': '<is> False',
'total': 500, 'free': 100, 'provisioned': 400,
'max_ratio': 1.0, 'reserved': 5, 'thin_prov': False},
'max_ratio': 1.0, 'reserved': 5, 'thin_prov': False,
'cap_thin_key': 'capabilities:thin_provisioning'},
{'size': 100, 'cap_thin': '<is> True',
'total': 500, 'free': 0, 'provisioned': 800,
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': True},
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': True,
'cap_thin_key': 'thin_provisioning'},
{'size': 100, 'cap_thin': '<is> True',
'total': 500, 'free': 99, 'provisioned': 1000,
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': True},
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': True,
'cap_thin_key': 'capabilities:thin_provisioning'},
{'size': 400, 'cap_thin': '<is> True',
'total': 500, 'free': 200, 'provisioned': 600,
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': True})
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': True,
'cap_thin_key': 'thin_provisioning'},
{'size': 200, 'cap_thin': '<is> True',
'total': 500, 'free': 100, 'provisioned': 400,
'max_ratio': 0.8, 'reserved': 0, 'thin_prov': [False, True],
'cap_thin_key': 'capabilities:thin_provisioning'},
{'size': 2000, 'cap_thin': '<is> True',
'total': 500, 'free': 30, 'provisioned': 9000,
'max_ratio': 20.0, 'reserved': 0, 'thin_prov': [True],
'cap_thin_key': 'thin_provisioning'},
{'size': 100, 'cap_thin': '<is> False',
'total': 500, 'free': 100, 'provisioned': 400,
'max_ratio': 1.0, 'reserved': 5, 'thin_prov': [False],
'cap_thin_key': 'thin_provisioning'},
{'size': 100, 'cap_thin': 'False',
'total': 500, 'free': 100, 'provisioned': 400,
'max_ratio': 1.0, 'reserved': 5, 'thin_prov': False,
'cap_thin_key': 'capabilities:thin_provisioning'},
{'size': 100, 'cap_thin': 'True',
'total': 500, 'free': 0, 'provisioned': 800,
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': [False, True],
'cap_thin_key': 'thin_provisioning'},
{'size': 100, 'cap_thin': 'true',
'total': 500, 'free': 99, 'provisioned': 1000,
'max_ratio': 2.0, 'reserved': 5, 'thin_prov': [True, ],
'cap_thin_key': 'capabilities:thin_provisioning'},
{'size': 100, 'cap_thin': 'false',
'total': 500, 'free': 100, 'provisioned': 400,
'max_ratio': 1.0, 'reserved': 5, 'thin_prov': [False, ],
'cap_thin_key': 'thin_provisioning'},
{'size': 2000, 'cap_thin': None,
'total': 500, 'free': 30, 'provisioned': 9000,
'max_ratio': 20.0, 'reserved': 0, 'thin_prov': [True],
'cap_thin_key': None},)
@ddt.unpack
def test_filter_thin_fails(self, size, cap_thin, total, free, provisioned,
max_ratio, reserved, thin_prov):
max_ratio, reserved, thin_prov, cap_thin_key):
self._stub_service_is_up(True)
filter_properties = {'size': size,
'capabilities:thin_provisioning': cap_thin}
filter_properties = {
'size': size,
'share_type': {
'extra_specs': {
cap_thin_key: cap_thin,
}
}
}
service = {'disabled': False}
host = fakes.FakeHostState('host1',
{'total_capacity_gb': total,

64
manila/tests/scheduler/test_utils.py

@ -0,0 +1,64 @@
# Copyright 2016 EMC Corporation 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.
"""
Tests For utils.
"""
import ddt
from manila.scheduler import utils
from manila import test
@ddt.ddt
class UtilsTestCase(test.TestCase):
"""Test case for utils."""
def setUp(self):
super(UtilsTestCase, self).setUp()
@ddt.data(
({'extra_specs': {'thin_provisioning': True}}, True),
({'extra_specs': {'thin_provisioning': False}}, False),
({'extra_specs': {'foo': 'bar'}}, True),
({'foo': 'bar'}, True),
({'extra_specs': {'thin_provisioning': '<is> True'}},
True),
({'extra_specs': {'thin_provisioning': '<is> False'}},
False),
({'extra_specs': {'thin_provisioning': '<not> True'}},
False),
({'extra_specs': {}}, True),
({}, True),
)
@ddt.unpack
def test_use_thin_logic(self, properties, use_thin):
use_thin_logic = utils.use_thin_logic(properties)
self.assertEqual(use_thin, use_thin_logic)
@ddt.data(
(True, True),
(False, False),
(None, False),
([True, False], True),
([True], True),
([False], False),
('wrong', False),
)
@ddt.unpack
def test_thin_provisioning(self, thin_capabilities, thin):
thin_provisioning = utils.thin_provisioning(thin_capabilities)
self.assertEqual(thin, thin_provisioning)

151
manila/tests/scheduler/weighers/test_capacity.py

@ -16,6 +16,7 @@
Tests For Capacity Weigher.
"""
import ddt
import mock
from oslo_config import cfg
@ -29,6 +30,7 @@ from manila.tests.scheduler import fakes
CONF = cfg.CONF
@ddt.ddt
class CapacityWeigherTestCase(test.TestCase):
def setUp(self):
super(CapacityWeigherTestCase, self).setUp()
@ -61,9 +63,37 @@ class CapacityWeigherTestCase(test.TestCase):
# - total * reserved)
# Otherwise, use the following formula:
# free = math.floor(free_space - total * reserved)
def test_default_of_spreading_first(self):
@ddt.data(
{'cap_thin': '<is> True',
'cap_thin_key': 'capabilities:thin_provisioning',
'winner': 'host2'},
{'cap_thin': '<is> False',
'cap_thin_key': 'thin_provisioning',
'winner': 'host1'},
{'cap_thin': 'True',
'cap_thin_key': 'capabilities:thin_provisioning',
'winner': 'host2'},
{'cap_thin': 'False',
'cap_thin_key': 'thin_provisioning',
'winner': 'host1'},
{'cap_thin': 'true',
'cap_thin_key': 'capabilities:thin_provisioning',
'winner': 'host2'},
{'cap_thin': 'false',
'cap_thin_key': 'thin_provisioning',
'winner': 'host1'},
{'cap_thin': None,
'cap_thin_key': None,
'winner': 'host2'},
)
@ddt.unpack
def test_default_of_spreading_first(self, cap_thin, cap_thin_key,
winner):
hostinfo_list = self._get_all_hosts()
# Results for the 1st test
# {'capabilities:thin_provisioning': '<is> True'}:
# host1: thin_provisioning = False
# free_capacity_gb = 1024
# free = math.floor(1024 - 1024 * 0.1) = 921.0
@ -73,16 +103,16 @@ class CapacityWeigherTestCase(test.TestCase):
# free_capacity_gb = 300
# free = math.floor(2048 * 2.0 - 1748 - 2048 * 0.1)=2143.0
# weight = 1.0
# host3: thin_provisioning = False
# host3: thin_provisioning = [False]
# free_capacity_gb = 512
# free = math.floor(256 - 512 * 0)=256.0
# weight = 0.08
# host4: thin_provisioning = True
# host4: thin_provisioning = [True]
# max_over_subscription_ratio = 1.0
# free_capacity_gb = 200
# free = math.floor(2048 * 1.0 - 1848 - 2048 * 0.05) = 97.0
# weight = 0.0
# host5: thin_provisioning = True
# host5: thin_provisioning = [True, False]
# max_over_subscription_ratio = 1.5
# free_capacity_gb = 500
# free = math.floor(2048 * 1.5 - 1548 - 2048 * 0.05) = 1421.0
@ -92,10 +122,20 @@ class CapacityWeigherTestCase(test.TestCase):
# weight = 0.0
# so, host2 should win:
weighed_host = self._get_weighed_host(hostinfo_list)
weight_properties = {
'size': 1,
'share_type': {
'extra_specs': {
cap_thin_key: cap_thin,
}
}
}
weighed_host = self._get_weighed_host(
hostinfo_list,
weight_properties=weight_properties)
self.assertEqual(1.0, weighed_host.weight)
self.assertEqual(
'host2', utils.extract_host(weighed_host.obj.host))
winner, utils.extract_host(weighed_host.obj.host))
def test_unknown_is_last(self):
hostinfo_list = self._get_all_hosts()
@ -105,10 +145,38 @@ class CapacityWeigherTestCase(test.TestCase):
'host6', utils.extract_host(last_host.obj.host))
self.assertEqual(0.0, last_host.weight)
def test_capacity_weight_multiplier_negative_1(self):
@ddt.data(
{'cap_thin': '<is> True',
'cap_thin_key': 'capabilities:thin_provisioning',
'winner': 'host4'},
{'cap_thin': '<is> False',
'cap_thin_key': 'thin_provisioning',
'winner': 'host2'},
{'cap_thin': 'True',
'cap_thin_key': 'capabilities:thin_provisioning',
'winner': 'host4'},
{'cap_thin': 'False',
'cap_thin_key': 'thin_provisioning',
'winner': 'host2'},
{'cap_thin': 'true',
'cap_thin_key': 'capabilities:thin_provisioning',
'winner': 'host4'},
{'cap_thin': 'false',
'cap_thin_key': 'thin_provisioning',
'winner': 'host2'},
{'cap_thin': None,
'cap_thin_key': None,
'winner': 'host4'},
)
@ddt.unpack
def test_capacity_weight_multiplier_negative_1(self, cap_thin,
cap_thin_key,
winner):
self.flags(capacity_weight_multiplier=-1.0)
hostinfo_list = self._get_all_hosts()
# Results for the 1st test
# {'capabilities:thin_provisioning': '<is> True'}:
# host1: thin_provisioning = False
# free_capacity_gb = 1024
# free = math.floor(1024 - 1024 * 0.1) = 921.0
@ -120,18 +188,18 @@ class CapacityWeigherTestCase(test.TestCase):
# free = math.floor(2048 * 2.0-1748-2048 * 0.1) = 2143.0
# free * (-1) = -2143.0
# weight = -1.0
# host3: thin_provisioning = False
# host3: thin_provisioning = [False]
# free_capacity_gb = 512
# free = math.floor(256 - 512 * 0) = 256.0
# free * (-1) = -256.0
# weight = -0.08
# host4: thin_provisioning = True
# host4: thin_provisioning = [True]
# max_over_subscription_ratio = 1.0
# free_capacity_gb = 200
# free = math.floor(2048 * 1.0 - 1848 - 2048 * 0.05) = 97.0
# free * (-1) = -97.0
# weight = 0.0
# host5: thin_provisioning = True
# host5: thin_provisioning = [True, False]
# max_over_subscription_ratio = 1.5
# free_capacity_gb = 500
# free = math.floor(2048 * 1.5 - 1548 - 2048 * 0.05) = 1421.0
@ -143,15 +211,52 @@ class CapacityWeigherTestCase(test.TestCase):
# weight = 0.0
# so, host4 should win:
weighed_host = self._get_weighed_host(hostinfo_list)
weight_properties = {
'size': 1,
'share_type': {
'extra_specs': {
cap_thin_key: cap_thin,
}
}
}
weighed_host = self._get_weighed_host(
hostinfo_list,
weight_properties=weight_properties)
self.assertEqual(0.0, weighed_host.weight)
self.assertEqual(
'host4', utils.extract_host(weighed_host.obj.host))
winner, utils.extract_host(weighed_host.obj.host))
def test_capacity_weight_multiplier_2(self):
@ddt.data(
{'cap_thin': '<is> True',
'cap_thin_key': 'capabilities:thin_provisioning',
'winner': 'host2'},
{'cap_thin': '<is> False',
'cap_thin_key': 'thin_provisioning',
'winner': 'host1'},
{'cap_thin': 'True',
'cap_thin_key': 'capabilities:thin_provisioning',
'winner': 'host2'},
{'cap_thin': 'False',
'cap_thin_key': 'thin_provisioning',
'winner': 'host1'},
{'cap_thin': 'true',
'cap_thin_key': 'capabilities:thin_provisioning',
'winner': 'host2'},
{'cap_thin': 'false',
'cap_thin_key': 'thin_provisioning',
'winner': 'host1'},
{'cap_thin': None,
'cap_thin_key': None,
'winner': 'host2'},
)
@ddt.unpack
def test_capacity_weight_multiplier_2(self, cap_thin, cap_thin_key,
winner):
self.flags(capacity_weight_multiplier=2.0)
hostinfo_list = self._get_all_hosts()
# Results for the 1st test
# {'capabilities:thin_provisioning': '<is> True'}:
# host1: thin_provisioning = False
# free_capacity_gb = 1024
# free = math.floor(1024-1024*0.1) = 921.0
@ -163,18 +268,18 @@ class CapacityWeigherTestCase(test.TestCase):
# free = math.floor(2048 * 2.0 - 1748 - 2048 * 0.1) = 2143.0
# free * 2 = 4286.0
# weight = 2.0
# host3: thin_provisioning = False
# host3: thin_provisioning = [False]
# free_capacity_gb = 512
# free = math.floor(256 - 512 * 0) = 256.0
# free * 2 = 512.0
# weight = 0.16
# host4: thin_provisioning = True
# host4: thin_provisioning = [True]
# max_over_subscription_ratio = 1.0
# free_capacity_gb = 200
# free = math.floor(2048 * 1.0 - 1848 - 2048 * 0.05) = 97.0
# free * 2 = 194.0
# weight = 0.0
# host5: thin_provisioning = True
# host5: thin_provisioning = [True, False]
# max_over_subscription_ratio = 1.5
# free_capacity_gb = 500
# free = math.floor(2048 * 1.5 - 1548 - 2048 * 0.05) = 1421.0
@ -185,7 +290,17 @@ class CapacityWeigherTestCase(test.TestCase):
# weight = 0.0
# so, host2 should win:
weighed_host = self._get_weighed_host(hostinfo_list)
weight_properties = {
'size': 1,
'share_type': {
'extra_specs': {
cap_thin_key: cap_thin,
}
}
}
weighed_host = self._get_weighed_host(
hostinfo_list,
weight_properties=weight_properties)
self.assertEqual(2.0, weighed_host.weight)
self.assertEqual(
'host2', utils.extract_host(weighed_host.obj.host))
winner, utils.extract_host(weighed_host.obj.host))

7
releasenotes/notes/check-thin-provisioning-4bb702535f6b10b6.yaml

@ -0,0 +1,7 @@
---
fixes:
- Capacity filter and weigher scheduler logic was modified to
account for back ends that can support thin and thick provisioning
for shares. Over subscription calculation is triggered with the
presence of the ``thin_provisioning`` extra-spec in the share type
of the share being created.
Loading…
Cancel
Save