def test_set_parameter_values(self):
# Setup
test_role = self._add_test_role()
test_plan = self.plans_manager.create_plan('p1', 'd1')
self.plans_manager.add_role_to_plan(test_plan.uuid, test_role.uuid)
# Test
ns = name_utils.generate_role_namespace(test_role.name,
test_role.version)
update_us = [
ParameterValue(ns_utils.apply_template_namespace(ns, 'key_name'),
'test-key'),
ParameterValue(ns_utils.apply_template_namespace(ns, 'image_id'),
'test-image'),
]
updated_plan = self.plans_manager.set_parameter_values(test_plan.uuid,
update_us)
# Verify
self.assertTrue(updated_plan is not None)
self.assertTrue(isinstance(updated_plan, DeploymentPlan))
# Pull it from the database again to make sure it was saved
found = self.plans_manager.retrieve_plan(test_plan.uuid)
found_params = sorted(found.parameters, key=lambda x: x.name)
self.assertEqual(4, len(found_params)) # 3 + 1 for scaling
self.assertEqual(found_params[0].value, '1')
self.assertEqual(found_params[1].value, 'test-image')
self.assertEqual(found_params[2].value, 'm1.small')
self.assertEqual(found_params[3].value, 'test-key')
def test_set_parameter_values(self):
# Setup
test_role = self._add_test_role()
test_plan = self.plans_manager.create_plan('p1', 'd1')
self.plans_manager.add_role_to_plan(test_plan.uuid, test_role.uuid)
# Test
ns = name_utils.generate_role_namespace(test_role.name,
test_role.version)
update_us = [
ParameterValue(ns_utils.apply_template_namespace(ns, 'key_name'),
'test-key'),
ParameterValue(ns_utils.apply_template_namespace(ns, 'image_id'),
'test-image'),
]
updated_plan = self.plans_manager.set_parameter_values(
test_plan.uuid, update_us)
# Verify
self.assertTrue(updated_plan is not None)
self.assertTrue(isinstance(updated_plan, DeploymentPlan))
# Pull it from the database again to make sure it was saved
found = self.plans_manager.retrieve_plan(test_plan.uuid)
found_params = sorted(found.parameters, key=lambda x: x.name)
self.assertEqual(4, len(found_params)) # 3 + 1 for scaling
self.assertEqual(found_params[0].value, '1')
self.assertEqual(found_params[1].value, 'test-image')
self.assertEqual(found_params[2].value, 'm1.small')
self.assertEqual(found_params[3].value, 'test-key')
def _add_resource(self, namespace, template, resource_alias):
resource = Resource(_generate_resource_id(namespace), resource_alias)
for map_me in template.parameters:
name = map_me.name
master_name = ns_utils.apply_template_namespace(namespace,
map_me.name)
value = {'get_param': [master_name]}
resource_property = ResourceProperty(name, value)
resource.add_property(resource_property)
# If scaling features are being automatically added in, wrap the
# resource in a resource group. The _add_parameters call will add
# a corresponding parameter for the count of this resource.
if self.add_scaling:
group_resource_id = _generate_group_id(resource.resource_id)
heat_group = Resource(group_resource_id, HEAT_TYPE_RESOURCE_GROUP)
count_prop = ResourceProperty(
PROPERTY_SCALING_COUNT,
{'get_param': [_generate_count_property_name(namespace)]})
heat_group.add_property(count_prop)
def_prop = ResourceProperty(PROPERTY_RESOURCE_DEFINITION, resource)
heat_group.add_property(def_prop)
outer_resource = heat_group
else:
outer_resource = resource
self.master_template.add_resource(outer_resource)
return outer_resource
def _add_to_environment(self, namespace, template, filename,
resource_alias, override_properties):
# Add Parameters
for add_me in template.parameters:
# For overridden properties, don't add a template property; the
# user does not need to specify a value for them.
if add_me.name in override_properties:
continue
name = ns_utils.apply_template_namespace(namespace, add_me.name)
param_default = add_me.default
if param_default is None:
param_default = ''
env_parameter = EnvironmentParameter(name, param_default)
self.environment.add_parameter(env_parameter)
if self.add_scaling:
count_param_name = generate_count_property_name(namespace)
count_param = EnvironmentParameter(count_param_name, '1')
self.environment.add_parameter(count_param)
removal_param_name = generate_removal_policies_name(namespace)
removal_param = EnvironmentParameter(removal_param_name, [])
self.environment.add_parameter(removal_param)
# Add Resource Registry Entry
registry_entry = RegistryEntry(resource_alias, filename)
self.environment.add_registry_entry(registry_entry)
def _add_to_environment(self, namespace, template,
filename, resource_alias, override_properties):
# Add Parameters
for add_me in template.parameters:
# For overridden properties, don't add a template property; the
# user does not need to specify a value for them.
if add_me.name in override_properties:
continue
name = ns_utils.apply_template_namespace(namespace, add_me.name)
param_default = add_me.default
if param_default is None:
param_default = ''
env_parameter = EnvironmentParameter(name, param_default)
self.environment.add_parameter(env_parameter)
if self.add_scaling:
count_param_name = generate_count_property_name(namespace)
count_param = EnvironmentParameter(count_param_name, '1')
self.environment.add_parameter(count_param)
# Add Resource Registry Entry
registry_entry = RegistryEntry(resource_alias, filename)
self.environment.add_registry_entry(registry_entry)
def _add_resource(self, namespace, template, resource_alias):
resource = Resource(_generate_resource_id(namespace), resource_alias)
for map_me in template.parameters:
name = map_me.name
master_name = ns_utils.apply_template_namespace(
namespace, map_me.name)
value = {'get_param': [master_name]}
resource_property = ResourceProperty(name, value)
resource.add_property(resource_property)
# If scaling features are being automatically added in, wrap the
# resource in a resource group. The _add_parameters call will add
# a corresponding parameter for the count of this resource.
if self.add_scaling:
group_resource_id = _generate_group_id(resource.resource_id)
heat_group = Resource(group_resource_id, HEAT_TYPE_RESOURCE_GROUP)
count_prop = ResourceProperty(
PROPERTY_SCALING_COUNT,
{'get_param': [_generate_count_property_name(namespace)]})
heat_group.add_property(count_prop)
def_prop = ResourceProperty(PROPERTY_RESOURCE_DEFINITION, resource)
heat_group.add_property(def_prop)
outer_resource = heat_group
else:
outer_resource = resource
self.master_template.add_resource(outer_resource)
return outer_resource
def test_remove_parameters_by_namespace(self):
# Setup
t = heat.Template()
p1 = heat.Parameter(ns.apply_template_namespace('ns1', 'foo'), 't')
p2 = heat.Parameter(ns.apply_template_namespace('ns2', 'bar'), 't')
p3 = heat.Parameter(ns.apply_template_namespace('ns1', 'baz'), 't')
t.add_parameter(p1)
t.add_parameter(p2)
t.add_parameter(p3)
# Test
t.remove_parameters_by_namespace('ns1')
# Verify
self.assertEqual(1, len(t.parameters))
self.assertEqual(p2, t.parameters[0])
def test_remove_parameters_by_namespace(self):
# Setup
t = heat.Template()
p1 = heat.Parameter(ns.apply_template_namespace('ns1', 'foo'), 't')
p2 = heat.Parameter(ns.apply_template_namespace('ns2', 'bar'), 't')
p3 = heat.Parameter(ns.apply_template_namespace('ns1', 'baz'), 't')
t.add_parameter(p1)
t.add_parameter(p2)
t.add_parameter(p3)
# Test
t.remove_parameters_by_namespace('ns1')
# Verify
self.assertEqual(1, len(t.parameters))
self.assertEqual(p2, t.parameters[0])
def test_add_template_no_scaling(self):
# Test
p = plan.DeploymentPlan(add_scaling=False)
t = self._generate_template()
p.add_template('ns1', t, 'template-1.yaml')
# Verify Master Template Parameters
self.assertEqual(2, len(p.master_template.parameters))
for original, added in zip(t.parameters, p.master_template.parameters):
self.assertTrue(added is not original)
expected_name = ns_utils.apply_template_namespace(
'ns1', original.name)
self.assertEqual(added.name, expected_name)
self.assertEqual(added.param_type, original.param_type)
# Verify Resource
self.assertEqual(1, len(p.master_template.resources))
added = p.master_template.resources[0]
expected_id = plan.generate_resource_id('ns1')
self.assertEqual(added.resource_id, expected_id)
expected_type = ns_utils.apply_resource_alias_namespace('ns1')
self.assertEqual(added.resource_type, expected_type)
for param, prop in zip(t.parameters, added.properties):
v = ns_utils.apply_template_namespace('ns1', param.name)
expected_value = {'get_param': [v]}
self.assertEqual(prop.value, expected_value)
# Verify Environment Parameters
self.assertEqual(2, len(p.environment.parameters))
for env_param, template_param in zip(p.environment.parameters,
t.parameters):
expected_name = (ns_utils.apply_template_namespace(
'ns1', template_param.name))
self.assertEqual(env_param.name, expected_name)
self.assertEqual(env_param.value, '')
# Verify Resource Registry Entry
self.assertEqual(1, len(p.environment.registry_entries))
added = p.environment.registry_entries[0]
expected_alias = ns_utils.apply_resource_alias_namespace('ns1')
self.assertEqual(added.alias, expected_alias)
self.assertEqual(added.filename, 'template-1.yaml')
def test_add_template_no_scaling(self):
# Test
p = plan.DeploymentPlan(add_scaling=False)
t = self._generate_template()
p.add_template('ns1', t, 'template-1.yaml')
# Verify Master Template Parameters
self.assertEqual(2, len(p.master_template.parameters))
for original, added in zip(t.parameters, p.master_template.parameters):
self.assertTrue(added is not original)
expected_name = ns_utils.apply_template_namespace('ns1',
original.name)
self.assertEqual(added.name, expected_name)
self.assertEqual(added.param_type, original.param_type)
# Verify Resource
self.assertEqual(1, len(p.master_template.resources))
added = p.master_template.resources[0]
expected_id = plan._generate_resource_id('ns1')
self.assertEqual(added.resource_id, expected_id)
expected_type = ns_utils.apply_resource_alias_namespace('ns1')
self.assertEqual(added.resource_type, expected_type)
for param, prop in zip(t.parameters, added.properties):
v = ns_utils.apply_template_namespace('ns1', param.name)
expected_value = {'get_param': [v]}
self.assertEqual(prop.value, expected_value)
# Verify Environment Parameters
self.assertEqual(2, len(p.environment.parameters))
for env_param, template_param in zip(p.environment.parameters,
t.parameters):
expected_name = (
ns_utils.apply_template_namespace('ns1', template_param.name))
self.assertEqual(env_param.name, expected_name)
self.assertEqual(env_param.value, '')
# Verify Resource Registry Entry
self.assertEqual(1, len(p.environment.registry_entries))
added = p.environment.registry_entries[0]
expected_alias = ns_utils.apply_resource_alias_namespace('ns1')
self.assertEqual(added.alias, expected_alias)
self.assertEqual(added.filename, 'template-1.yaml')
def _update_property(check_me):
if isinstance(check_me, dict):
for k, v in check_me.items():
if k == 'get_param' and v in all_role_property_keys:
check_me[k] = ns_utils.apply_template_namespace(namespace,
v)
else:
# It could be a nested dictionary, so recurse further
_update_property(v)
def generate_removal_policies_name(namespace):
"""Generates the name of the property to hold the removal policies for
a group. The property will be prefixed by the namespace in the same way
as other parameters for the resource.
:type namespace: str
:rtype: str
"""
return ns_utils.apply_template_namespace(namespace, 'removal_policies')
def test_remove_outputs_by_namespace(self):
# Setup
t = heat.Template()
o1 = heat.Output(ns.apply_template_namespace('ns1', 'foo'), 'v')
o2 = heat.Output(ns.apply_template_namespace('ns2', 'bar'), 'v')
o3 = heat.Output(ns.apply_template_namespace('ns1', 'foo'), 'v')
t.add_output(o1)
t.add_output(o2)
t.add_output(o3)
# Test
t.remove_outputs_by_namespace('ns1')
# Verify
self.assertEqual(1, len(t.outputs))
self.assertEqual(o2, t.outputs[0])
def _update_property(check_me):
if isinstance(check_me, dict):
for k, v in check_me.items():
if k == 'get_param' and v in all_role_property_keys:
check_me[k] = ns_utils.apply_template_namespace(
namespace, v)
else:
# It could be a nested dictionary, so recurse further
_update_property(v)
def test_add_template_with_default_parameter_value(self):
# Test
p = plan.DeploymentPlan()
t = heat.Template()
t.add_parameter(heat.Parameter('param-1', 'type-1', default='d1'))
t.add_parameter(heat.Parameter('param-2', 'type-2'))
p.add_template('ns1', t, 'template-1.yaml')
# Verify
p1 = p.environment.parameters[0]
self.assertEqual(ns_utils.apply_template_namespace('ns1', 'param-1'),
p1.name)
self.assertEqual('d1', p1.value)
p2 = p.environment.parameters[1]
self.assertEqual(ns_utils.apply_template_namespace('ns1', 'param-2'),
p2.name)
self.assertEqual('', p2.value)
def test_remove_outputs_by_namespace(self):
# Setup
t = heat.Template()
o1 = heat.Output(ns.apply_template_namespace('ns1', 'foo'), 'v')
o2 = heat.Output(ns.apply_template_namespace('ns2', 'bar'), 'v')
o3 = heat.Output(ns.apply_template_namespace('ns1', 'foo'), 'v')
t.add_output(o1)
t.add_output(o2)
t.add_output(o3)
# Test
t.remove_outputs_by_namespace('ns1')
# Verify
self.assertEqual(1, len(t.outputs))
self.assertEqual(o2, t.outputs[0])
def test_add_template_with_default_parameter_value(self):
# Test
p = plan.DeploymentPlan()
t = heat.Template()
t.add_parameter(heat.Parameter('param-1', 'type-1', default='d1'))
t.add_parameter(heat.Parameter('param-2', 'type-2'))
p.add_template('ns1', t, 'template-1.yaml')
# Verify
p1 = p.environment.parameters[0]
self.assertEqual(ns_utils.apply_template_namespace('ns1', 'param-1'),
p1.name)
self.assertEqual('d1', p1.value)
p2 = p.environment.parameters[1]
self.assertEqual(ns_utils.apply_template_namespace('ns1', 'param-2'),
p2.name)
self.assertEqual('', p2.value)
def generate_count_property_name(namespace):
"""Generates the name of the property to hold the count of a particular
resource as identified by its namespace. The count property will be
prefixed by the namespace in the same way as other parameters for the
resource.
:type namespace: str
:rtype: str
"""
return ns_utils.apply_template_namespace(namespace, 'count')
def _generate_count_property_name(namespace):
"""Generates the name of the property to hold the count of a particular
resource as identified by its namespace. The count property will be
prefixed by the namespace in the same way as other parameters for the
resource.
:type namespace: str
:rtype: str
"""
return ns_utils.apply_template_namespace(namespace, 'count')
def test_set_non_existent_parameters(self):
# Setup
test_role = self._add_test_role()
test_plan = self.plans_manager.create_plan('p1', 'd1')
self.plans_manager.add_role_to_plan(test_plan.uuid, test_role.uuid)
# Test
ns = name_utils.generate_role_namespace(test_role.name,
test_role.version)
not_present_in_role_1_name = ns_utils.apply_template_namespace(
ns, 'not_present_in_role_1')
not_present_in_role_2_name = ns_utils.apply_template_namespace(
ns, 'not_present_in_role_2')
update_us = [
ParameterValue(ns_utils.apply_template_namespace(ns, 'key_name'),
'test-key'),
ParameterValue(ns_utils.apply_template_namespace(ns, 'image_id'),
'test-image'),
ParameterValue(not_present_in_role_1_name,
'not-present-in-role-1-value'),
ParameterValue(not_present_in_role_2_name,
'not-present-in-role-2-value'),
]
# Verify
exc = self.assertRaises(exception.PlanParametersNotExist,
self.plans_manager.set_parameter_values,
test_plan.uuid,
update_us)
self.assertIn(not_present_in_role_1_name, str(exc))
self.assertIn(not_present_in_role_2_name, str(exc))
# Pull it from the database to make sure it was modified
found = self.plans_manager.retrieve_plan(test_plan.uuid)
found_params = sorted(found.parameters, key=lambda x: x.name)
self.assertEqual(4, len(found_params)) # 3 + 1 for scaling
self.assertEqual(found_params[0].value, '1')
self.assertEqual(found_params[1].value,
'3e6270da-fbf7-4aef-bc78-6d0cfc3ad11b')
self.assertEqual(found_params[2].value, 'm1.small')
self.assertEqual(found_params[3].value, '')
def test_remove_parameters_by_namespace(self):
# Setup
e = heat.Environment()
p1 = heat.EnvironmentParameter(
ns.apply_template_namespace('ns1', 'n1'), 'v')
p2 = heat.EnvironmentParameter(
ns.apply_template_namespace('ns2', 'n2'), 'v')
p3 = heat.EnvironmentParameter(
ns.apply_template_namespace('ns1', 'n3'), 'v')
e.add_parameter(p1)
e.add_parameter(p2)
e.add_parameter(p3)
# Test
e.remove_parameters_by_namespace('ns1')
# Verify
self.assertEqual(1, len(e.parameters))
self.assertEqual(p2, e.parameters[0])
def _add_outputs(self, namespace, template, resource):
for add_me in template.outputs:
# The output creation is a bit trickier than simply copying the
# original. The master output is namespaced like the other pieces,
# and it's value is retrieved from the resource that's created in
# the master template, but will be present in that resource
# under it's original name.
output_name = ns_utils.apply_template_namespace(namespace,
add_me.name)
output_value = {'get_attr': [resource.resource_id, add_me.name]}
master_out = Output(output_name, output_value)
self.master_template.add_output(master_out)
def test_remove_parameters_by_namespace(self):
# Setup
e = heat.Environment()
p1 = heat.EnvironmentParameter(
ns.apply_template_namespace('ns1', 'n1'), 'v')
p2 = heat.EnvironmentParameter(
ns.apply_template_namespace('ns2', 'n2'), 'v')
p3 = heat.EnvironmentParameter(
ns.apply_template_namespace('ns1', 'n3'), 'v')
e.add_parameter(p1)
e.add_parameter(p2)
e.add_parameter(p3)
# Test
e.remove_parameters_by_namespace('ns1')
# Verify
self.assertEqual(1, len(e.parameters))
self.assertEqual(p2, e.parameters[0])
def _add_outputs(self, namespace, template, resource):
for add_me in template.outputs:
# The output creation is a bit trickier than simply copying the
# original. The master output is namespaced like the other pieces,
# and it's value is retrieved from the resource that's created in
# the master template, but will be present in that resource
# under it's original name.
output_name = ns_utils.apply_template_namespace(
namespace, add_me.name)
output_value = {'get_attr': [resource.resource_id, add_me.name]}
master_out = Output(output_name, output_value)
self.master_template.add_output(master_out)
def test_set_non_existent_parameters(self):
# Setup
test_role = self._add_test_role()
test_plan = self.plans_manager.create_plan('p1', 'd1')
self.plans_manager.add_role_to_plan(test_plan.uuid, test_role.uuid)
# Test
ns = name_utils.generate_role_namespace(test_role.name,
test_role.version)
not_present_in_role_1_name = ns_utils.apply_template_namespace(
ns, 'not_present_in_role_1')
not_present_in_role_2_name = ns_utils.apply_template_namespace(
ns, 'not_present_in_role_2')
update_us = [
ParameterValue(ns_utils.apply_template_namespace(ns, 'key_name'),
'test-key'),
ParameterValue(ns_utils.apply_template_namespace(ns, 'image_id'),
'test-image'),
ParameterValue(not_present_in_role_1_name,
'not-present-in-role-1-value'),
ParameterValue(not_present_in_role_2_name,
'not-present-in-role-2-value'),
]
# Verify
exc = self.assertRaises(exception.PlanParametersNotExist,
self.plans_manager.set_parameter_values,
test_plan.uuid, update_us)
self.assertIn(not_present_in_role_1_name, str(exc))
self.assertIn(not_present_in_role_2_name, str(exc))
# Pull it from the database to make sure it was modified
found = self.plans_manager.retrieve_plan(test_plan.uuid)
found_params = sorted(found.parameters, key=lambda x: x.name)
self.assertEqual(4, len(found_params)) # 3 + 1 for scaling
self.assertEqual(found_params[0].value, '1')
self.assertEqual(found_params[1].value,
'3e6270da-fbf7-4aef-bc78-6d0cfc3ad11b')
self.assertEqual(found_params[2].value, 'm1.small')
self.assertEqual(found_params[3].value, '')
def _add_parameters(self, namespace, template):
for add_me in template.parameters:
cloned = copy.deepcopy(add_me)
cloned.name = ns_utils.apply_template_namespace(
namespace, add_me.name)
self.master_template.add_parameter(cloned)
# If scaling features are being automatically added in, create the
# template parameter for accepting the count for the resource with
# this namespace
if self.add_scaling:
count_param = Parameter(_generate_count_property_name(namespace),
'number')
constraint = ParameterConstraint('range', {'min': 1})
count_param.add_constraint(constraint)
self.master_template.add_parameter(count_param)
def _add_to_environment(self, namespace, template, filename,
resource_alias):
# Add Parameters
for add_me in template.parameters:
name = ns_utils.apply_template_namespace(namespace, add_me.name)
env_parameter = EnvironmentParameter(name, add_me.default or '')
self.environment.add_parameter(env_parameter)
if self.add_scaling:
count_param_name = _generate_count_property_name(namespace)
count_param = EnvironmentParameter(count_param_name, 1)
self.environment.add_parameter(count_param)
# Add Resource Registry Entry
registry_entry = RegistryEntry(resource_alias, filename)
self.environment.add_registry_entry(registry_entry)
def _add_parameters(self, namespace, template):
for add_me in template.parameters:
cloned = copy.deepcopy(add_me)
cloned.name = ns_utils.apply_template_namespace(namespace,
add_me.name)
self.master_template.add_parameter(cloned)
# If scaling features are being automatically added in, create the
# template parameter for accepting the count for the resource with
# this namespace
if self.add_scaling:
count_param = Parameter(_generate_count_property_name(namespace),
'number')
constraint = ParameterConstraint('range', {'min': '1'})
count_param.add_constraint(constraint)
self.master_template.add_parameter(count_param)
def _add_to_environment(self, namespace, template,
filename, resource_alias):
# Add Parameters
for add_me in template.parameters:
name = ns_utils.apply_template_namespace(namespace, add_me.name)
env_parameter = EnvironmentParameter(name, add_me.default or '')
self.environment.add_parameter(env_parameter)
if self.add_scaling:
count_param_name = _generate_count_property_name(namespace)
count_param = EnvironmentParameter(count_param_name, '1')
self.environment.add_parameter(count_param)
# Add Resource Registry Entry
registry_entry = RegistryEntry(resource_alias, filename)
self.environment.add_registry_entry(registry_entry)
def _add_resource(self, namespace, template, resource_alias,
override_properties):
resource = Resource(generate_resource_id(namespace), resource_alias)
for map_me in template.parameters:
name = map_me.name
# If an explicit value is specified, use that. Otherwise, create
# a look up within the master template.
if name in override_properties:
value = override_properties[name]
else:
master_name = ns_utils.apply_template_namespace(
namespace, map_me.name)
value = {'get_param': [master_name]}
resource_property = ResourceProperty(name, value)
resource.add_property(resource_property)
# If scaling features are being automatically added in, wrap the
# resource in a resource group. The _add_parameters call will add
# a corresponding parameter for the count of this resource.
if self.add_scaling:
group_resource_id = generate_group_id(namespace)
heat_group = Resource(group_resource_id, HEAT_TYPE_RESOURCE_GROUP)
count_prop = ResourceProperty(
PROPERTY_SCALING_COUNT,
{'get_param': [generate_count_property_name(namespace)]})
heat_group.add_property(count_prop)
removal_prop = ResourceProperty(
PROPERTY_REMOVAL_POLICIES,
{'get_param': [generate_removal_policies_name(namespace)]})
heat_group.add_property(removal_prop)
def_prop = ResourceProperty(PROPERTY_RESOURCE_DEFINITION, resource)
heat_group.add_property(def_prop)
outer_resource = heat_group
else:
outer_resource = resource
self.master_template.add_resource(outer_resource)
return outer_resource
def _add_resource(self, namespace, template, resource_alias,
override_properties):
resource = Resource(generate_resource_id(namespace), resource_alias)
for map_me in template.parameters:
name = map_me.name
# If an explicit value is specified, use that. Otherwise, create
# a look up within the master template.
if name in override_properties:
value = override_properties[name]
else:
master_name = ns_utils.apply_template_namespace(namespace,
map_me.name)
value = {'get_param': [master_name]}
resource_property = ResourceProperty(name, value)
resource.add_property(resource_property)
# If scaling features are being automatically added in, wrap the
# resource in a resource group. The _add_parameters call will add
# a corresponding parameter for the count of this resource.
if self.add_scaling:
group_resource_id = generate_group_id(namespace)
heat_group = Resource(group_resource_id, HEAT_TYPE_RESOURCE_GROUP)
count_prop = ResourceProperty(
PROPERTY_SCALING_COUNT,
{'get_param': [generate_count_property_name(namespace)]})
heat_group.add_property(count_prop)
def_prop = ResourceProperty(PROPERTY_RESOURCE_DEFINITION, resource)
heat_group.add_property(def_prop)
outer_resource = heat_group
else:
outer_resource = resource
self.master_template.add_resource(outer_resource)
return outer_resource
def _add_parameters(self, namespace, template, override_properties):
for add_me in template.parameters:
if add_me.name in override_properties:
continue
cloned = copy.deepcopy(add_me)
cloned.name = ns_utils.apply_template_namespace(
namespace, add_me.name)
self.master_template.add_parameter(cloned)
# If scaling features are being automatically added in, create the
# template parameters for configuring the group
if self.add_scaling:
count_param = Parameter(generate_count_property_name(namespace),
'number')
constraint = ParameterConstraint('range', {'min': '0'})
count_param.add_constraint(constraint)
self.master_template.add_parameter(count_param)
removal_param = Parameter(
generate_removal_policies_name(namespace), 'json')
removal_param.default = []
self.master_template.add_parameter(removal_param)
def test_apply_template_namespace(self):
namespaced = namespace.apply_template_namespace('test-ns', 'test-name')
self.assertEqual(namespaced, 'test-ns::test-name')
self.assertTrue(namespace.matches_template_namespace('test-ns',
namespaced))
def test_apply_template_namespace(self):
namespaced = namespace.apply_template_namespace('test-ns', 'test-name')
self.assertEqual(namespaced, 'test-ns::test-name')
self.assertTrue(
namespace.matches_template_namespace('test-ns', namespaced))
