From e3950a4e727f548c1dcc41c137baecb1ed32b5c2 Mon Sep 17 00:00:00 2001 From: Angus Salkeld Date: Mon, 16 Mar 2015 14:07:38 +1000 Subject: [PATCH] Pass the environment into the Template class and not Stack When we moved parameters from the stack table to the template table we did it in a "flexible" way, but this led to some difficult to diagnose problems. So this patch totally removes "env" as an argument to the Stack class to make absolutely sure that we are doing this correctly. I came across these bugs when rebasing decouple-nested. - env was not getting passed into instance group make_templates() - template deepcopy was not working correctly (causing some problems when deleting backup stacks) Change-Id: I85cfb01c68ff5a44e2ff4f6e446870efb7205933 --- .../tests/test_rackspace_cloud_server.py | 5 +- .../rackspace/tests/test_rackspace_dns.py | 4 +- .../openstack/heat/instance_group.py | 8 +- heat/engine/stack.py | 30 +++-- heat/engine/template.py | 3 +- heat/scaling/template.py | 5 +- heat/tests/aws/test_waitcondition.py | 5 +- heat/tests/openstack/test_waitcondition.py | 4 +- heat/tests/test_engine_service.py | 10 +- heat/tests/test_function.py | 5 +- heat/tests/test_hot.py | 14 ++- heat/tests/test_instance.py | 4 +- heat/tests/test_instance_network.py | 8 +- heat/tests/test_metadata_refresh.py | 8 +- heat/tests/test_provider_template.py | 48 ++++---- heat/tests/test_resource.py | 11 +- heat/tests/test_server.py | 5 +- heat/tests/test_server_tags.py | 5 +- heat/tests/test_sqlalchemy_api.py | 4 +- heat/tests/test_stack.py | 24 ++-- heat/tests/test_stack_update.py | 35 +++--- heat/tests/test_swiftsignal.py | 2 - heat/tests/test_template.py | 17 ++- heat/tests/test_validate.py | 107 +++++++++--------- heat/tests/utils.py | 2 +- 25 files changed, 194 insertions(+), 179 deletions(-) diff --git a/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py b/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py index 5e98157851..9d158f486b 100644 --- a/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py +++ b/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py @@ -90,9 +90,10 @@ class CloudServersTest(common.HeatTestCase): def _setup_test_stack(self, stack_name): t = template_format.parse(wp_template) - templ = template.Template(t) + templ = template.Template( + t, env=environment.Environment({'key_name': 'test'})) + stack = parser.Stack(self.ctx, stack_name, templ, - environment.Environment({'key_name': 'test'}), stack_id=uuidutils.generate_uuid()) return (templ, stack) diff --git a/contrib/rackspace/rackspace/tests/test_rackspace_dns.py b/contrib/rackspace/rackspace/tests/test_rackspace_dns.py index fe550ef0de..f6b9e44595 100644 --- a/contrib/rackspace/rackspace/tests/test_rackspace_dns.py +++ b/contrib/rackspace/rackspace/tests/test_rackspace_dns.py @@ -101,11 +101,11 @@ class RackspaceDnsTest(common.HeatTestCase): def _setup_test_cloud_dns_instance(self, name, parsed_t): stack_name = '%s_stack' % name t = parsed_t - templ = template.Template(t) + templ = template.Template( + t, env=environment.Environment({'name': 'test'})) stack = parser.Stack(utils.dummy_context(), stack_name, templ, - environment.Environment({'name': 'test'}), stack_id=str(uuid.uuid4())) instance = cloud_dns.CloudDns( diff --git a/heat/engine/resources/openstack/heat/instance_group.py b/heat/engine/resources/openstack/heat/instance_group.py index 913b583cf1..d5e22fc299 100644 --- a/heat/engine/resources/openstack/heat/instance_group.py +++ b/heat/engine/resources/openstack/heat/instance_group.py @@ -16,6 +16,7 @@ from heat.common import grouputils from heat.common.i18n import _ from heat.common import timeutils as iso8601utils from heat.engine import attributes +from heat.engine import environment from heat.engine import function from heat.engine import properties from heat.engine.resources import stack_resource @@ -264,7 +265,12 @@ class InstanceGroup(stack_resource.StackResource): definitions = template.resource_templates( old_resources, instance_definition, num_instances, num_replace) - return template.make_template(definitions, version=template_version) + child_env = environment.get_child_environment( + self.stack.env, + self.child_params(), item_to_remove=self.resource_info) + + return template.make_template(definitions, version=template_version, + child_env=child_env) def _try_rolling_update(self, prop_diff): if (self.update_policy[self.ROLLING_UPDATE] and diff --git a/heat/engine/stack.py b/heat/engine/stack.py index 44b022f479..dbb02b6ff4 100755 --- a/heat/engine/stack.py +++ b/heat/engine/stack.py @@ -73,7 +73,7 @@ class Stack(collections.Mapping): _zones = None - def __init__(self, context, stack_name, tmpl, env=None, + def __init__(self, context, stack_name, tmpl, stack_id=None, action=None, status=None, status_reason='', timeout_mins=None, resolve_data=True, disable_rollback=True, parent_resource=None, owner_id=None, @@ -138,7 +138,6 @@ class Stack(collections.Mapping): resources.initialise() - self.env = env or self.t.env self.parameters = self.t.parameters( self.identifier(), user_params=self.env.params, @@ -150,6 +149,11 @@ class Stack(collections.Mapping): else: self.outputs = {} + @property + def env(self): + """This is a helper to allow resources to access stack.env.""" + return self.t.env + @property def parent_resource(self): """Dynamically load up the parent_resource. @@ -327,10 +331,15 @@ class Stack(collections.Mapping): use_stored_context=False): template = tmpl.Template.load( context, stack.raw_template_id, stack.raw_template) - return cls(context, stack.name, template, template.env, - stack.id, stack.action, stack.status, stack.status_reason, - stack.timeout, resolve_data, stack.disable_rollback, - parent_resource, owner_id=stack.owner_id, + return cls(context, stack.name, template, + stack_id=stack.id, + action=stack.action, status=stack.status, + status_reason=stack.status_reason, + timeout_mins=stack.timeout, + resolve_data=resolve_data, + disable_rollback=stack.disable_rollback, + parent_resource=parent_resource, + owner_id=stack.owner_id, stack_user_project_id=stack.stack_user_project_id, created_time=stack.created_at, updated_time=stack.updated_at, @@ -729,7 +738,7 @@ class Stack(collections.Mapping): return self.load(self.context, stack=s) elif create_if_missing: prev = type(self)(self.context, self.name, copy.deepcopy(self.t), - self.env, owner_id=self.id, + owner_id=self.id, user_creds_id=self.user_creds_id, convergence=self.convergence) prev.store(backup=True) @@ -806,7 +815,7 @@ class Stack(collections.Mapping): # Oldstack is useless when the action is not UPDATE , so we don't # need to build it, this can avoid some unexpected errors. oldstack = Stack(self.context, self.name, copy.deepcopy(self.t), - self.env, convergence=self.convergence) + convergence=self.convergence) backup_stack = self._backup_stack() try: update_task = update.StackUpdate( @@ -815,7 +824,6 @@ class Stack(collections.Mapping): error_wait_time=cfg.CONF.error_wait_time) updater = scheduler.TaskRunner(update_task) - self.env = newstack.env self.parameters = newstack.parameters self.t.files = newstack.t.files self.t.env = newstack.t.env @@ -1152,7 +1160,7 @@ class Stack(collections.Mapping): return self.updated_time = datetime.datetime.utcnow() - template = tmpl.Template(snapshot.data['template']) + template = tmpl.Template(snapshot.data['template'], env=self.env) for name, defn in six.iteritems(template.resource_definitions(self)): rsrc = resource.Resource(name, defn, self) @@ -1162,7 +1170,7 @@ class Stack(collections.Mapping): defn = handle_restore(defn, data) template.add_resource(defn, name) - newstack = self.__class__(self.context, self.name, template, self.env, + newstack = self.__class__(self.context, self.name, template, timeout_mins=self.timeout_mins, disable_rollback=self.disable_rollback) newstack.parameters.set_stack_id(self.identifier()) diff --git a/heat/engine/template.py b/heat/engine/template.py index 2f3177a50c..0fbe29f733 100644 --- a/heat/engine/template.py +++ b/heat/engine/template.py @@ -119,7 +119,8 @@ class Template(collections.Mapping): self.version = get_version(self.t, _template_classes.keys()) def __deepcopy__(self, memo): - return Template(copy.deepcopy(self.t, memo), files=self.files) + return Template(copy.deepcopy(self.t, memo), files=self.files, + env=self.env) @classmethod def load(cls, context, template_id, t=None): diff --git a/heat/scaling/template.py b/heat/scaling/template.py index c20c2d871e..c1f446a161 100644 --- a/heat/scaling/template.py +++ b/heat/scaling/template.py @@ -40,7 +40,8 @@ def resource_templates(old_resources, resource_definition, def make_template(resource_definitions, - version=('heat_template_version', '2013-05-23')): + version=('heat_template_version', '2013-05-23'), + child_env=None): """ Return a Template object containing the given resource definitions. @@ -48,7 +49,7 @@ def make_template(resource_definitions, can be specified by passing a (version_type, version_string) tuple matching any of the available template format plugins. """ - tmpl = template.Template(dict([version])) + tmpl = template.Template(dict([version]), env=child_env) for name, defn in resource_definitions: tmpl.add_resource(defn, name) diff --git a/heat/tests/aws/test_waitcondition.py b/heat/tests/aws/test_waitcondition.py index f1a00bb3e2..f5de1ea2e7 100644 --- a/heat/tests/aws/test_waitcondition.py +++ b/heat/tests/aws/test_waitcondition.py @@ -87,10 +87,10 @@ class WaitConditionTest(common.HeatTestCase): stub=True, stub_status=True): params = params or {} temp = template_format.parse(template) - template = parser.Template(temp) + template = parser.Template(temp, + env=environment.Environment(params)) ctx = utils.dummy_context(tenant_id='test_tenant') stack = parser.Stack(ctx, 'test_stack', template, - environment.Environment(params), disable_rollback=True) # Stub out the stack ID so we have a known value @@ -533,7 +533,6 @@ class WaitConditionUpdateTest(common.HeatTestCase): template = parser.Template(temp) ctx = utils.dummy_context(tenant_id='test_tenant') stack = parser.Stack(ctx, 'test_stack', template, - environment.Environment({}), disable_rollback=True) stack_id = str(uuid.uuid4()) diff --git a/heat/tests/openstack/test_waitcondition.py b/heat/tests/openstack/test_waitcondition.py index 18c501085a..5698711b93 100644 --- a/heat/tests/openstack/test_waitcondition.py +++ b/heat/tests/openstack/test_waitcondition.py @@ -80,10 +80,10 @@ class HeatWaitConditionTest(common.HeatTestCase): params={}, stub=True, stub_status=True): temp = template_format.parse(template) - template = parser.Template(temp) + template = parser.Template(temp, + env=environment.Environment(params)) ctx = utils.dummy_context(tenant_id=self.tenant_id) stack = parser.Stack(ctx, 'test_stack', template, - environment.Environment(params), disable_rollback=True) # Stub out the stack ID so we have a known value diff --git a/heat/tests/test_engine_service.py b/heat/tests/test_engine_service.py index 71993afea3..34b3638459 100644 --- a/heat/tests/test_engine_service.py +++ b/heat/tests/test_engine_service.py @@ -733,8 +733,7 @@ class StackServiceCreateUpdateDeleteTest(common.HeatTestCase): 'C': {'Type': 'GenericResourceType'}}} template = templatem.Template(tpl) - stack = parser.Stack(self.ctx, stack_name, template, - environment.Environment({})) + stack = parser.Stack(self.ctx, stack_name, template) self.m.StubOutWithMock(templatem, 'Template') self.m.StubOutWithMock(environment, 'Environment') @@ -1058,10 +1057,10 @@ class StackServiceCreateUpdateDeleteTest(common.HeatTestCase): s = stack_object.Stack.get_by_id(self.ctx, sid) t = template_format.parse(wp_template_no_default) - template = templatem.Template(t) env = environment.Environment({'parameters': with_params, 'resource_registry': {'rsc': 'test'}}) - stack = parser.Stack(self.ctx, stack_name, template, env) + template = templatem.Template(t, env=env) + stack = parser.Stack(self.ctx, stack_name, template) self._stub_update_mocks(s, old_stack) @@ -3002,8 +3001,7 @@ class StackServiceTest(common.HeatTestCase): } } templ = templatem.Template(lazy_load_template) - stack = parser.Stack(self.ctx, stack_name, templ, - environment.Environment({})) + stack = parser.Stack(self.ctx, stack_name, templ) self.assertIsNone(stack._resources) self.assertIsNone(stack._dependencies) diff --git a/heat/tests/test_function.py b/heat/tests/test_function.py index 3f3fa382c9..342a4d2aed 100644 --- a/heat/tests/test_function.py +++ b/heat/tests/test_function.py @@ -177,8 +177,9 @@ class ValidateGetAttTest(common.HeatTestCase): self.stack = parser.Stack( utils.dummy_context(), 'test_stack', - parser.Template({"HeatTemplateFormatVersion": "2012-12-12"}), - env=env, stack_id=str(uuid.uuid4())) + parser.Template({"HeatTemplateFormatVersion": "2012-12-12"}, + env=env), + stack_id=str(uuid.uuid4())) res_defn = rsrc_defn.ResourceDefinition('test_rsrc', 'OS::Test::GenericResource') self.rsrc = resource.Resource('test_rsrc', res_defn, self.stack) diff --git a/heat/tests/test_hot.py b/heat/tests/test_hot.py index c820c00f1a..071934f963 100644 --- a/heat/tests/test_hot.py +++ b/heat/tests/test_hot.py @@ -1053,16 +1053,18 @@ class HotStackTest(common.HeatTestCase): 'update_template_diff') self.stack = parser.Stack(self.ctx, 'update_test_stack', - template.Template(tmpl), - environment.Environment({'foo': 'abc'})) + template.Template( + tmpl, env=environment.Environment( + {'foo': 'abc'}))) self.stack.store() self.stack.create() self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE), self.stack.state) updated_stack = parser.Stack(self.ctx, 'updated_stack', - template.Template(tmpl), - environment.Environment({'foo': 'xyz'})) + template.Template( + tmpl, env=environment.Environment( + {'foo': 'xyz'}))) def check_props(*args): self.assertEqual('abc', self.stack['AResource'].properties['Foo']) @@ -1307,9 +1309,9 @@ class StackParametersTest(common.HeatTestCase): def test_param_refs(self): """Test if parameter references work.""" - tmpl = parser.Template(self.props_template) env = environment.Environment(self.params) - stack = parser.Stack(utils.dummy_context(), 'test', tmpl, env, + tmpl = parser.Template(self.props_template, env=env) + stack = parser.Stack(utils.dummy_context(), 'test', tmpl, stack_id='1ba8c334-2297-4312-8c7c-43763a988ced', tenant_id='9913ef0a-b8be-4b33-b574-9061441bd373') self.assertEqual(self.expected, diff --git a/heat/tests/test_instance.py b/heat/tests/test_instance.py index 819337b851..70dffafb57 100644 --- a/heat/tests/test_instance.py +++ b/heat/tests/test_instance.py @@ -79,9 +79,9 @@ class InstancesTest(common.HeatTestCase): def _setup_test_stack(self, stack_name): t = template_format.parse(wp_template) - template = parser.Template(t) + template = parser.Template( + t, env=environment.Environment({'KeyName': 'test'})) stack = parser.Stack(utils.dummy_context(), stack_name, template, - environment.Environment({'KeyName': 'test'}), stack_id=str(uuid.uuid4())) return (template, stack) diff --git a/heat/tests/test_instance_network.py b/heat/tests/test_instance_network.py index 307a34ee4e..50820b0334 100644 --- a/heat/tests/test_instance_network.py +++ b/heat/tests/test_instance_network.py @@ -198,12 +198,12 @@ class instancesTest(common.HeatTestCase): def _create_test_instance(self, return_server, name): stack_name = '%s_s' % name t = template_format.parse(wp_template) - template = parser.Template(t) kwargs = {'KeyName': 'test', 'InstanceType': 'm1.large', 'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861'} + template = parser.Template(t, + env=environment.Environment(kwargs)) stack = parser.Stack(utils.dummy_context(), stack_name, template, - environment.Environment(kwargs), stack_id=str(uuid.uuid4())) image_id = 'CentOS 5.2' t['Resources']['WebServer']['Properties']['ImageId'] = image_id @@ -253,12 +253,12 @@ class instancesTest(common.HeatTestCase): def _create_test_instance_with_nic(self, return_server, name): stack_name = '%s_s' % name t = template_format.parse(wp_template_with_nic) - template = parser.Template(t) kwargs = {'KeyName': 'test', 'InstanceType': 'm1.large', 'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861'} + template = parser.Template(t, + env=environment.Environment(kwargs)) stack = parser.Stack(utils.dummy_context(), stack_name, template, - environment.Environment(kwargs), stack_id=str(uuid.uuid4())) image_id = 'CentOS 5.2' t['Resources']['WebServer']['Properties']['ImageId'] = image_id diff --git a/heat/tests/test_metadata_refresh.py b/heat/tests/test_metadata_refresh.py index 3a2ef03078..c279455790 100644 --- a/heat/tests/test_metadata_refresh.py +++ b/heat/tests/test_metadata_refresh.py @@ -154,10 +154,10 @@ class MetadataRefreshTest(common.HeatTestCase): def create_stack(self, stack_name='test_stack', params=None): params = params or {} temp = template_format.parse(test_template_metadata) - template = parser.Template(temp) + template = parser.Template(temp, + env=environment.Environment(params)) ctx = utils.dummy_context() stack = parser.Stack(ctx, stack_name, template, - environment.Environment(params), disable_rollback=True) self.stack_id = stack.store() @@ -314,10 +314,10 @@ class MetadataRefreshTestServer(common.HeatTestCase): def create_stack(self, stack_name='test_stack_native', params=None): params = params or {} temp = template_format.parse(test_template_server) - template = parser.Template(temp) + template = parser.Template(temp, + env=environment.Environment(params)) ctx = utils.dummy_context() stack = parser.Stack(ctx, stack_name, template, - environment.Environment(params), disable_rollback=True) self.stack_id = stack.store() diff --git a/heat/tests/test_provider_template.py b/heat/tests/test_provider_template.py index a1cf972477..cb3af79970 100644 --- a/heat/tests/test_provider_template.py +++ b/heat/tests/test_provider_template.py @@ -127,8 +127,8 @@ class ProviderTemplateTest(common.HeatTestCase): env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', - parser.Template(empty_template, files=files), - env=env, + parser.Template(empty_template, files=files, + env=env), stack_id=str(uuid.uuid4())) map_prop_val = { @@ -208,8 +208,8 @@ class ProviderTemplateTest(common.HeatTestCase): env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', - parser.Template(empty_template, files=files), - env=env, + parser.Template(empty_template, files=files, + env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', @@ -237,8 +237,8 @@ class ProviderTemplateTest(common.HeatTestCase): env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', - parser.Template(empty_template, files=files), - env=env, + parser.Template(empty_template, files=files, + env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', @@ -270,8 +270,8 @@ class ProviderTemplateTest(common.HeatTestCase): env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', - parser.Template(empty_template, files=files), - env=env, + parser.Template(empty_template, files=files, + env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', @@ -302,8 +302,8 @@ class ProviderTemplateTest(common.HeatTestCase): env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', - parser.Template(empty_template, files=files), - env=env, + parser.Template(empty_template, files=files, + env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', @@ -332,8 +332,8 @@ class ProviderTemplateTest(common.HeatTestCase): env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', - parser.Template(empty_template, files=files), - env=env, + parser.Template(empty_template, files=files, + env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', @@ -366,7 +366,7 @@ class ProviderTemplateTest(common.HeatTestCase): stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, - files=files), env=env, + files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', @@ -402,7 +402,7 @@ class ProviderTemplateTest(common.HeatTestCase): stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, - files=files), env=env, + files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', @@ -434,7 +434,7 @@ class ProviderTemplateTest(common.HeatTestCase): stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, - files=files), env=env, + files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', @@ -468,7 +468,7 @@ class ProviderTemplateTest(common.HeatTestCase): stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, - files=files), env=env, + files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', @@ -503,7 +503,7 @@ class ProviderTemplateTest(common.HeatTestCase): stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, - files=files), env=env, + files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('foo', @@ -547,7 +547,7 @@ class ProviderTemplateTest(common.HeatTestCase): stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, - files=files), env=env, + files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', @@ -686,7 +686,7 @@ class ProviderTemplateTest(common.HeatTestCase): env.load({'resource_registry': {'Test::Flippy': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', - parser.Template(empty_template), env=env, + parser.Template(empty_template, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', @@ -738,7 +738,7 @@ class ProviderTemplateTest(common.HeatTestCase): env.load({'resource_registry': {'Test::Flippy': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', - parser.Template(empty_template), env=env, + parser.Template(empty_template, env=env), stack_id=str(uuid.uuid4())) self.m.StubOutWithMock(urlfetch, "get") @@ -767,7 +767,7 @@ class ProviderTemplateTest(common.HeatTestCase): env.load({'resource_registry': {'Test::Flippy': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', - parser.Template(empty_template), env=env, + parser.Template(empty_template, env=env), stack_id=str(uuid.uuid4())) self.m.ReplayAll() @@ -790,7 +790,7 @@ class ProviderTemplateTest(common.HeatTestCase): env.load({'resource_registry': {'Test::Tmpl': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', - parser.Template(empty_template), env=env, + parser.Template(empty_template, env=env), stack_id=str(uuid.uuid4())) self.m.StubOutWithMock(urlfetch, "get") @@ -836,8 +836,8 @@ class TemplateResourceCrudTest(common.HeatTestCase): env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', - parser.Template(empty_template, files=files), - env=env, + parser.Template(empty_template, files=files, + env=env), stack_id=str(uuid.uuid4())) self.defn = rsrc_defn.ResourceDefinition('test_t_res', diff --git a/heat/tests/test_resource.py b/heat/tests/test_resource.py index c08f1df3f4..4d11ccfb3d 100644 --- a/heat/tests/test_resource.py +++ b/heat/tests/test_resource.py @@ -62,8 +62,9 @@ class ResourceTest(common.HeatTestCase): u'ResourceWithCustomConstraint'}}) self.stack = parser.Stack(utils.dummy_context(), 'test_stack', - parser.Template(empty_template), - env=self.env, stack_id=str(uuid.uuid4())) + parser.Template(empty_template, + env=self.env), + stack_id=str(uuid.uuid4())) self.patch('heat.engine.resource.warnings') def test_get_class_ok(self): @@ -1083,7 +1084,7 @@ class ResourceTest(common.HeatTestCase): self.assertFalse(res.is_using_neutron()) def _test_skip_validation_if_custom_constraint(self, tmpl): - stack = parser.Stack(utils.dummy_context(), 'test', tmpl, env=self.env) + stack = parser.Stack(utils.dummy_context(), 'test', tmpl) stack.store() path = ('heat.engine.clients.os.neutron.NetworkConstraint.' 'validate_with_client') @@ -1104,7 +1105,7 @@ class ResourceTest(common.HeatTestCase): } } } - }) + }, env=self.env) self._test_skip_validation_if_custom_constraint(tmpl) def test_hot_ref_skip_validation_if_custom_constraint(self): @@ -1119,7 +1120,7 @@ class ResourceTest(common.HeatTestCase): } } } - }) + }, env=self.env) self._test_skip_validation_if_custom_constraint(tmpl) diff --git a/heat/tests/test_server.py b/heat/tests/test_server.py index 55f2d844a6..ee3abaf4b8 100644 --- a/heat/tests/test_server.py +++ b/heat/tests/test_server.py @@ -119,9 +119,10 @@ class ServersTest(common.HeatTestCase): def _setup_test_stack(self, stack_name, test_templ=wp_template): t = template_format.parse(test_templ) - templ = template.Template(t) + templ = template.Template(t, + env=environment.Environment( + {'key_name': 'test'})) stack = parser.Stack(utils.dummy_context(), stack_name, templ, - environment.Environment({'key_name': 'test'}), stack_id=uuidutils.generate_uuid(), stack_user_project_id='8888') return (templ, stack) diff --git a/heat/tests/test_server_tags.py b/heat/tests/test_server_tags.py index e1ab392a89..b9bb10ee4c 100644 --- a/heat/tests/test_server_tags.py +++ b/heat/tests/test_server_tags.py @@ -65,9 +65,10 @@ class ServerTagsTest(common.HeatTestCase): def _setup_test_instance(self, intags=None, nova_tags=None): stack_name = 'tag_test' t = template_format.parse(instance_template) - template = parser.Template(t) + template = parser.Template(t, + env=environment.Environment( + {'KeyName': 'test'})) stack = parser.Stack(utils.dummy_context(), stack_name, template, - environment.Environment({'KeyName': 'test'}), stack_id=str(uuid.uuid4())) t['Resources']['WebServer']['Properties']['Tags'] = intags diff --git a/heat/tests/test_sqlalchemy_api.py b/heat/tests/test_sqlalchemy_api.py index ecfcc723e6..5680160e9d 100644 --- a/heat/tests/test_sqlalchemy_api.py +++ b/heat/tests/test_sqlalchemy_api.py @@ -100,10 +100,10 @@ class SqlAlchemyTest(common.HeatTestCase): def _setup_test_stack(self, stack_name, stack_id=None, owner_id=None, stack_user_project_id=None, backup=False): t = template_format.parse(wp_template) - template = parser.Template(t) + template = parser.Template( + t, env=environment.Environment({'KeyName': 'test'})) stack_id = stack_id or str(uuid.uuid4()) stack = parser.Stack(self.ctx, stack_name, template, - environment.Environment({'KeyName': 'test'}), owner_id=owner_id, stack_user_project_id=stack_user_project_id) with utils.UUIDStub(stack_id): diff --git a/heat/tests/test_stack.py b/heat/tests/test_stack.py index b1ae699954..34f21ad72e 100644 --- a/heat/tests/test_stack.py +++ b/heat/tests/test_stack.py @@ -276,10 +276,12 @@ class StackTest(common.HeatTestCase): ).AndReturn(t) self.m.StubOutWithMock(stack.Stack, '__init__') - stack.Stack.__init__(self.ctx, stk.name, t, t.env, stk.id, - stk.action, stk.status, stk.status_reason, - stk.timeout, True, stk.disable_rollback, - 'parent', owner_id=None, + stack.Stack.__init__(self.ctx, stk.name, t, stack_id=stk.id, + action=stk.action, status=stk.status, + status_reason=stk.status_reason, + timeout_mins=stk.timeout, resolve_data=True, + disable_rollback=stk.disable_rollback, + parent_resource='parent', owner_id=None, stack_user_project_id=None, created_time=mox.IgnoreArg(), updated_time=None, @@ -319,10 +321,9 @@ class StackTest(common.HeatTestCase): "metadata": {}}}''' env = environment.Environment({'parameters': {'param1': 'test'}}) self.stack = stack.Stack(self.ctx, 'stack_details_test', - template.Template(tpl), + template.Template(tpl, env=env), tenant_id='123', - stack_user_project_id='234', - env=env) + stack_user_project_id='234') self.stack.store() info = self.stack.prepare_abandon() self.assertEqual('CREATE', info['action']) @@ -1459,9 +1460,9 @@ class StackTest(common.HeatTestCase): self.m.ReplayAll() + test_env = environment.Environment({'flavor': 'dummy'}) self.stack = stack.Stack(self.ctx, 'stack_with_custom_constraint', - template.Template(tmpl), - environment.Environment({'flavor': 'dummy'})) + template.Template(tmpl, env=test_env)) self.stack.validate() self.stack.store() @@ -1627,10 +1628,9 @@ class StackTest(common.HeatTestCase): Type: Number """) - env1 = {'parameters': {'foo': 'abc'}} + env1 = environment.Environment({'parameters': {'foo': 'abc'}}) self.stack = stack.Stack(self.ctx, 'stack_with_bad_param', - template.Template(tmpl), - env=environment.Environment(env1)) + template.Template(tmpl, env=env1)) ex = self.assertRaises(exception.StackValidationFailed, self.stack.validate) diff --git a/heat/tests/test_stack_update.py b/heat/tests/test_stack_update.py index 938acbb425..4867979d8c 100644 --- a/heat/tests/test_stack_update.py +++ b/heat/tests/test_stack_update.py @@ -261,17 +261,18 @@ class StackUpdateTest(common.HeatTestCase): } } - self.stack = stack.Stack(self.ctx, 'update_test_stack', - template.Template(tmpl), - environment.Environment({'foo': 'abc'})) + self.stack = stack.Stack( + self.ctx, 'update_test_stack', + template.Template( + tmpl, env=environment.Environment({'foo': 'abc'}))) self.stack.store() self.stack.create() self.assertEqual((stack.Stack.CREATE, stack.Stack.COMPLETE), self.stack.state) + env2 = environment.Environment({'foo': 'xyz'}) updated_stack = stack.Stack(self.ctx, 'updated_stack', - template.Template(tmpl), - environment.Environment({'foo': 'xyz'})) + template.Template(tmpl, env=env2)) def check_and_raise(*args): self.assertEqual('abc', self.stack['AResource'].properties['Foo']) @@ -800,11 +801,10 @@ class StackUpdateTest(common.HeatTestCase): 'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'abc'}}}} - env1 = {'parameters': {'AParam': 'abc'}} + env1 = environment.Environment({'parameters': {'AParam': 'abc'}}) self.stack = stack.Stack(self.ctx, 'update_test_stack', - template.Template(tmpl), - disable_rollback=False, - env=environment.Environment(env1)) + template.Template(tmpl, env=env1), + disable_rollback=False) self.stack.store() self.stack.create() self.assertEqual((stack.Stack.CREATE, stack.Stack.COMPLETE), @@ -815,11 +815,10 @@ class StackUpdateTest(common.HeatTestCase): 'Resources': {'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': 'xyz'}}}} - env2 = {'parameters': {'BParam': 'smelly'}} + env2 = environment.Environment({'parameters': {'BParam': 'smelly'}}) updated_stack = stack.Stack(self.ctx, 'updated_stack', - template.Template(tmpl2), - disable_rollback=False, - env=environment.Environment(env2)) + template.Template(tmpl2, env=env2), + disable_rollback=False) # patch in a dummy handle_create making the replace fail when creating # the replacement rsrc, and again on the second call (rollback) @@ -1344,11 +1343,10 @@ class StackUpdateTest(common.HeatTestCase): 'AResource': {'Type': 'ResourceWithPropsType', 'Properties': {'Foo': {'Ref': 'AParam'}}}}} - env1 = {'parameters': {'AParam': 'abc'}} - env2 = {'parameters': {'AParam': 'smelly'}} + env1 = environment.Environment({'parameters': {'AParam': 'abc'}}) + env2 = environment.Environment({'parameters': {'AParam': 'smelly'}}) self.stack = stack.Stack(self.ctx, 'update_test_stack', - template.Template(tmpl), - environment.Environment(env1)) + template.Template(tmpl, env=env1)) self.stack.store() self.stack.create() @@ -1357,8 +1355,7 @@ class StackUpdateTest(common.HeatTestCase): self.assertEqual('abc', self.stack['AResource'].properties['Foo']) updated_stack = stack.Stack(self.ctx, 'updated_stack', - template.Template(tmpl), - environment.Environment(env2)) + template.Template(tmpl, env=env2)) self.stack.update(updated_stack) self.assertEqual((stack.Stack.UPDATE, stack.Stack.COMPLETE), self.stack.state) diff --git a/heat/tests/test_swiftsignal.py b/heat/tests/test_swiftsignal.py index e12e25b292..48461ac397 100644 --- a/heat/tests/test_swiftsignal.py +++ b/heat/tests/test_swiftsignal.py @@ -26,7 +26,6 @@ from testtools import matchers from heat.common import exception from heat.common import template_format from heat.engine.clients.os import swift -from heat.engine import environment from heat.engine import resource from heat.engine import rsrc_defn from heat.engine import scheduler @@ -88,7 +87,6 @@ def create_stack(template, stack_id=None): template = templatem.Template(tmpl) ctx = utils.dummy_context(tenant_id='test_tenant') st = stack.Stack(ctx, 'test_st', template, - environment.Environment(), disable_rollback=True) # Stub out the stack ID so we have a known value diff --git a/heat/tests/test_template.py b/heat/tests/test_template.py index e46d8b4143..5a54fdb57b 100644 --- a/heat/tests/test_template.py +++ b/heat/tests/test_template.py @@ -559,17 +559,17 @@ Mappings: self.assertRaises(KeyError, self.resolve, find, tmpl, stk) def test_param_refs(self): - tmpl = template.Template(parameter_template) env = environment.Environment({'foo': 'bar', 'blarg': 'wibble'}) - stk = stack.Stack(self.ctx, 'test', tmpl, env) + tmpl = template.Template(parameter_template, env=env) + stk = stack.Stack(self.ctx, 'test', tmpl) p_snippet = {"Ref": "foo"} self.assertEqual("bar", self.resolve(p_snippet, tmpl, stk)) def test_param_ref_missing(self): - tmpl = template.Template(parameter_template) env = environment.Environment({'foo': 'bar'}) - stk = stack.Stack(self.ctx, 'test', tmpl, env) - stk.env = environment.Environment({}) + tmpl = template.Template(parameter_template, env=env) + stk = stack.Stack(self.ctx, 'test', tmpl) + tmpl.env = environment.Environment({}) stk.parameters = parameters.Parameters(stk.identifier(), tmpl) snippet = {"Ref": "foo"} self.assertRaises(exception.UserParameterMissing, @@ -728,9 +728,9 @@ Mappings: self.assertEqual('"foo" is "${var3}"', self.resolve(snippet, tmpl)) def test_replace_param_values(self): - tmpl = template.Template(parameter_template) env = environment.Environment({'foo': 'wibble'}) - stk = stack.Stack(self.ctx, 'test_stack', tmpl, env) + tmpl = template.Template(parameter_template, env=env) + stk = stack.Stack(self.ctx, 'test_stack', tmpl) snippet = {"Fn::Replace": [ {'$var1': {'Ref': 'foo'}, '%var2%': {'Ref': 'blarg'}}, '$var1 is %var2%' @@ -1007,8 +1007,7 @@ class ResolveDataTest(common.HeatTestCase): self.ctx = utils.dummy_context() self.stack = stack.Stack(self.ctx, 'resolve_test_stack', - template.Template(empty_template), - environment.Environment({})) + template.Template(empty_template)) def resolve(self, snippet): return function.resolve(self.stack.t.parse(self.stack, snippet)) diff --git a/heat/tests/test_validate.py b/heat/tests/test_validate.py index 3599e5a7ac..f675b3c887 100644 --- a/heat/tests/test_validate.py +++ b/heat/tests/test_validate.py @@ -1245,10 +1245,9 @@ class validateTest(common.HeatTestCase): def test_unregistered_key(self): t = template_format.parse(test_unregistered_key) - template = parser.Template(t) params = {'KeyName': 'not_registered'} - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment(params)) + template = parser.Template(t, env=environment.Environment(params)) + stack = parser.Stack(self.ctx, 'test_stack', template) self._mock_get_image_id_success('image_name', 'image_id') self.m.ReplayAll() @@ -1259,10 +1258,11 @@ class validateTest(common.HeatTestCase): def test_unregistered_image(self): t = template_format.parse(test_template_image) - template = parser.Template(t) + template = parser.Template(t, + env=environment.Environment( + {'KeyName': 'test'})) - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment({'KeyName': 'test'})) + stack = parser.Stack(self.ctx, 'test_stack', template) self._mock_get_image_id_fail('image_name', exception.ImageNotFound( @@ -1276,10 +1276,11 @@ class validateTest(common.HeatTestCase): def test_duplicated_image(self): t = template_format.parse(test_template_image) - template = parser.Template(t) + template = parser.Template(t, + env=environment.Environment( + {'KeyName': 'test'})) - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment({'KeyName': 'test'})) + stack = parser.Stack(self.ctx, 'test_stack', template) self._mock_get_image_id_fail('image_name', exception.PhysicalResourceNameAmbiguity( @@ -1295,9 +1296,10 @@ class validateTest(common.HeatTestCase): def test_invalid_security_groups_with_nics(self): t = template_format.parse(test_template_invalid_secgroups) - template = parser.Template(t) - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment({'KeyName': 'test'})) + template = parser.Template(t, + env=environment.Environment( + {'KeyName': 'test'})) + stack = parser.Stack(self.ctx, 'test_stack', template) self._mock_get_image_id_success('image_name', 'image_id') @@ -1312,9 +1314,9 @@ class validateTest(common.HeatTestCase): def test_invalid_security_group_ids_with_nics(self): t = template_format.parse(test_template_invalid_secgroupids) - template = parser.Template(t) - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment({'KeyName': 'test'})) + template = parser.Template( + t, env=environment.Environment({'KeyName': 'test'})) + stack = parser.Stack(self.ctx, 'test_stack', template) self._mock_get_image_id_success('image_name', 'image_id') @@ -1344,22 +1346,22 @@ class validateTest(common.HeatTestCase): def test_validate_unique_logical_name(self): t = template_format.parse(test_template_unique_logical_name) - template = parser.Template(t) - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment({'AName': 'test', - 'KeyName': 'test'})) + template = parser.Template( + t, env=environment.Environment( + {'AName': 'test', 'KeyName': 'test'})) + stack = parser.Stack(self.ctx, 'test_stack', template) self.assertRaises(exception.StackValidationFailed, stack.validate) def test_validate_duplicate_parameters_in_group(self): t = template_format.parse(test_template_duplicate_parameters) - template = tmpl.HOTemplate20130523(t) - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment({ - 'KeyName': 'test', - 'ImageId': 'sometestid', - 'db_password': 'Pass123' - })) + template = tmpl.HOTemplate20130523( + t, env=environment.Environment({ + 'KeyName': 'test', + 'ImageId': 'sometestid', + 'db_password': 'Pass123' + })) + stack = parser.Stack(self.ctx, 'test_stack', template) exc = self.assertRaises(exception.StackValidationFailed, stack.validate) @@ -1368,12 +1370,12 @@ class validateTest(common.HeatTestCase): def test_validate_invalid_parameter_in_group(self): t = template_format.parse(test_template_invalid_parameter_name) - template = tmpl.HOTemplate20130523(t) - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment({ - 'KeyName': 'test', - 'ImageId': 'sometestid', - 'db_password': 'Pass123'})) + template = tmpl.HOTemplate20130523(t, + env=environment.Environment({ + 'KeyName': 'test', + 'ImageId': 'sometestid', + 'db_password': 'Pass123'})) + stack = parser.Stack(self.ctx, 'test_stack', template) exc = self.assertRaises(exception.StackValidationFailed, stack.validate) @@ -1394,47 +1396,46 @@ class validateTest(common.HeatTestCase): def test_validate_allowed_values_integer(self): t = template_format.parse(test_template_allowed_integers) - template = parser.Template(t) + template = parser.Template(t, + env=environment.Environment({'size': '4'})) # test with size parameter provided as string - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment({'size': '4'})) + stack = parser.Stack(self.ctx, 'test_stack', template) self.assertIsNone(stack.validate()) # test with size parameter provided as number - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment({'size': 4})) + template.env = environment.Environment({'size': 4}) + stack = parser.Stack(self.ctx, 'test_stack', template) self.assertIsNone(stack.validate()) def test_validate_allowed_values_integer_str(self): t = template_format.parse(test_template_allowed_integers_str) - template = parser.Template(t) + template = parser.Template(t, + env=environment.Environment({'size': '4'})) # test with size parameter provided as string - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment({'size': '4'})) + stack = parser.Stack(self.ctx, 'test_stack', template) self.assertIsNone(stack.validate()) - # test with size parameter provided as number - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment({'size': 4})) + template.env = environment.Environment({'size': 4}) + stack = parser.Stack(self.ctx, 'test_stack', template) self.assertIsNone(stack.validate()) def test_validate_not_allowed_values_integer(self): t = template_format.parse(test_template_allowed_integers) - template = parser.Template(t) + template = parser.Template(t, + env=environment.Environment({'size': '3'})) # test with size parameter provided as string - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment({'size': '3'})) + stack = parser.Stack(self.ctx, 'test_stack', template) err = self.assertRaises(exception.StackValidationFailed, stack.validate) self.assertIn('"3" is not an allowed value [1, 4, 8]', six.text_type(err)) # test with size parameter provided as number - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment({'size': 3})) + template.env = environment.Environment({'size': 3}) + stack = parser.Stack(self.ctx, 'test_stack', template) err = self.assertRaises(exception.StackValidationFailed, stack.validate) self.assertIn('"3" is not an allowed value [1, 4, 8]', @@ -1442,19 +1443,19 @@ class validateTest(common.HeatTestCase): def test_validate_not_allowed_values_integer_str(self): t = template_format.parse(test_template_allowed_integers_str) - template = parser.Template(t) + template = parser.Template(t, + env=environment.Environment({'size': '3'})) # test with size parameter provided as string - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment({'size': '3'})) + stack = parser.Stack(self.ctx, 'test_stack', template) err = self.assertRaises(exception.StackValidationFailed, stack.validate) self.assertIn('"3" is not an allowed value [1, 4, 8]', six.text_type(err)) # test with size parameter provided as number - stack = parser.Stack(self.ctx, 'test_stack', template, - environment.Environment({'size': 3})) + template.env = environment.Environment({'size': 3}) + stack = parser.Stack(self.ctx, 'test_stack', template) err = self.assertRaises(exception.StackValidationFailed, stack.validate) self.assertIn('"3" is not an allowed value [1, 4, 8]', diff --git a/heat/tests/utils.py b/heat/tests/utils.py index 35bdb124b1..0b7caab10b 100644 --- a/heat/tests/utils.py +++ b/heat/tests/utils.py @@ -96,7 +96,7 @@ def parse_stack(t, params=None, files=None, stack_name=None, templ.store() if stack_name is None: stack_name = random_name() - stk = stack.Stack(ctx, stack_name, templ, stack_id, + stk = stack.Stack(ctx, stack_name, templ, stack_id=stack_id, timeout_mins=timeout_mins) stk.store() return stk