def do_stack_preview(hc, args):
"""Preview the stack."""
tpl_files, template = template_utils.get_template_contents(
args.template_file, args.template_url, args.template_object, hc.http_client.raw_request
)
env_files, env = template_utils.process_environment_and_files(env_path=args.environment_file)
fields = {
"stack_name": args.name,
"parameters": utils.format_parameters(args.parameters),
"template": template,
"files": dict(list(tpl_files.items()) + list(env_files.items())),
"environment": env,
}
stack = hc.stacks.preview(**fields)
formatters = {
"description": utils.text_wrap_formatter,
"template_description": utils.text_wrap_formatter,
"stack_status_reason": utils.text_wrap_formatter,
"parameters": utils.json_formatter,
"outputs": utils.json_formatter,
"resources": utils.json_formatter,
"links": utils.link_formatter,
}
utils.print_dict(stack.to_dict(), formatters=formatters)
def test_base_resources_integration(self):
"""Define test for base resources interation from core porjects
The alternative scenario is the following:
1. Create a stack with basic resources from core projects.
2. Check that all stack resources are created successfully.
3. Wait for deployment.
4. Check that stack was created.
5. Check stack outputs.
"""
self.private_net_name = test.rand_name('heat-net')
parameters = {
'key_name': test.rand_name('heat-key'),
'flavor': self.conf.instance_type,
'image': self.conf.image_ref,
'vol_size': self.conf.volume_size,
'private_net_name': self.private_net_name
}
env_files, env = template_utils.process_environment_and_files(
self.conf.boot_config_env)
# Launch stack
self.stack_identifier = self.launch_stack(
template_name='test_base_resources.yaml',
parameters=parameters,
expected_status=None,
environment=env
)
# Check stack
self.check_stack()
def test_base_resources_integration(self):
"""Define test for base resources interation from core porjects
The alternative scenario is the following:
1. Create a stack with basic resources from core projects.
2. Check that all stack resources are created successfully.
3. Wait for deployment.
4. Check that stack was created.
5. Check stack outputs.
"""
self.private_net_name = test.rand_name('heat-net')
parameters = {
'key_name': test.rand_name('heat-key'),
'flavor': self.conf.instance_type,
'image': self.conf.image_ref,
'vol_size': self.conf.volume_size,
'private_net_name': self.private_net_name
}
env_files, env = template_utils.process_environment_and_files(
self.conf.boot_config_env)
# Launch stack
self.stack_identifier = self.launch_stack(
template_name='test_base_resources.yaml',
parameters=parameters,
expected_status=None,
environment=env)
# Check stack
self.check_stack()
def do_stack_adopt(hc, args):
'''Adopt a stack.'''
env_files, env = template_utils.process_environment_and_files(
env_path=args.environment_file)
if not args.adopt_file:
raise exc.CommandError(_('Need to specify %(arg)s') %
{'arg': '--adopt-file'})
adopt_url = utils.normalise_file_path_to_url(args.adopt_file)
adopt_data = request.urlopen(adopt_url).read()
if args.create_timeout:
logger.warning(_LW('%(arg1)s is deprecated, '
'please use %(arg2)s instead'),
{
'arg1': '-c/--create-timeout',
'arg2': '-t/--timeout'
})
fields = {
'stack_name': args.name,
'disable_rollback': not(args.enable_rollback),
'adopt_stack_data': adopt_data,
'parameters': utils.format_parameters(args.parameters),
'files': dict(list(env_files.items())),
'environment': env
}
timeout = args.timeout or args.create_timeout
if timeout:
fields['timeout_mins'] = timeout
hc.stacks.create(**fields)
do_stack_list(hc)
def test_process_environment_file(self):
self.m.StubOutWithMock(request, 'urlopen')
env_file = '/home/my/dir/env.yaml'
env = b'''
resource_registry:
"OS::Thingy": "file:///home/b/a.yaml"
'''
request.urlopen('file://%s' % env_file).AndReturn(
six.BytesIO(env))
request.urlopen('file:///home/b/a.yaml').AndReturn(
six.BytesIO(self.template_a))
request.urlopen('file:///home/b/a.yaml').AndReturn(
six.BytesIO(self.template_a))
self.m.ReplayAll()
files, env_dict = template_utils.process_environment_and_files(
env_file)
self.assertEqual(
{'resource_registry': {
'OS::Thingy': 'file:///home/b/a.yaml'}},
env_dict)
self.assertEqual(self.template_a.decode('utf-8'),
files['file:///home/b/a.yaml'])
def do_stack_create(hc, args):
"""Create the stack."""
tpl_files, template = template_utils.get_template_contents(
args.template_file, args.template_url, args.template_object, hc.http_client.raw_request
)
env_files, env = template_utils.process_environment_and_files(env_path=args.environment_file)
if args.create_timeout:
logger.warning("-c/--create-timeout is deprecated, " "please use -t/--timeout instead")
fields = {
"stack_name": args.name,
"disable_rollback": not (args.enable_rollback),
"parameters": utils.format_parameters(args.parameters),
"template": template,
"files": dict(list(tpl_files.items()) + list(env_files.items())),
"environment": env,
}
timeout = args.timeout or args.create_timeout
if timeout:
fields["timeout_mins"] = timeout
hc.stacks.create(**fields)
do_stack_list(hc)
def do_stack_adopt(hc, args):
"""Adopt a stack."""
env_files, env = template_utils.process_environment_and_files(env_path=args.environment_file)
if not args.adopt_file:
raise exc.CommandError("Need to specify --adopt-file")
adopt_url = template_utils.normalise_file_path_to_url(args.adopt_file)
adopt_data = request.urlopen(adopt_url).read()
if args.create_timeout:
logger.warning("-c/--create-timeout is deprecated, " "please use -t/--timeout instead")
fields = {
"stack_name": args.name,
"disable_rollback": not (args.enable_rollback),
"adopt_stack_data": adopt_data,
"parameters": utils.format_parameters(args.parameters),
"files": dict(list(env_files.items())),
"environment": env,
}
timeout = args.timeout or args.create_timeout
if timeout:
fields["timeout_mins"] = timeout
hc.stacks.create(**fields)
do_stack_list(hc)
def test_process_environment_relative_file_up(self, mock_url):
env_file = '/home/my/dir/env.yaml'
env_url = 'file:///home/my/dir/env.yaml'
env = b'''
resource_registry:
"OS::Thingy": ../bar/a.yaml
'''
mock_url.side_effect = [
six.BytesIO(env),
six.BytesIO(self.template_a),
six.BytesIO(self.template_a)
]
env_url = 'file://%s' % env_file
self.assertEqual(env_url, utils.normalise_file_path_to_url(env_file))
self.assertEqual('file:///home/my/dir',
utils.base_url_for_url(env_url))
files, env_dict = template_utils.process_environment_and_files(
env_file)
self.assertEqual(
{
'resource_registry': {
'OS::Thingy': 'file:///home/my/bar/a.yaml'
}
}, env_dict)
self.assertEqual(self.template_a.decode('utf-8'),
files['file:///home/my/bar/a.yaml'])
mock_url.assert_has_calls([
mock.call(env_url),
mock.call('file:///home/my/bar/a.yaml'),
mock.call('file:///home/my/bar/a.yaml')
])
def test_process_environment_relative_file(self):
self.m.StubOutWithMock(urlutils, 'urlopen')
env_file = '/home/my/dir/env.yaml'
env_url = 'file:///home/my/dir/env.yaml'
env = '''
resource_registry:
"OS::Thingy": a.yaml
'''
tmpl = '{"foo": "bar"}'
urlutils.urlopen(env_url).AndReturn(
six.StringIO(env))
urlutils.urlopen('file:///home/my/dir/a.yaml').AndReturn(
six.StringIO(tmpl))
self.m.ReplayAll()
self.assertEqual(
env_url,
template_utils.normalise_file_path_to_url(env_file))
self.assertEqual(
'file:///home/my/dir',
template_utils.base_url_for_url(env_url))
files, env_dict = template_utils.process_environment_and_files(
env_file)
self.assertEqual(
{'resource_registry': {
'OS::Thingy': 'file:///home/my/dir/a.yaml'}},
env_dict)
self.assertEqual(
'{"foo": "bar"}', files['file:///home/my/dir/a.yaml'])
def test_process_environment_file(self):
self.m.StubOutWithMock(request, 'urlopen')
env_file = '/home/my/dir/env.yaml'
env = b'''
resource_registry:
"OS::Thingy": "file:///home/b/a.yaml"
'''
request.urlopen('file://%s' % env_file).AndReturn(
six.BytesIO(env))
request.urlopen('file:///home/b/a.yaml').AndReturn(
six.BytesIO(self.template_a))
request.urlopen('file:///home/b/a.yaml').AndReturn(
six.BytesIO(self.template_a))
self.m.ReplayAll()
files, env_dict = template_utils.process_environment_and_files(
env_file)
self.assertEqual(
{'resource_registry': {
'OS::Thingy': 'file:///home/b/a.yaml'}},
env_dict)
self.assertEqual(self.template_a.decode('utf-8'),
files['file:///home/b/a.yaml'])
def do_stack_update(hc, args):
'''Update the stack.'''
tpl_files, template = template_utils.get_template_contents(
args.template_file,
args.template_url,
args.template_object,
hc.http_client.raw_request)
env_files, env = template_utils.process_environment_and_files(
env_path=args.environment_file)
fields = {
'stack_id': args.id,
'parameters': utils.format_parameters(args.parameters),
'template': template,
'files': dict(list(tpl_files.items()) + list(env_files.items())),
'environment': env
}
if args.timeout:
fields['timeout_mins'] = args.timeout
hc.stacks.update(**fields)
do_stack_list(hc)
def do_stack_preview(hc, args):
'''Preview the stack.'''
tpl_files, template = template_utils.get_template_contents(
args.template_file,
args.template_url,
args.template_object,
hc.http_client.raw_request)
env_files, env = template_utils.process_environment_and_files(
env_path=args.environment_file)
fields = {
'stack_name': args.name,
'parameters': utils.format_parameters(args.parameters),
'template': template,
'files': dict(list(tpl_files.items()) + list(env_files.items())),
'environment': env
}
stack = hc.stacks.preview(**fields)
formatters = {
'description': utils.text_wrap_formatter,
'template_description': utils.text_wrap_formatter,
'stack_status_reason': utils.text_wrap_formatter,
'parameters': utils.json_formatter,
'outputs': utils.json_formatter,
'resources': utils.json_formatter,
'links': utils.link_formatter,
}
utils.print_dict(stack.to_dict(), formatters=formatters)
def do_stack_create(hc, args):
'''Create the stack.'''
tpl_files, template = template_utils.get_template_contents(
args.template_file,
args.template_url,
args.template_object,
hc.http_client.raw_request)
env_files, env = template_utils.process_environment_and_files(
env_path=args.environment_file)
if args.create_timeout:
logger.warning('-c/--create-timeout is deprecated, '
'please use -t/--timeout instead')
fields = {
'stack_name': args.name,
'disable_rollback': not(args.enable_rollback),
'parameters': utils.format_parameters(args.parameters),
'template': template,
'files': dict(list(tpl_files.items()) + list(env_files.items())),
'environment': env
}
timeout = args.timeout or args.create_timeout
if timeout:
fields['timeout_mins'] = timeout
hc.stacks.create(**fields)
do_stack_list(hc)
def test_process_environment_relative_file(self):
self.m.StubOutWithMock(request, 'urlopen')
env_file = '/home/my/dir/env.yaml'
env_url = 'file:///home/my/dir/env.yaml'
env = b'''
resource_registry:
"OS::Thingy": a.yaml
'''
request.urlopen(env_url).AndReturn(
six.BytesIO(env))
request.urlopen('file:///home/my/dir/a.yaml').AndReturn(
six.BytesIO(self.template_a))
request.urlopen('file:///home/my/dir/a.yaml').AndReturn(
six.BytesIO(self.template_a))
self.m.ReplayAll()
self.assertEqual(
env_url,
utils.normalise_file_path_to_url(env_file))
self.assertEqual(
'file:///home/my/dir',
utils.base_url_for_url(env_url))
files, env_dict = template_utils.process_environment_and_files(
env_file)
self.assertEqual(
{'resource_registry': {
'OS::Thingy': 'file:///home/my/dir/a.yaml'}},
env_dict)
self.assertEqual(self.template_a.decode('utf-8'),
files['file:///home/my/dir/a.yaml'])
def test_ignore_env_keys(self):
self.m.StubOutWithMock(request, 'urlopen')
env_file = '/home/my/dir/env.yaml'
env = b'''
resource_registry:
resources:
bar:
hooks: pre_create
restricted_actions: replace
'''
request.urlopen('file://%s' % env_file).AndReturn(six.BytesIO(env))
self.m.ReplayAll()
_, env_dict = template_utils.process_environment_and_files(env_file)
self.assertEqual(
{
u'resource_registry': {
u'resources': {
u'bar': {
u'hooks': u'pre_create',
u'restricted_actions': u'replace'
}
}
}
}, env_dict)
self.m.VerifyAll()
def do_stack_adopt(hc, args):
'''Adopt a stack.'''
env_files, env = template_utils.process_environment_and_files(
env_path=args.environment_file)
if not args.adopt_file:
raise exc.CommandError('Need to specify --adopt-file')
adopt_url = template_utils.normalise_file_path_to_url(args.adopt_file)
adopt_data = request.urlopen(adopt_url).read()
if args.create_timeout:
logger.warning('-c/--create-timeout is deprecated, '
'please use -t/--timeout instead')
fields = {
'stack_name': args.name,
'disable_rollback': not (args.enable_rollback),
'adopt_stack_data': adopt_data,
'parameters': utils.format_parameters(args.parameters),
'files': dict(list(env_files.items())),
'environment': env
}
timeout = args.timeout or args.create_timeout
if timeout:
fields['timeout_mins'] = timeout
hc.stacks.create(**fields)
do_stack_list(hc)
def test_process_environment_relative_file_up(self):
self.m.StubOutWithMock(request, 'urlopen')
env_file = '/home/my/dir/env.yaml'
env_url = 'file:///home/my/dir/env.yaml'
env = b'''
resource_registry:
"OS::Thingy": ../bar/a.yaml
'''
request.urlopen(env_url).AndReturn(six.BytesIO(env))
request.urlopen('file:///home/my/bar/a.yaml').AndReturn(
six.BytesIO(self.template_a))
request.urlopen('file:///home/my/bar/a.yaml').AndReturn(
six.BytesIO(self.template_a))
self.m.ReplayAll()
env_url = 'file://%s' % env_file
self.assertEqual(env_url, utils.normalise_file_path_to_url(env_file))
self.assertEqual('file:///home/my/dir',
utils.base_url_for_url(env_url))
files, env_dict = template_utils.process_environment_and_files(
env_file)
self.assertEqual(
{
'resource_registry': {
'OS::Thingy': 'file:///home/my/bar/a.yaml'
}
}, env_dict)
self.assertEqual(self.template_a.decode('utf-8'),
files['file:///home/my/bar/a.yaml'])
def test_server_software_config(self):
"""Check that passed files with scripts are executed on created server.
The alternative scenario is the following:
1. Create a stack and pass files with scripts.
2. Check that all stack resources are created successfully.
3. Wait for all deployments.
4. Check that stack was created.
5. Check stack outputs.
"""
parameters = {
'key_name': self.keypair_name,
'flavor': self.conf.instance_type,
'image': self.conf.image_ref,
'network': self.net['id']
}
files = {'cfg1.sh': CFG1_SH, 'cfg3.pp': CFG3_PP}
env_files, env = template_utils.process_environment_and_files(
self.conf.boot_config_env)
# Launch stack
self.stack_identifier = self.launch_stack(
stack_name=self.stack_name,
template_name='test_server_software_config.yaml',
parameters=parameters,
files=dict(list(files.items()) + list(env_files.items())),
expected_status=None,
environment=env)
# Check stack
self.check_stack()
def test_process_environment_file(self, mock_url):
env_file = '/home/my/dir/env.yaml'
env = b'''
resource_registry:
"OS::Thingy": "file:///home/b/a.yaml"
'''
mock_url.side_effect = [
six.BytesIO(env),
six.BytesIO(self.template_a),
six.BytesIO(self.template_a)
]
files, env_dict = template_utils.process_environment_and_files(
env_file)
self.assertEqual(
{'resource_registry': {
'OS::Thingy': 'file:///home/b/a.yaml'
}}, env_dict)
self.assertEqual(self.template_a.decode('utf-8'),
files['file:///home/b/a.yaml'])
mock_url.assert_has_calls([
mock.call('file://%s' % env_file),
mock.call('file:///home/b/a.yaml'),
mock.call('file:///home/b/a.yaml')
])
def do_stack_adopt(hc, args):
'''Adopt a stack.'''
tpl_files, template = template_utils.get_template_contents(
args.template_file,
args.template_url,
args.template_object,
hc.http_client.raw_request)
env_files, env = template_utils.process_environment_and_files(
env_path=args.environment_file)
if not args.adopt_file:
raise exc.CommandError('Need to specify --adopt-file')
adopt_url = template_utils.normalise_file_path_to_url(args.adopt_file)
adopt_data = request.urlopen(adopt_url).read()
if args.create_timeout:
logger.warning('-c/--create-timeout is deprecated, '
'please use -t/--timeout instead')
fields = {
'stack_name': args.name,
'timeout_mins': args.timeout or args.create_timeout,
'disable_rollback': not(args.enable_rollback),
'adopt_stack_data': adopt_data,
'parameters': utils.format_parameters(args.parameters),
'template': template,
'files': dict(list(tpl_files.items()) + list(env_files.items())),
'environment': env
}
hc.stacks.create(**fields)
do_stack_list(hc)
def do_stack_create(hc, args):
'''Create the stack.'''
tpl_files, template = template_utils.get_template_contents(
args.template_file,
args.template_url,
args.template_object,
hc.http_client.raw_request)
env_files, env = template_utils.process_environment_and_files(
env_path=args.environment_file)
if args.create_timeout:
logger.warning('-c/--create-timeout is deprecated, '
'please use -t/--timeout instead')
fields = {
'stack_name': args.name,
'disable_rollback': not(args.enable_rollback),
'parameters': utils.format_parameters(args.parameters),
'template': template,
'files': dict(list(tpl_files.items()) + list(env_files.items())),
'environment': env
}
timeout = args.timeout or args.create_timeout
if timeout:
fields['timeout_mins'] = timeout
hc.stacks.create(**fields)
do_stack_list(hc)
def do_stack_update(hc, args):
'''Update the stack.'''
tpl_files, template = template_utils.get_template_contents(
args.template_file,
args.template_url,
args.template_object,
hc.http_client.raw_request)
env_files, env = template_utils.process_environment_and_files(
env_path=args.environment_file)
fields = {
'stack_id': args.id,
'parameters': utils.format_parameters(args.parameters),
'template': template,
'files': dict(list(tpl_files.items()) + list(env_files.items())),
'environment': env
}
if args.timeout:
fields['timeout_mins'] = args.timeout
hc.stacks.update(**fields)
do_stack_list(hc)
def do_stack_preview(hc, args):
'''Preview the stack.'''
tpl_files, template = template_utils.get_template_contents(
args.template_file,
args.template_url,
args.template_object,
hc.http_client.raw_request)
env_files, env = template_utils.process_environment_and_files(
env_path=args.environment_file)
fields = {
'stack_name': args.name,
'parameters': utils.format_parameters(args.parameters),
'template': template,
'files': dict(list(tpl_files.items()) + list(env_files.items())),
'environment': env
}
stack = hc.stacks.preview(**fields)
formatters = {
'description': utils.text_wrap_formatter,
'template_description': utils.text_wrap_formatter,
'stack_status_reason': utils.text_wrap_formatter,
'parameters': utils.json_formatter,
'outputs': utils.json_formatter,
'resources': utils.json_formatter,
'links': utils.link_formatter,
}
utils.print_dict(stack.to_dict(), formatters=formatters)
def test_process_environment_empty_file(self, mock_url):
env_file = '/home/my/dir/env.yaml'
env = b''
mock_url.return_value = six.BytesIO(env)
files, env_dict = template_utils.process_environment_and_files(
env_file)
self.assertEqual({}, env_dict)
self.assertEqual({}, files)
mock_url.assert_called_with('file://%s' % env_file)
def get_heat_temp_files(self, template, env_file=None):
try:
env = None
files = None
temp = None
files, temp = template_utils.process_template_path(template)
if env_file:
files, env = template_utils.process_environment_and_files(
env_file, template)
return files, temp, env
except Exception as err:
logger.debug(err)
raise
def test_process_environment_empty_file(self):
self.m.StubOutWithMock(request, "urlopen")
env_file = "/home/my/dir/env.yaml"
env = b""
request.urlopen("file://%s" % env_file).AndReturn(six.BytesIO(env))
self.m.ReplayAll()
files, env_dict = template_utils.process_environment_and_files(env_file)
self.assertEqual({}, env_dict)
self.assertEqual({}, files)
def test_process_environment_empty_file(self):
self.m.StubOutWithMock(urlutils, 'urlopen')
env_file = '/home/my/dir/env.yaml'
env = ''
urlutils.urlopen('file://%s' % env_file).AndReturn(six.StringIO(env))
self.m.ReplayAll()
files, env_dict = template_utils.process_environment_and_files(
env_file)
self.assertEqual({}, env_dict)
self.assertEqual({}, files)
def test_process_environment_empty_file(self):
self.m.StubOutWithMock(request, 'urlopen')
env_file = '/home/my/dir/env.yaml'
env = b''
request.urlopen('file://%s' % env_file).AndReturn(six.BytesIO(env))
self.m.ReplayAll()
files, env_dict = template_utils.process_environment_and_files(
env_file)
self.assertEqual({}, env_dict)
self.assertEqual({}, files)
def do_template_validate(hc, args):
"""Validate a template with parameters."""
tpl_files, template = template_utils.get_template_contents(
args.template_file, args.template_url, args.template_object, hc.http_client.raw_request
)
env_files, env = template_utils.process_environment_and_files(env_path=args.environment_file)
fields = {
"parameters": utils.format_parameters(args.parameters),
"template": template,
"files": dict(list(tpl_files.items()) + list(env_files.items())),
"environment": env,
}
validation = hc.stacks.validate(**fields)
print(jsonutils.dumps(validation, indent=2))
def test_process_environment_file(self):
self.m.StubOutWithMock(request, "urlopen")
env_file = "/home/my/dir/env.yaml"
env = b"""
resource_registry:
"OS::Thingy": "file:///home/b/a.yaml"
"""
request.urlopen("file://%s" % env_file).AndReturn(six.BytesIO(env))
request.urlopen("file:///home/b/a.yaml").AndReturn(six.BytesIO(self.template_a))
request.urlopen("file:///home/b/a.yaml").AndReturn(six.BytesIO(self.template_a))
self.m.ReplayAll()
files, env_dict = template_utils.process_environment_and_files(env_file)
self.assertEqual({"resource_registry": {"OS::Thingy": "file:///home/b/a.yaml"}}, env_dict)
self.assertEqual(self.template_a.decode("utf-8"), files["file:///home/b/a.yaml"])
def test_process_environment_url(self):
env = b"""
resource_registry:
"OS::Thingy": "a.yaml"
"""
url = "http://no.where/some/path/to/file.yaml"
tmpl_url = "http://no.where/some/path/to/a.yaml"
self.m.StubOutWithMock(request, "urlopen")
request.urlopen(url).AndReturn(six.BytesIO(env))
request.urlopen(tmpl_url).AndReturn(six.BytesIO(self.template_a))
request.urlopen(tmpl_url).AndReturn(six.BytesIO(self.template_a))
self.m.ReplayAll()
files, env_dict = template_utils.process_environment_and_files(url)
self.assertEqual({"resource_registry": {"OS::Thingy": tmpl_url}}, env_dict)
self.assertEqual(self.template_a.decode("utf-8"), files[tmpl_url])
def do_template_validate(hc, args):
'''Validate a template with parameters.'''
tpl_files, template = template_utils.get_template_contents(
args.template_file, args.template_url, args.template_object,
hc.http_client.raw_request)
env_files, env = template_utils.process_environment_and_files(
env_path=args.environment_file)
fields = {
'parameters': utils.format_parameters(args.parameters),
'template': template,
'files': dict(list(tpl_files.items()) + list(env_files.items())),
'environment': env
}
validation = hc.stacks.validate(**fields)
print(jsonutils.dumps(validation, indent=2))
def test_process_environment_url(self):
env = b'''
resource_registry:
"OS::Thingy": "a.yaml"
'''
url = 'http://no.where/some/path/to/file.yaml'
tmpl_url = 'http://no.where/some/path/to/a.yaml'
self.m.StubOutWithMock(request, 'urlopen')
request.urlopen(url).AndReturn(six.BytesIO(env))
request.urlopen(tmpl_url).AndReturn(six.BytesIO(self.template_a))
self.m.ReplayAll()
files, env_dict = template_utils.process_environment_and_files(
url)
self.assertEqual({'resource_registry': {'OS::Thingy': tmpl_url}},
env_dict)
self.assertEqual(self.template_a.decode('utf-8'), files[tmpl_url])
def do_template_validate(hc, args):
'''Validate a template with parameters.'''
tpl_files, template = template_utils.get_template_contents(
args.template_file,
args.template_url,
args.template_object,
hc.http_client.raw_request)
env_files, env = template_utils.process_environment_and_files(
env_path=args.environment_file)
fields = {
'template': template,
'files': dict(list(tpl_files.items()) + list(env_files.items())),
'environment': env
}
validation = hc.stacks.validate(**fields)
print(jsonutils.dumps(validation, indent=2, ensure_ascii=False))
def test_process_environment_url(self):
env = b'''
resource_registry:
"OS::Thingy": "a.yaml"
'''
url = 'http://no.where/some/path/to/file.yaml'
tmpl_url = 'http://no.where/some/path/to/a.yaml'
self.m.StubOutWithMock(request, 'urlopen')
request.urlopen(url).AndReturn(six.BytesIO(env))
request.urlopen(tmpl_url).AndReturn(six.BytesIO(self.template_a))
self.m.ReplayAll()
files, env_dict = template_utils.process_environment_and_files(
url)
self.assertEqual({'resource_registry': {'OS::Thingy': tmpl_url}},
env_dict)
self.assertEqual(self.template_a.decode('utf-8'), files[tmpl_url])
def test_process_environment_url(self):
env = '''
resource_registry:
"OS::Thingy": "a.yaml"
'''
url = 'http://no.where/some/path/to/file.yaml'
tmpl_url = 'http://no.where/some/path/to/a.yaml'
tmpl = '{"foo": "bar"}'
self.m.StubOutWithMock(urlutils, 'urlopen')
urlutils.urlopen(url).AndReturn(six.StringIO(env))
urlutils.urlopen(tmpl_url).AndReturn(six.StringIO(tmpl))
self.m.ReplayAll()
files, env_dict = template_utils.process_environment_and_files(
url)
self.assertEqual({'resource_registry': {'OS::Thingy': tmpl_url}},
env_dict)
self.assertEqual(tmpl, files[tmpl_url])
def create(self):
tpl_files, template = template_utils.get_template_contents(
self.template_file,
self.template_url,
self.template_object,
self.client.http_client.raw_request)
env_files, env = template_utils.process_environment_and_files()
fields = {
'stack_name': self.name,
'disable_rollback': False, #not(args.enable_rollback),
'template': template,
'files': dict(list(tpl_files.items()) + list(env_files.items())),
'environment': env
}
if self.parameters:
fields['parameters'] = self.parameters #utils.format_parameters(self.parameters),
myresult = self.client.stacks.create(**fields)
self.id = myresult['stack']['id']
def test_ignore_env_keys(self):
self.m.StubOutWithMock(request, 'urlopen')
env_file = '/home/my/dir/env.yaml'
env = b'''
resource_registry:
resources:
bar:
hooks: pre_create
restricted_actions: replace
'''
request.urlopen('file://%s' % env_file).AndReturn(
six.BytesIO(env))
self.m.ReplayAll()
_, env_dict = template_utils.process_environment_and_files(
env_file)
self.assertEqual(
{u'resource_registry': {u'resources': {
u'bar': {u'hooks': u'pre_create',
u'restricted_actions': u'replace'}}}},
env_dict)
self.m.VerifyAll()
def test_process_environment_relative_file(self):
self.m.StubOutWithMock(request, "urlopen")
env_file = "/home/my/dir/env.yaml"
env_url = "file:///home/my/dir/env.yaml"
env = b"""
resource_registry:
"OS::Thingy": a.yaml
"""
request.urlopen(env_url).AndReturn(six.BytesIO(env))
request.urlopen("file:///home/my/dir/a.yaml").AndReturn(six.BytesIO(self.template_a))
request.urlopen("file:///home/my/dir/a.yaml").AndReturn(six.BytesIO(self.template_a))
self.m.ReplayAll()
self.assertEqual(env_url, utils.normalise_file_path_to_url(env_file))
self.assertEqual("file:///home/my/dir", utils.base_url_for_url(env_url))
files, env_dict = template_utils.process_environment_and_files(env_file)
self.assertEqual({"resource_registry": {"OS::Thingy": "file:///home/my/dir/a.yaml"}}, env_dict)
self.assertEqual(self.template_a.decode("utf-8"), files["file:///home/my/dir/a.yaml"])
def test_server_software_config(self):
"""
Check that passed files with scripts are executed on created server.
The alternative scenario is the following:
1. Create a stack and pass files with scripts.
2. Check that all stack resources are created successfully.
3. Wait for all deployments.
4. Check that stack was created.
5. Check stack outputs.
"""
parameters = {
'key_name': self.keypair_name,
'flavor': self.conf.instance_type,
'image': self.conf.image_ref,
'network': self.net['id']
}
files = {
'cfg1.sh': CFG1_SH,
'cfg3.pp': CFG3_PP
}
env_files, env = template_utils.process_environment_and_files(
self.conf.boot_config_env)
# Launch stack
self.stack_identifier = self.launch_stack(
stack_name=self.stack_name,
template_name='test_server_software_config.yaml',
parameters=parameters,
files=dict(list(files.items()) + list(env_files.items())),
expected_status=None,
environment=env
)
# Check stack
self.check_stack()
def do_stack_create(hc, args):
'''Create the stack.'''
tpl_files, template = template_utils.get_template_contents(
args.template_file,
args.template_url,
args.template_object,
hc.http_client.raw_request)
env_files, env = template_utils.process_environment_and_files(
env_path=args.environment_file)
fields = {
'stack_name': args.name,
'timeout_mins': args.create_timeout,
'disable_rollback': not(args.enable_rollback),
'parameters': utils.format_parameters(args.parameters),
'template': template,
'files': dict(tpl_files.items() + env_files.items()),
'environment': env
}
hc.stacks.create(**fields)
do_stack_list(hc)
def do_stack_update(hc, args):
"""Update the stack."""
tpl_files, template = template_utils.get_template_contents(
args.template_file, args.template_url, args.template_object, hc.http_client.raw_request
)
env_files, env = template_utils.process_environment_and_files(env_path=args.environment_file)
fields = {
"stack_id": args.id,
"parameters": utils.format_parameters(args.parameters),
"template": template,
"files": dict(list(tpl_files.items()) + list(env_files.items())),
"environment": env,
}
if args.timeout:
fields["timeout_mins"] = args.timeout
hc.stacks.update(**fields)
do_stack_list(hc)
def test_process_environment_file(self):
self.m.StubOutWithMock(urlutils, 'urlopen')
env_file = '/home/my/dir/env.yaml'
env = '''
resource_registry:
"OS::Thingy": "file:///home/b/a.yaml"
'''
tmpl = '{"foo": "bar"}'
urlutils.urlopen('file://%s' % env_file).AndReturn(
six.StringIO(env))
urlutils.urlopen('file:///home/b/a.yaml').AndReturn(
six.StringIO(tmpl))
self.m.ReplayAll()
files, env_dict = template_utils.process_environment_and_files(
env_file)
self.assertEqual(
{'resource_registry': {
'OS::Thingy': 'file:///home/b/a.yaml'}},
env_dict)
self.assertEqual('{"foo": "bar"}', files['file:///home/b/a.yaml'])
def test_process_environment_url(self, mock_url):
env = b'''
resource_registry:
"OS::Thingy": "a.yaml"
'''
url = 'http://no.where/some/path/to/file.yaml'
tmpl_url = 'http://no.where/some/path/to/a.yaml'
mock_url.side_effect = [
six.BytesIO(env),
six.BytesIO(self.template_a),
six.BytesIO(self.template_a)
]
files, env_dict = template_utils.process_environment_and_files(url)
self.assertEqual({'resource_registry': {
'OS::Thingy': tmpl_url
}}, env_dict)
self.assertEqual(self.template_a.decode('utf-8'), files[tmpl_url])
mock_url.assert_has_calls(
[mock.call(url),
mock.call(tmpl_url),
mock.call(tmpl_url)])
def test_ignore_env_keys(self, mock_url):
env_file = '/home/my/dir/env.yaml'
env = b'''
resource_registry:
resources:
bar:
hooks: pre_create
restricted_actions: replace
'''
mock_url.return_value = six.BytesIO(env)
_, env_dict = template_utils.process_environment_and_files(env_file)
self.assertEqual(
{
u'resource_registry': {
u'resources': {
u'bar': {
u'hooks': u'pre_create',
u'restricted_actions': u'replace'
}
}
}
}, env_dict)
mock_url.assert_called_with('file://%s' % env_file)
def test_no_process_environment_and_files(self):
files, env = template_utils.process_environment_and_files()
self.assertEqual({}, env)
self.assertEqual({}, files)
def get_environment_and_file(self, env_path):
env_files, env = template_utils.process_environment_and_files(
env_path=env_path)
print "env: %s" % env
print "env files: %s" % env_files
return env, env_files
def test_env_nested_includes(self):
self.m.StubOutWithMock(request, 'urlopen')
env_file = '/home/my/dir/env.yaml'
env_url = 'file:///home/my/dir/env.yaml'
env = b'''
resource_registry:
"OS::Thingy": template.yaml
'''
template_url = u'file:///home/my/dir/template.yaml'
foo_url = u'file:///home/my/dir/foo.yaml'
egg_url = u'file:///home/my/dir/spam/egg.yaml'
ham_url = u'file:///home/my/dir/spam/ham.yaml'
one_url = u'file:///home/my/dir/spam/one.yaml'
two_url = u'file:///home/my/dir/spam/two.yaml'
three_url = u'file:///home/my/dir/spam/three.yaml'
request.urlopen(env_url).AndReturn(six.BytesIO(env))
request.urlopen(template_url).AndReturn(six.BytesIO(self.hot_template))
request.urlopen(template_url).AndReturn(six.BytesIO(self.hot_template))
request.urlopen(foo_url).InAnyOrder().AndReturn(
six.BytesIO(self.foo_template))
request.urlopen(egg_url).InAnyOrder().AndReturn(
six.BytesIO(self.egg_template))
request.urlopen(ham_url).InAnyOrder().AndReturn(
six.BytesIO(b'ham contents'))
request.urlopen(one_url).InAnyOrder().AndReturn(
six.BytesIO(self.foo_template))
request.urlopen(two_url).InAnyOrder().AndReturn(
six.BytesIO(self.foo_template))
request.urlopen(three_url).InAnyOrder().AndReturn(
six.BytesIO(b'three contents'))
request.urlopen(foo_url).InAnyOrder().AndReturn(
six.BytesIO(self.foo_template))
request.urlopen(egg_url).InAnyOrder().AndReturn(
six.BytesIO(self.egg_template))
request.urlopen(one_url).InAnyOrder().AndReturn(
six.BytesIO(self.foo_template))
request.urlopen(two_url).InAnyOrder().AndReturn(
six.BytesIO(self.foo_template))
self.m.ReplayAll()
files, env_dict = template_utils.process_environment_and_files(
env_file)
self.assertEqual({'resource_registry': {
'OS::Thingy': template_url
}}, env_dict)
self.assertEqual(
{
u'heat_template_version': u'2013-05-23',
u'parameters': {
u'param1': {
u'type': u'string'
}
},
u'resources': {
u'resource1': {
u'properties': {
u'foo': u'bar'
},
u'type': foo_url
},
u'resource2': {
u'type': u'OS::Heat::ResourceGroup',
u'properties': {
u'resource_def': {
u'type': egg_url
},
u'with': {
u'get_file': ham_url
}
}
}
}
}, json.loads(files.get(template_url)))
self.assertEqual(yaml.safe_load(self.foo_template.decode('utf-8')),
json.loads(files.get(foo_url)))
self.assertEqual(
{
u'heat_template_version': u'2013-05-23',
u'parameters': {
u'param1': {
u'type': u'string'
}
},
u'resources': {
u'resource1': {
u'properties': {
u'foo': u'bar'
},
u'type': one_url
},
u'resource2': {
u'type': u'OS::Heat::ResourceGroup',
u'properties': {
u'resource_def': {
u'type': two_url
},
u'with': {
u'get_file': three_url
}
}
}
}
}, json.loads(files.get(egg_url)))
self.assertEqual(b'ham contents', files.get(ham_url))
self.assertEqual(yaml.safe_load(self.foo_template.decode('utf-8')),
json.loads(files.get(one_url)))
self.assertEqual(yaml.safe_load(self.foo_template.decode('utf-8')),
json.loads(files.get(two_url)))
self.assertEqual(b'three contents', files.get(three_url))
def test_env_nested_includes(self):
self.m.StubOutWithMock(request, "urlopen")
env_file = "/home/my/dir/env.yaml"
env_url = "file:///home/my/dir/env.yaml"
env = b"""
resource_registry:
"OS::Thingy": template.yaml
"""
template_url = u"file:///home/my/dir/template.yaml"
foo_url = u"file:///home/my/dir/foo.yaml"
egg_url = u"file:///home/my/dir/spam/egg.yaml"
ham_url = u"file:///home/my/dir/spam/ham.yaml"
one_url = u"file:///home/my/dir/spam/one.yaml"
two_url = u"file:///home/my/dir/spam/two.yaml"
three_url = u"file:///home/my/dir/spam/three.yaml"
request.urlopen(env_url).AndReturn(six.BytesIO(env))
request.urlopen(template_url).AndReturn(six.BytesIO(self.hot_template))
request.urlopen(template_url).AndReturn(six.BytesIO(self.hot_template))
request.urlopen(foo_url).InAnyOrder().AndReturn(six.BytesIO(self.foo_template))
request.urlopen(egg_url).InAnyOrder().AndReturn(six.BytesIO(self.egg_template))
request.urlopen(ham_url).InAnyOrder().AndReturn(six.BytesIO(b"ham contents"))
request.urlopen(one_url).InAnyOrder().AndReturn(six.BytesIO(self.foo_template))
request.urlopen(two_url).InAnyOrder().AndReturn(six.BytesIO(self.foo_template))
request.urlopen(three_url).InAnyOrder().AndReturn(six.BytesIO(b"three contents"))
request.urlopen(foo_url).InAnyOrder().AndReturn(six.BytesIO(self.foo_template))
request.urlopen(egg_url).InAnyOrder().AndReturn(six.BytesIO(self.egg_template))
request.urlopen(one_url).InAnyOrder().AndReturn(six.BytesIO(self.foo_template))
request.urlopen(two_url).InAnyOrder().AndReturn(six.BytesIO(self.foo_template))
self.m.ReplayAll()
files, env_dict = template_utils.process_environment_and_files(env_file)
self.assertEqual({"resource_registry": {"OS::Thingy": template_url}}, env_dict)
self.assertEqual(
{
u"heat_template_version": u"2013-05-23",
u"parameters": {u"param1": {u"type": u"string"}},
u"resources": {
u"resource1": {u"properties": {u"foo": u"bar"}, u"type": foo_url},
u"resource2": {
u"type": u"OS::Heat::ResourceGroup",
u"properties": {u"resource_def": {u"type": egg_url}, u"with": {u"get_file": ham_url}},
},
},
},
json.loads(files.get(template_url)),
)
self.assertEqual(yaml.load(self.foo_template.decode("utf-8")), json.loads(files.get(foo_url)))
self.assertEqual(
{
u"heat_template_version": u"2013-05-23",
u"parameters": {u"param1": {u"type": u"string"}},
u"resources": {
u"resource1": {u"properties": {u"foo": u"bar"}, u"type": one_url},
u"resource2": {
u"type": u"OS::Heat::ResourceGroup",
u"properties": {u"resource_def": {u"type": two_url}, u"with": {u"get_file": three_url}},
},
},
},
json.loads(files.get(egg_url)),
)
self.assertEqual(b"ham contents", files.get(ham_url))
self.assertEqual(yaml.load(self.foo_template.decode("utf-8")), json.loads(files.get(one_url)))
self.assertEqual(yaml.load(self.foo_template.decode("utf-8")), json.loads(files.get(two_url)))
self.assertEqual(b"three contents", files.get(three_url))
def process_multiple_environments(created_env_files,
tht_root,
user_tht_root,
cleanup=True):
log = logging.getLogger(__name__ + ".process_multiple_environments")
env_files = {}
localenv = {}
# Normalize paths for full match checks
user_tht_root = os.path.normpath(user_tht_root)
tht_root = os.path.normpath(tht_root)
for env_path in created_env_files:
log.debug("Processing environment files %s" % env_path)
abs_env_path = os.path.abspath(env_path)
if (abs_env_path.startswith(user_tht_root) and
((user_tht_root + '/') in env_path or
(user_tht_root + '/') in abs_env_path
or user_tht_root == abs_env_path or user_tht_root == env_path)):
new_env_path = env_path.replace(user_tht_root + '/',
tht_root + '/')
log.debug("Redirecting env file %s to %s" %
(abs_env_path, new_env_path))
env_path = new_env_path
try:
files, env = template_utils.process_environment_and_files(
env_path=env_path)
except hc_exc.CommandError as ex:
# This provides fallback logic so that we can reference files
# inside the resource_registry values that may be rendered via
# j2.yaml templates, where the above will fail because the
# file doesn't exist in user_tht_root, but it is in tht_root
# See bug https://bugs.launchpad.net/tripleo/+bug/1625783
# for details on why this is needed (backwards-compatibility)
log.debug("Error %s processing environment file %s" %
(six.text_type(ex), env_path))
# Use the temporary path as it's possible the environment
# itself was rendered via jinja.
with open(env_path, 'r') as f:
env_map = yaml.safe_load(f)
env_registry = env_map.get('resource_registry', {})
env_dirname = os.path.dirname(os.path.abspath(env_path))
for rsrc, rsrc_path in six.iteritems(env_registry):
# We need to calculate the absolute path relative to
# env_path not cwd (which is what abspath uses).
abs_rsrc_path = os.path.normpath(
os.path.join(env_dirname, rsrc_path))
# If the absolute path matches user_tht_root, rewrite
# a temporary environment pointing at tht_root instead
if (abs_rsrc_path.startswith(user_tht_root)
and ((user_tht_root + '/') in abs_rsrc_path
or abs_rsrc_path == user_tht_root)):
new_rsrc_path = abs_rsrc_path.replace(
user_tht_root + '/', tht_root + '/')
log.debug("Rewriting %s %s path to %s" %
(env_path, rsrc, new_rsrc_path))
env_registry[rsrc] = new_rsrc_path
else:
# Skip any resources that are mapping to OS::*
# resource names as these aren't paths
if not rsrc_path.startswith("OS::"):
env_registry[rsrc] = abs_rsrc_path
env_map['resource_registry'] = env_registry
f_name = os.path.basename(os.path.splitext(abs_env_path)[0])
with tempfile.NamedTemporaryFile(dir=tht_root,
prefix="env-%s-" % f_name,
suffix=".yaml",
mode="w",
delete=cleanup) as f:
log.debug("Rewriting %s environment to %s" %
(env_path, f.name))
f.write(yaml.safe_dump(env_map, default_flow_style=False))
f.flush()
files, env = template_utils.process_environment_and_files(
env_path=f.name)
if files:
log.debug("Adding files %s for %s" % (files, env_path))
env_files.update(files)
# 'env' can be a deeply nested dictionary, so a simple update is
# not enough
localenv = template_utils.deep_update(localenv, env)
return env_files, localenv
def _stack_create(self):
"""Create a heat stack from a basic heat template, verify its status"""
u.log.debug('Creating heat stack...')
t_url = u.file_to_url(TEMPLATE_REL_PATH)
r_req = self.heat.http_client
u.log.debug('template url: {}'.format(t_url))
t_files, template = template_utils.get_template_contents(t_url, r_req)
env_files, env = template_utils.process_environment_and_files(
env_path=None)
fields = {
'stack_name': STACK_NAME,
'timeout_mins': '15',
'disable_rollback': False,
'parameters': {
'admin_pass': '******',
'key_name': KEYPAIR_NAME,
'image': IMAGE_NAME
},
'template': template,
'files': dict(list(t_files.items()) + list(env_files.items())),
'environment': env
}
# Create the stack.
try:
_stack = self.heat.stacks.create(**fields)
u.log.debug('Stack data: {}'.format(_stack))
_stack_id = _stack['stack']['id']
u.log.debug('Creating new stack, ID: {}'.format(_stack_id))
except Exception as e:
# Generally, an api or cloud config error if this is hit.
msg = 'Failed to create heat stack: {}'.format(e)
amulet.raise_status(amulet.FAIL, msg=msg)
# Confirm stack reaches COMPLETE status.
# /!\ Heat stacks reach a COMPLETE status even when nova cannot
# find resources (a valid hypervisor) to fit the instance, in
# which case the heat stack self-deletes! Confirm anyway...
ret = u.resource_reaches_status(self.heat.stacks,
_stack_id,
expected_stat="COMPLETE",
msg="Stack status wait")
_stacks = list(self.heat.stacks.list())
u.log.debug('All stacks: {}'.format(_stacks))
if not ret:
msg = 'Heat stack failed to reach expected state.'
amulet.raise_status(amulet.FAIL, msg=msg)
# Confirm stack still exists.
try:
_stack = self.heat.stacks.get(STACK_NAME)
except Exception as e:
# Generally, a resource availability issue if this is hit.
msg = 'Failed to get heat stack: {}'.format(e)
amulet.raise_status(amulet.FAIL, msg=msg)
# Confirm stack name.
u.log.debug('Expected, actual stack name: {}, '
'{}'.format(STACK_NAME, _stack.stack_name))
if STACK_NAME != _stack.stack_name:
msg = 'Stack name mismatch, {} != {}'.format(
STACK_NAME, _stack.stack_name)
amulet.raise_status(amulet.FAIL, msg=msg)
def test_env_nested_includes(self):
self.m.StubOutWithMock(request, 'urlopen')
env_file = '/home/my/dir/env.yaml'
env_url = 'file:///home/my/dir/env.yaml'
env = b'''
resource_registry:
"OS::Thingy": template.yaml
'''
template_url = u'file:///home/my/dir/template.yaml'
foo_url = u'file:///home/my/dir/foo.yaml'
egg_url = u'file:///home/my/dir/spam/egg.yaml'
ham_url = u'file:///home/my/dir/spam/ham.yaml'
one_url = u'file:///home/my/dir/spam/one.yaml'
two_url = u'file:///home/my/dir/spam/two.yaml'
three_url = u'file:///home/my/dir/spam/three.yaml'
request.urlopen(env_url).AndReturn(
six.BytesIO(env))
request.urlopen(template_url).AndReturn(
six.BytesIO(self.hot_template))
request.urlopen(template_url).AndReturn(
six.BytesIO(self.hot_template))
request.urlopen(foo_url).InAnyOrder().AndReturn(
six.BytesIO(self.foo_template))
request.urlopen(egg_url).InAnyOrder().AndReturn(
six.BytesIO(self.egg_template))
request.urlopen(ham_url).InAnyOrder().AndReturn(
six.BytesIO(b'ham contents'))
request.urlopen(one_url).InAnyOrder().AndReturn(
six.BytesIO(self.foo_template))
request.urlopen(two_url).InAnyOrder().AndReturn(
six.BytesIO(self.foo_template))
request.urlopen(three_url).InAnyOrder().AndReturn(
six.BytesIO(b'three contents'))
request.urlopen(foo_url).InAnyOrder().AndReturn(
six.BytesIO(self.foo_template))
request.urlopen(egg_url).InAnyOrder().AndReturn(
six.BytesIO(self.egg_template))
request.urlopen(one_url).InAnyOrder().AndReturn(
six.BytesIO(self.foo_template))
request.urlopen(two_url).InAnyOrder().AndReturn(
six.BytesIO(self.foo_template))
self.m.ReplayAll()
files, env_dict = template_utils.process_environment_and_files(
env_file)
self.assertEqual(
{'resource_registry': {
'OS::Thingy': template_url}},
env_dict)
self.assertEqual({
u'heat_template_version': u'2013-05-23',
u'parameters': {u'param1': {u'type': u'string'}},
u'resources': {
u'resource1': {
u'properties': {u'foo': u'bar'},
u'type': foo_url
},
u'resource2': {
u'type': u'OS::Heat::ResourceGroup',
u'properties': {
u'resource_def': {
u'type': egg_url},
u'with': {u'get_file': ham_url}
}
}
}
}, json.loads(files.get(template_url)))
self.assertEqual(yaml.load(self.foo_template.decode('utf-8')),
json.loads(files.get(foo_url)))
self.assertEqual({
u'heat_template_version': u'2013-05-23',
u'parameters': {u'param1': {u'type': u'string'}},
u'resources': {
u'resource1': {
u'properties': {u'foo': u'bar'},
u'type': one_url},
u'resource2': {
u'type': u'OS::Heat::ResourceGroup',
u'properties': {
u'resource_def': {u'type': two_url},
u'with': {u'get_file': three_url}
}
}
}
}, json.loads(files.get(egg_url)))
self.assertEqual(b'ham contents',
files.get(ham_url))
self.assertEqual(yaml.load(self.foo_template.decode('utf-8')),
json.loads(files.get(one_url)))
self.assertEqual(yaml.load(self.foo_template.decode('utf-8')),
json.loads(files.get(two_url)))
self.assertEqual(b'three contents',
files.get(three_url))
def test_no_process_environment_and_files(self):
files, env = template_utils.process_environment_and_files()
self.assertEqual({}, env)
self.assertEqual({}, files)
def test_env_nested_includes(self, mock_url):
env_file = '/home/my/dir/env.yaml'
env_url = 'file:///home/my/dir/env.yaml'
env = b'''
resource_registry:
"OS::Thingy": template.yaml
'''
template_url = u'file:///home/my/dir/template.yaml'
foo_url = u'file:///home/my/dir/foo.yaml'
egg_url = u'file:///home/my/dir/spam/egg.yaml'
ham_url = u'file:///home/my/dir/spam/ham.yaml'
one_url = u'file:///home/my/dir/spam/one.yaml'
two_url = u'file:///home/my/dir/spam/two.yaml'
three_url = u'file:///home/my/dir/spam/three.yaml'
def side_effect(args):
if env_url == args:
return six.BytesIO(env)
if template_url == args:
return six.BytesIO(self.hot_template)
if foo_url == args:
return six.BytesIO(self.foo_template)
if egg_url == args:
return six.BytesIO(self.egg_template)
if ham_url == args:
return six.BytesIO(b'ham contents')
if one_url == args:
return six.BytesIO(self.foo_template)
if two_url == args:
return six.BytesIO(self.foo_template)
if three_url == args:
return six.BytesIO(b'three contents')
mock_url.side_effect = side_effect
files, env_dict = template_utils.process_environment_and_files(
env_file)
self.assertEqual({'resource_registry': {
'OS::Thingy': template_url
}}, env_dict)
self.assertEqual(
{
u'heat_template_version': u'2013-05-23',
u'parameters': {
u'param1': {
u'type': u'string'
}
},
u'resources': {
u'resource1': {
u'properties': {
u'foo': u'bar'
},
u'type': foo_url
},
u'resource2': {
u'type': u'OS::Heat::ResourceGroup',
u'properties': {
u'resource_def': {
u'type': egg_url
},
u'with': {
u'get_file': ham_url
}
}
}
}
}, json.loads(files.get(template_url)))
self.assertEqual(yaml.safe_load(self.foo_template.decode('utf-8')),
json.loads(files.get(foo_url)))
self.assertEqual(
{
u'heat_template_version': u'2013-05-23',
u'parameters': {
u'param1': {
u'type': u'string'
}
},
u'resources': {
u'resource1': {
u'properties': {
u'foo': u'bar'
},
u'type': one_url
},
u'resource2': {
u'type': u'OS::Heat::ResourceGroup',
u'properties': {
u'resource_def': {
u'type': two_url
},
u'with': {
u'get_file': three_url
}
}
}
}
}, json.loads(files.get(egg_url)))
self.assertEqual(b'ham contents', files.get(ham_url))
self.assertEqual(yaml.safe_load(self.foo_template.decode('utf-8')),
json.loads(files.get(one_url)))
self.assertEqual(yaml.safe_load(self.foo_template.decode('utf-8')),
json.loads(files.get(two_url)))
self.assertEqual(b'three contents', files.get(three_url))
mock_url.assert_has_calls([
mock.call(env_url),
mock.call(template_url),
mock.call(foo_url),
mock.call(egg_url),
mock.call(ham_url),
mock.call(one_url),
mock.call(two_url),
mock.call(three_url),
],
any_order=True)
def test_410_heat_stack_create_delete(self):
"""Create stack, confirm nova compute resource, delete stack."""
# Verify new image name
images_list = list(self.glance_client.images.list())
self.assertEqual(images_list[0].name, IMAGE_NAME,
"glance image create failed or unexpected")
# Create a heat stack from a heat template, verify its status
logging.info('Creating heat stack...')
t_name = 'hot_hello_world.yaml'
if (openstack_utils.get_os_release() <
openstack_utils.get_os_release('xenial_queens')):
os_release = 'icehouse'
else:
os_release = 'queens'
# Get location of template files in charm-heat
bundle_path = charm_lifecycle_utils.BUNDLE_DIR
if bundle_path[-1:] == "/":
bundle_path = bundle_path[0:-1]
file_rel_path = os.path.join(os.path.dirname(bundle_path),
TEMPLATES_PATH, os_release, t_name)
file_abs_path = os.path.abspath(file_rel_path)
t_url = urlparse.urlparse(file_abs_path, scheme='file').geturl()
logging.info('template url: {}'.format(t_url))
r_req = self.heat_client.http_client
t_files, template = template_utils.get_template_contents(t_url, r_req)
env_files, env = template_utils.process_environment_and_files(
env_path=None)
fields = {
'stack_name': STACK_NAME,
'timeout_mins': '15',
'disable_rollback': False,
'parameters': {
'admin_pass': '******',
'key_name': nova_utils.KEYPAIR_NAME,
'image': IMAGE_NAME
},
'template': template,
'files': dict(list(t_files.items()) + list(env_files.items())),
'environment': env
}
# Create the stack
try:
stack = self.heat_client.stacks.create(**fields)
logging.info('Stack data: {}'.format(stack))
stack_id = stack['stack']['id']
logging.info('Creating new stack, ID: {}'.format(stack_id))
except Exception as e:
# Generally, an api or cloud config error if this is hit.
msg = 'Failed to create heat stack: {}'.format(e)
self.fail(msg)
# Confirm stack reaches COMPLETE status.
# /!\ Heat stacks reach a COMPLETE status even when nova cannot
# find resources (a valid hypervisor) to fit the instance, in
# which case the heat stack self-deletes! Confirm anyway...
openstack_utils.resource_reaches_status(self.heat_client.stacks,
stack_id,
expected_status="COMPLETE",
msg="Stack status wait")
# List stack
stacks = list(self.heat_client.stacks.list())
logging.info('All stacks: {}'.format(stacks))
# Get stack information
try:
stack = self.heat_client.stacks.get(STACK_NAME)
except Exception as e:
# Generally, a resource availability issue if this is hit.
msg = 'Failed to get heat stack: {}'.format(e)
self.fail(msg)
# Confirm stack name.
logging.info('Expected, actual stack name: {}, '
'{}'.format(STACK_NAME, stack.stack_name))
self.assertEqual(
stack.stack_name, STACK_NAME, 'Stack name mismatch, '
'{} != {}'.format(STACK_NAME, stack.stack_name))
# Confirm existence of a heat-generated nova compute resource
logging.info('Confirming heat stack resource status...')
resource = self.heat_client.resources.get(STACK_NAME, RESOURCE_TYPE)
server_id = resource.physical_resource_id
self.assertTrue(server_id, "Stack failed to spawn a compute resource.")
# Confirm nova instance reaches ACTIVE status
openstack_utils.resource_reaches_status(self.nova_client.servers,
server_id,
expected_status="ACTIVE",
msg="nova instance")
logging.info('Nova instance reached ACTIVE status')
# Delete stack
logging.info('Deleting heat stack...')
openstack_utils.delete_resource(self.heat_client.stacks,
STACK_NAME,
msg="heat stack")
