diff --git a/heat/engine/resources/openstack/heat/resource_group.py b/heat/engine/resources/openstack/heat/resource_group.py index dbed1d4e2e..d6fb46e5d8 100644 --- a/heat/engine/resources/openstack/heat/resource_group.py +++ b/heat/engine/resources/openstack/heat/resource_group.py @@ -322,24 +322,24 @@ class ResourceGroup(stack_resource.StackResource): raise exception.StackValidationFailed( ex, path=[self.stack.t.RESOURCES, path]) - def _current_blacklist(self): + def _current_skiplist(self): db_rsrc_names = self.data().get('name_blacklist') if db_rsrc_names: return db_rsrc_names.split(',') else: return [] - def _get_new_blacklist_entries(self, properties, current_blacklist): + def _get_new_skiplist_entries(self, properties, current_skiplist): insp = grouputils.GroupInspector.from_parent_resource(self) - # Now we iterate over the removal policies, and update the blacklist + # Now we iterate over the removal policies, and update the skiplist # with any additional names for r in properties.get(self.REMOVAL_POLICIES, []): if self.REMOVAL_RSRC_LIST in r: # Tolerate string or int list values for n in r[self.REMOVAL_RSRC_LIST]: str_n = str(n) - if (str_n in current_blacklist or + if (str_n in current_skiplist or self.resource_id is None or str_n in insp.member_names(include_failed=True)): yield str_n @@ -364,52 +364,52 @@ class ResourceGroup(stack_resource.StackResource): # outdated values after stack update. self._outputs = None - def _update_name_blacklist(self, properties): + def _update_name_skiplist(self, properties): """Resolve the remove_policies to names for removal.""" # To avoid reusing names after removal, we store a comma-separated - # blacklist in the resource data - in cases where you want to + # skiplist in the resource data - in cases where you want to # overwrite the stored data, removal_policies_mode: update can be used - curr_bl = set(self._current_blacklist()) + curr_sl = set(self._current_skiplist()) p_mode = properties.get(self.REMOVAL_POLICIES_MODE, self.REMOVAL_POLICY_APPEND) if p_mode == self.REMOVAL_POLICY_UPDATE: - init_bl = set() + init_sl = set() else: - init_bl = curr_bl - updated_bl = init_bl | set(self._get_new_blacklist_entries(properties, - curr_bl)) + init_sl = curr_sl + updated_sl = init_sl | set(self._get_new_skiplist_entries(properties, + curr_sl)) - # If the blacklist has changed, update the resource data - if updated_bl != curr_bl: - self.data_set('name_blacklist', ','.join(sorted(updated_bl))) + # If the skiplist has changed, update the resource data + if updated_sl != curr_sl: + self.data_set('name_blacklist', ','.join(sorted(updated_sl))) - def _name_blacklist(self): - """Get the list of resource names to blacklist.""" - bl = set(self._current_blacklist()) + def _name_skiplist(self): + """Get the list of resource names to skiplist.""" + sl = set(self._current_skiplist()) if self.resource_id is None: - bl |= set(self._get_new_blacklist_entries(self.properties, bl)) - return bl + sl |= set(self._get_new_skiplist_entries(self.properties, sl)) + return sl def _resource_names(self, size=None): - name_blacklist = self._name_blacklist() + name_skiplist = self._name_skiplist() if size is None: size = self.get_size() - def is_blacklisted(name): - return name in name_blacklist + def is_skipped(name): + return name in name_skiplist candidates = map(str, itertools.count()) - return itertools.islice(itertools.filterfalse(is_blacklisted, + return itertools.islice(itertools.filterfalse(is_skipped, candidates), size) - def _count_black_listed(self, existing_members): - """Return the number of current resource names that are blacklisted.""" - return len(self._name_blacklist() & set(existing_members)) + def _count_skipped(self, existing_members): + """Return the number of current resource names that are skipped.""" + return len(self._name_skiplist() & set(existing_members)) def handle_create(self): - self._update_name_blacklist(self.properties) + self._update_name_skiplist(self.properties) if self.update_policy.get(self.BATCH_CREATE) and self.get_size(): batch_create = self.update_policy[self.BATCH_CREATE] max_batch_size = batch_create[self.MAX_BATCH_SIZE] @@ -468,7 +468,7 @@ class ResourceGroup(stack_resource.StackResource): checkers = [] self.properties = json_snippet.properties(self.properties_schema, self.context) - self._update_name_blacklist(self.properties) + self._update_name_skiplist(self.properties) if prop_diff and self.res_def_changed(prop_diff): updaters = self._try_rolling_update() if updaters: @@ -491,7 +491,7 @@ class ResourceGroup(stack_resource.StackResource): def get_attribute(self, key, *path): if key == self.REMOVED_RSRC_LIST: - return self._current_blacklist() + return self._current_skiplist() if key == self.ATTR_ATTRIBUTES and not path: raise exception.InvalidTemplateAttribute(resource=self.name, key=key) @@ -680,11 +680,11 @@ class ResourceGroup(stack_resource.StackResource): template_version=('heat_template_version', '2015-04-30')): names = list(self._resource_names(total_capacity)) - name_blacklist = self._name_blacklist() + name_skiplist = self._name_skiplist() valid_resources = [(n, d) for n, d in grouputils.get_member_definitions(self) - if n not in name_blacklist] + if n not in name_skiplist] targ_cap = self.get_size() @@ -728,7 +728,7 @@ class ResourceGroup(stack_resource.StackResource): def _resolve_attribute(self, name): if name == self.REMOVED_RSRC_LIST: - return self._current_blacklist() + return self._current_skiplist() def _update_timeout(self, batch_cnt, pause_sec): total_pause_time = pause_sec * max(batch_cnt - 1, 0) @@ -761,12 +761,12 @@ class ResourceGroup(stack_resource.StackResource): while not duration.expired(): yield - # current capacity not including existing blacklisted + # current capacity not including existing skiplisted inspector = grouputils.GroupInspector.from_parent_resource(self) - num_blacklist = self._count_black_listed( + num_skiplist = self._count_skipped( inspector.member_names(include_failed=False)) num_resources = inspector.size(include_failed=True) - curr_cap = num_resources - num_blacklist + curr_cap = num_resources - num_skiplist batches = list(self._get_batches(self.get_size(), curr_cap, batch_size, min_in_service)) diff --git a/heat/engine/resources/openstack/heat/software_deployment.py b/heat/engine/resources/openstack/heat/software_deployment.py index 39a6d0675e..2e0ddeafab 100644 --- a/heat/engine/resources/openstack/heat/software_deployment.py +++ b/heat/engine/resources/openstack/heat/software_deployment.py @@ -709,10 +709,10 @@ class SoftwareDeploymentGroup(resource_group.ResourceGroup): def res_def_changed(self, prop_diff): return True - def _update_name_blacklist(self, properties): + def _update_name_skiplist(self, properties): pass - def _name_blacklist(self): + def _name_skiplist(self): return set() def get_resource_def(self, include_all=False): diff --git a/heat/tests/openstack/heat/test_resource_group.py b/heat/tests/openstack/heat/test_resource_group.py index 1355709ca4..ca26af6e64 100644 --- a/heat/tests/openstack/heat/test_resource_group.py +++ b/heat/tests/openstack/heat/test_resource_group.py @@ -648,7 +648,7 @@ class ResourceGroupTest(common.HeatTestCase): resg = stack.resources['group1'] self.assertIsNone(resg.validate()) - def test_validate_with_blacklist(self): + def test_validate_with_skiplist(self): templ = copy.deepcopy(template_server) self.mock_flavor = mock.Mock(ram=4, disk=4) self.mock_active_image = mock.Mock(min_ram=1, min_disk=1, @@ -822,11 +822,11 @@ class ResourceGroupTest(common.HeatTestCase): self.assertTrue(resgrp._assemble_nested.called) -class ResourceGroupBlackList(common.HeatTestCase): - """This class tests ResourceGroup._name_blacklist().""" +class ResourceGroupSkiplistTest(common.HeatTestCase): + """This class tests ResourceGroup._name_skiplist().""" - # 1) no resource_list, empty blacklist - # 2) no resource_list, existing blacklist + # 1) no resource_list, empty skiplist + # 2) no resource_list, existing skiplist # 3) resource_list not in nested() # 4) resource_list (refid) not in nested() # 5) resource_list in nested() -> saved @@ -876,7 +876,7 @@ class ResourceGroupBlackList(common.HeatTestCase): saved=True, fallback=True, rm_mode='update')), ] - def test_blacklist(self): + def test_skiplist(self): stack = utils.parse_stack(template) resg = stack['group1'] @@ -923,13 +923,13 @@ class ResourceGroupBlackList(common.HeatTestCase): nested.resource_by_refid.side_effect = by_refid resg.nested = mock.Mock(return_value=nested) - resg._update_name_blacklist(properties) + resg._update_name_skiplist(properties) if self.saved: resg.data_set.assert_called_once_with('name_blacklist', ','.join(self.expected)) else: resg.data_set.assert_not_called() - self.assertEqual(set(self.expected), resg._name_blacklist()) + self.assertEqual(set(self.expected), resg._name_skiplist()) class ResourceGroupEmptyParams(common.HeatTestCase): @@ -979,18 +979,18 @@ class ResourceGroupEmptyParams(common.HeatTestCase): class ResourceGroupNameListTest(common.HeatTestCase): """This class tests ResourceGroup._resource_names().""" - # 1) no blacklist, 0 count - # 2) no blacklist, x count - # 3) blacklist (not effecting) - # 4) blacklist with pruning + # 1) no skiplist, 0 count + # 2) no skiplist, x count + # 3) skiplist (not effecting) + # 4) skiplist with pruning scenarios = [ - ('1', dict(blacklist=[], count=0, + ('1', dict(skiplist=[], count=0, expected=[])), - ('2', dict(blacklist=[], count=4, + ('2', dict(skiplist=[], count=4, expected=['0', '1', '2', '3'])), - ('3', dict(blacklist=['5', '6'], count=3, + ('3', dict(skiplist=['5', '6'], count=3, expected=['0', '1', '2'])), - ('4', dict(blacklist=['2', '4'], count=4, + ('4', dict(skiplist=['2', '4'], count=4, expected=['0', '1', '3', '5'])), ] @@ -1000,7 +1000,7 @@ class ResourceGroupNameListTest(common.HeatTestCase): resg.properties = mock.MagicMock() resg.properties.get.return_value = self.count - resg._name_blacklist = mock.MagicMock(return_value=self.blacklist) + resg._name_skiplist = mock.MagicMock(return_value=self.skiplist) self.assertEqual(self.expected, list(resg._resource_names())) @@ -1115,7 +1115,7 @@ class ResourceGroupAttrTest(common.HeatTestCase): rsrc = stack.defn['group1'] self.assertEqual(['rsrc1', 'rsrc2'], rsrc.FnGetAtt('refs')) - def test_get_attribute_blacklist(self): + def test_get_attribute_skiplist(self): resg = self._create_dummy_stack() resg.data = mock.Mock(return_value={'name_blacklist': '3,5'}) @@ -1201,48 +1201,48 @@ class ResourceGroupAttrFallbackTest(ResourceGroupAttrTest): class ReplaceTest(common.HeatTestCase): # 1. no min_in_service - # 2. min_in_service > count and existing with no blacklist - # 3. min_in_service > count and existing with blacklist - # 4. existing > count and min_in_service with blacklist - # 5. existing > count and min_in_service with no blacklist - # 6. all existing blacklisted - # 7. count > existing and min_in_service with no blacklist - # 8. count > existing and min_in_service with blacklist - # 9. count < existing - blacklisted + # 2. min_in_service > count and existing with no skiplist + # 3. min_in_service > count and existing with skiplist + # 4. existing > count and min_in_service with skiplist + # 5. existing > count and min_in_service with no skiplist + # 6. all existing skipped + # 7. count > existing and min_in_service with no skiplist + # 8. count > existing and min_in_service with skiplist + # 9. count < existing - skiplisted # 10. pause_sec > 0 scenarios = [ ('1', dict(min_in_service=0, count=2, - existing=['0', '1'], black_listed=['0'], + existing=['0', '1'], skipped=['0'], batch_size=1, pause_sec=0, tasks=2)), ('2', dict(min_in_service=3, count=2, - existing=['0', '1'], black_listed=[], + existing=['0', '1'], skipped=[], batch_size=2, pause_sec=0, tasks=3)), ('3', dict(min_in_service=3, count=2, - existing=['0', '1'], black_listed=['0'], + existing=['0', '1'], skipped=['0'], batch_size=2, pause_sec=0, tasks=3)), ('4', dict(min_in_service=3, count=2, - existing=['0', '1', '2', '3'], black_listed=['2', '3'], + existing=['0', '1', '2', '3'], skipped=['2', '3'], batch_size=1, pause_sec=0, tasks=4)), ('5', dict(min_in_service=2, count=2, - existing=['0', '1', '2', '3'], black_listed=[], + existing=['0', '1', '2', '3'], skipped=[], batch_size=2, pause_sec=0, tasks=2)), ('6', dict(min_in_service=2, count=3, - existing=['0', '1'], black_listed=['0', '1'], + existing=['0', '1'], skipped=['0', '1'], batch_size=2, pause_sec=0, tasks=2)), ('7', dict(min_in_service=0, count=5, - existing=['0', '1'], black_listed=[], + existing=['0', '1'], skipped=[], batch_size=1, pause_sec=0, tasks=5)), ('8', dict(min_in_service=0, count=5, - existing=['0', '1'], black_listed=['0'], + existing=['0', '1'], skipped=['0'], batch_size=1, pause_sec=0, tasks=5)), ('9', dict(min_in_service=0, count=3, existing=['0', '1', '2', '3', '4', '5'], - black_listed=['0'], + skipped=['0'], batch_size=2, pause_sec=0, tasks=2)), ('10', dict(min_in_service=0, count=3, existing=['0', '1', '2', '3', '4', '5'], - black_listed=['0'], + skipped=['0'], batch_size=2, pause_sec=10, tasks=3))] def setUp(self): @@ -1263,8 +1263,8 @@ class ReplaceTest(common.HeatTestCase): def test_rolling_updates(self): self.group._nested = get_fake_nested_stack(self.existing) self.group.get_size = mock.Mock(return_value=self.count) - self.group._name_blacklist = mock.Mock( - return_value=set(self.black_listed)) + self.group._name_skiplist = mock.Mock( + return_value=set(self.skipped)) tasks = self.group._replace(self.min_in_service, self.batch_size, self.pause_sec) self.assertEqual(self.tasks, len(tasks)) @@ -1468,18 +1468,18 @@ class RollingUpdateTest(common.HeatTestCase): class TestUtils(common.HeatTestCase): - # 1. No existing no blacklist - # 2. Existing with no blacklist - # 3. Existing with blacklist + # 1. No existing no skiplist + # 2. Existing with no skiplist + # 3. Existing with skiplist scenarios = [ - ('1', dict(existing=[], black_listed=[], count=0)), - ('2', dict(existing=['0', '1'], black_listed=[], count=0)), - ('3', dict(existing=['0', '1'], black_listed=['0'], count=1)), - ('4', dict(existing=['0', '1'], black_listed=['1', '2'], count=1)) + ('1', dict(existing=[], skipped=[], count=0)), + ('2', dict(existing=['0', '1'], skipped=[], count=0)), + ('3', dict(existing=['0', '1'], skipped=['0'], count=1)), + ('4', dict(existing=['0', '1'], skipped=['1', '2'], count=1)) ] - def test_count_black_listed(self): + def test_count_skipped(self): inspector = mock.Mock(spec=grouputils.GroupInspector) self.patchobject(grouputils.GroupInspector, 'from_parent_resource', return_value=inspector) @@ -1488,8 +1488,8 @@ class TestUtils(common.HeatTestCase): stack = utils.parse_stack(template2) snip = stack.t.resource_definitions(stack)['group1'] resgrp = resource_group.ResourceGroup('test', snip, stack) - resgrp._name_blacklist = mock.Mock(return_value=set(self.black_listed)) - rcount = resgrp._count_black_listed(self.existing) + resgrp._name_skiplist = mock.Mock(return_value=set(self.skipped)) + rcount = resgrp._count_skipped(self.existing) self.assertEqual(self.count, rcount) @@ -1761,7 +1761,7 @@ class TestGetBatches(common.HeatTestCase): self.stack = utils.parse_stack(template) self.grp = self.stack['group1'] - self.grp._name_blacklist = mock.Mock(return_value={'0'}) + self.grp._name_skiplist = mock.Mock(return_value={'0'}) def test_get_batches(self): batches = list(self.grp._get_batches(self.targ_cap,