def add_role_to_plan(self, plan_uuid, role_uuid):
"""Adds a role to the given plan, storing the changes in Tuskar's
storage.
:type plan_uuid: str
:type role_uuid: str
:return: updated plan model instance
:rtype: tuskar.manager.models.DeploymentPlan
:raises tuskar.storage.exceptions.UnknownUUID: if either the plan
or the role cannot be found
"""
# Load the plan and role from storage
db_plan = self.plan_store.retrieve(plan_uuid)
db_role = self.template_store.retrieve(role_uuid)
# Parse the plan and role template into template objects.
deployment_plan = self._plan_to_template_object(db_plan)
role_template = self._role_to_template_object(db_role)
# Use the combination logic to perform the addition.
role_namespace = name_utils.generate_role_namespace(db_role.name,
db_role.version)
template_filename = name_utils.role_template_filename(db_role.name,
db_role.version)
deployment_plan.add_template(role_namespace, role_template,
template_filename)
# Save the updated plan.
updated = self._save_updated_plan(plan_uuid, deployment_plan)
return updated
def test_package_templates_seeded_plan(self):
# Setup
self.seed_store.create(MASTER_SEED_NAME, TEST_SEED)
self.registry_store.create(RESOURCE_REGISTRY_NAME, RESOURCE_REGISTRY)
# more setup (this is normally called in load_roles)
self.registry_mapping_store.create('required_file.yaml',
'some fake template data')
test_role = self._add_test_role()
test_plan = self.plans_manager.create_plan('p1', 'd1')
self.plans_manager.add_role_to_plan(test_plan.uuid, test_role.uuid)
# Test
templates = self.plans_manager.package_templates(test_plan.uuid)
# Verify
self.assertTrue(isinstance(templates, dict))
self.assertEqual(4, len(templates))
self.assertTrue('plan.yaml' in templates)
parsed_plan = parser.parse_template(templates['plan.yaml'])
self.assertEqual(parsed_plan.description, 'd1')
self.assertTrue('environment.yaml' in templates)
self.assertTrue('required_file.yaml' in templates)
parsed_env = parser.parse_environment(templates['environment.yaml'])
self.assertEqual(2, len(parsed_env.registry_entries))
role_filename = name_utils.role_template_filename('r1', '1', None)
self.assertTrue(role_filename in templates)
parsed_role = parser.parse_template(templates[role_filename])
self.assertEqual(parsed_role.description, 'Test provider resource foo')
def test_package_templates_seeded_plan(self):
# Setup
self.seed_store.create(MASTER_SEED_NAME, TEST_SEED)
self.registry_store.create(RESOURCE_REGISTRY_NAME, RESOURCE_REGISTRY)
# more setup (this is normally called in load_roles)
self.registry_mapping_store.create('required_file.yaml',
'some fake template data')
test_role = self._add_test_role()
test_plan = self.plans_manager.create_plan('p1', 'd1')
self.plans_manager.add_role_to_plan(test_plan.uuid, test_role.uuid)
# Test
templates = self.plans_manager.package_templates(test_plan.uuid)
# Verify
self.assertTrue(isinstance(templates, dict))
self.assertEqual(4, len(templates))
self.assertTrue('plan.yaml' in templates)
parsed_plan = parser.parse_template(templates['plan.yaml'])
self.assertEqual(parsed_plan.description, 'd1')
self.assertTrue('environment.yaml' in templates)
self.assertTrue('required_file.yaml' in templates)
parsed_env = parser.parse_environment(templates['environment.yaml'])
self.assertEqual(2, len(parsed_env.registry_entries))
role_filename = name_utils.role_template_filename('r1', '1', None)
self.assertTrue(role_filename in templates)
parsed_role = parser.parse_template(templates[role_filename])
self.assertEqual(parsed_role.description, 'Test provider resource foo')
def test_package_templates(self):
# Setup
test_role = self._add_test_role()
test_plan = self.plans_manager.create_plan('p1', 'd1')
self.plans_manager.add_role_to_plan(test_plan.uuid, test_role.uuid)
# Test
templates = self.plans_manager.package_templates(test_plan.uuid)
# Verify
self.assertTrue(isinstance(templates, dict))
self.assertEqual(3, len(templates))
self.assertTrue('plan.yaml' in templates)
parsed_plan = parser.parse_template(templates['plan.yaml'])
self.assertEqual(parsed_plan.description, 'd1')
self.assertTrue('environment.yaml' in templates)
parsed_env = parser.parse_environment(templates['environment.yaml'])
self.assertEqual(1, len(parsed_env.registry_entries))
role_filename = name_utils.role_template_filename('r1', '1', None)
self.assertTrue(role_filename in templates)
parsed_role = parser.parse_template(templates[role_filename])
self.assertEqual(parsed_role.description, 'Test provider resource foo')
def test_package_templates(self):
# Setup
test_role = self._add_test_role()
test_plan = self.plans_manager.create_plan('p1', 'd1')
self.plans_manager.add_role_to_plan(test_plan.uuid, test_role.uuid)
# Test
templates = self.plans_manager.package_templates(test_plan.uuid)
# Verify
self.assertTrue(isinstance(templates, dict))
self.assertEqual(3, len(templates))
self.assertTrue('plan.yaml' in templates)
parsed_plan = parser.parse_template(templates['plan.yaml'])
self.assertEqual(parsed_plan.description, 'd1')
self.assertTrue('environment.yaml' in templates)
parsed_env = parser.parse_environment(templates['environment.yaml'])
self.assertEqual(1, len(parsed_env.registry_entries))
role_filename = name_utils.role_template_filename('r1', '1', None)
self.assertTrue(role_filename in templates)
parsed_role = parser.parse_template(templates[role_filename])
self.assertEqual(parsed_role.description, 'Test provider resource foo')
def package_templates(self, plan_uuid):
"""Packages and returns all of the templates related to the given plan.
The returned dictionary is keyed by filename and contains the contents
of that file (a template or an environment file).
:type plan_uuid: str
:return: mapping of filename to contents for each file in the plan
:rtype: dict
:raises tuskar.storage.exceptions.UnknownUUID: if there is no plan
with the given UUID
"""
# Load and parse the plan.
db_plan = self.plan_store.retrieve(plan_uuid)
master_template = parser.parse_template(
db_plan.master_template.contents
)
environment = parser.parse_environment(
db_plan.environment_file.contents
)
# Compose the plan files and all plan roles and package them into
# a single dictionary.
plan_contents = composer.compose_template(master_template)
env_contents = composer.compose_environment(environment)
files_dict = {
'plan.yaml': plan_contents,
'environment.yaml': env_contents,
}
plan_roles = self._find_roles(environment)
for role in plan_roles:
contents = composer.compose_template(role.template)
filename = name_utils.role_template_filename(role.name,
role.version)
files_dict[filename] = contents
return files_dict
def package_templates(self, plan_uuid):
"""Packages and returns all of the templates related to the given plan.
The returned dictionary is keyed by filename and contains the contents
of that file (a template or an environment file).
:type plan_uuid: str
:return: mapping of filename to contents for each file in the plan
:rtype: dict
:raises tuskar.storage.exceptions.UnknownUUID: if there is no plan
with the given UUID
"""
# Load and parse the plan.
db_plan = self.plan_store.retrieve(plan_uuid)
master_template = parser.parse_template(
db_plan.master_template.contents
)
environment = parser.parse_environment(
db_plan.environment_file.contents
)
# Compose the plan files and all plan roles and package them into
# a single dictionary.
plan_contents = composer.compose_template(master_template)
env_contents = composer.compose_environment(environment)
files_dict = {
'plan.yaml': plan_contents,
'environment.yaml': env_contents,
}
plan_roles = self._find_roles(environment)
for role in plan_roles:
contents = composer.compose_template(role.template)
filename = name_utils.role_template_filename(role.name,
role.version)
files_dict[filename] = contents
return files_dict
def package_templates(self, plan_uuid):
"""Packages and returns all of the templates related to the given plan.
The returned dictionary is keyed by filename and contains the contents
of that file (a template or an environment file).
:type plan_uuid: str
:return: mapping of filename to contents for each file in the plan
:rtype: dict
:raises tuskar.storage.exceptions.UnknownUUID: if there is no plan
with the given UUID
"""
# Load and parse the plan.
db_plan = self.plan_store.retrieve(plan_uuid)
master_template = parser.parse_template(
db_plan.master_template.contents
)
environment = parser.parse_environment(
db_plan.environment_file.contents
)
# Compose the plan files and all plan roles and package them into
# a single dictionary.
plan_contents = composer.compose_template(master_template)
env_contents = composer.compose_environment(environment)
files_dict = {
'plan.yaml': plan_contents,
'environment.yaml': env_contents,
}
plan_roles = self._find_roles(environment)
manager = RoleManager()
for role in plan_roles:
contents = composer.compose_template(role.template)
filename = name_utils.role_template_filename(role.name,
role.version,
role.relative_path)
files_dict[filename] = contents
def _add_template_extra_data_for(templates, template_store):
template_extra_data = manager.retrieve_db_role_extra()
for template in templates:
db_template = template_store.retrieve_by_name(template.name)
prefix = os_path.split(db_template.name)[0]
template_extra_paths = utils.resolve_template_extra_data(
db_template, template_extra_data)
extra_data_output = manager.template_extra_data_for_output(
template_extra_paths, prefix)
files_dict.update(extra_data_output)
# also grab any extradata files for the role
_add_template_extra_data_for(plan_roles, self.template_store)
# in addition to provider roles above, return non-role template files
reg_mapping = self.registry_mapping_store.list()
for entry in reg_mapping:
if os_path.splitext(entry.name)[1] in ('.yaml', '.yml'):
# if entry is an alias, don't include it
files_dict[entry.name] = entry.contents
# similarly, also grab extradata files for the non role templates
_add_template_extra_data_for(reg_mapping, self.registry_mapping_store)
return files_dict
def add_role_to_plan(self, plan_uuid, role_uuid):
"""Adds a role to the given plan, storing the changes in Tuskar's
storage.
:type plan_uuid: str
:type role_uuid: str
:return: updated plan model instance
:rtype: tuskar.manager.models.DeploymentPlan
:raises tuskar.storage.exceptions.UnknownUUID: if either the plan
or the role cannot be found
"""
# Load the plan and role from storage
db_plan = self.plan_store.retrieve(plan_uuid)
db_role = self.template_store.retrieve(role_uuid)
# Parse the plan and role template into template objects.
deployment_plan = self._plan_to_template_object(db_plan)
role_template = self._role_to_template_object(db_role)
# See if a master seed template has been set.
try:
db_master_seed = self.seed_store.retrieve_by_name(MASTER_SEED_NAME)
master_seed = parser.parse_template(db_master_seed.contents)
except UnknownName:
master_seed = None
special_properties = None
def _find_role_type(registry):
for path in registry.keys():
if path in db_role.registry_path:
return registry[path]
if master_seed is not None:
try:
db_registry_env = self.registry_store.retrieve_by_name(
RESOURCE_REGISTRY_NAME).contents
except UnknownName:
LOG.error("Could not load resource_registry. Make sure you "
"pass --resource-registry to tuskar-load-roles.")
raise
parsed_registry_env = parser.parse_environment(db_registry_env)
registry = dict((e.filename, e.alias)
for e in parsed_registry_env.registry_entries)
role_type = _find_role_type(registry)
special_properties = template_seed.get_property_map_for_role(
master_seed, role_type)
# Use the combination logic to perform the addition.
role_namespace = name_utils.generate_role_namespace(db_role.name,
db_role.version)
template_filename = (
name_utils.role_template_filename(db_role.name, db_role.version,
db_role.relative_path))
deployment_plan.add_template(role_namespace, role_template,
template_filename,
override_properties=special_properties)
# If there is a master seed, add its top-level elements to the plan.
# These calls are idempotent, so it's safe to call each time a role
# is added.
if master_seed is not None:
template_seed.add_top_level_parameters(
master_seed,
deployment_plan.master_template,
deployment_plan.environment)
template_seed.add_top_level_resources(
master_seed, deployment_plan.master_template)
template_seed.add_top_level_outputs(
master_seed, deployment_plan.master_template)
if role_type is None:
LOG.error(
"Role '%s' not found in seed template." % db_role.name)
raise ValueError(db_role.name)
seed_role = template_seed.find_role_from_type(
master_seed.resources, role_type)
if seed_role is None:
LOG.error(
"Role '%s' of type '%s' not found in seed template." %
(db_role.name, role_type))
raise ValueError(db_role.name)
# These calls are idempotent, but must be called on each role as
# new references may have been added.
template_seed.update_role_resource_references(
deployment_plan.master_template,
seed_role,
db_role.name)
template_seed.update_role_property_references(
deployment_plan.master_template,
seed_role,
role_namespace)
# Update environment file to add top level mappings, which is made
# up of all non-role files present in the resource registry, plus
# required aliases
reg_mapping = self.registry_mapping_store.list()
environment = deployment_plan.environment
for entry in parsed_registry_env.registry_entries:
# check if registry_mapping is in database, if so add to
# environment (later will become environment.yaml)
if any(x.name == entry.filename for x in reg_mapping):
additem = RegistryEntry(entry.alias, entry.filename)
environment.add_registry_entry(additem, unique=True)
# Save the updated plan.
updated = self._save_updated_plan(plan_uuid, deployment_plan)
return updated
def test_role_template_filename_with_relative_path(self):
filename = name_utils.role_template_filename('r1', 'v1', 'l1')
self.assertEqual('l1/provider-r1-v1.yaml', filename)
def test_role_template_filename(self):
filename = name_utils.role_template_filename('r1', 'v1', None)
self.assertEqual('provider-r1-v1.yaml', filename)
def test_role_template_filename(self):
filename = name_utils.role_template_filename('r1', 'v1')
self.assertEqual('provider-r1-v1.yaml', filename)
def add_role_to_plan(self, plan_uuid, role_uuid):
"""Adds a role to the given plan, storing the changes in Tuskar's
storage.
:type plan_uuid: str
:type role_uuid: str
:return: updated plan model instance
:rtype: tuskar.manager.models.DeploymentPlan
:raises tuskar.storage.exceptions.UnknownUUID: if either the plan
or the role cannot be found
"""
# Load the plan and role from storage
db_plan = self.plan_store.retrieve(plan_uuid)
db_role = self.template_store.retrieve(role_uuid)
# Parse the plan and role template into template objects.
deployment_plan = self._plan_to_template_object(db_plan)
role_template = self._role_to_template_object(db_role)
# See if a master seed template has been set.
try:
db_master_seed = self.seed_store.retrieve_by_name(MASTER_SEED_NAME)
master_seed = parser.parse_template(db_master_seed.contents)
except UnknownName:
master_seed = None
special_properties = None
if master_seed is not None:
try:
db_registry_env = self.registry_store.retrieve_by_name(
RESOURCE_REGISTRY_NAME).contents
except UnknownName:
LOG.error("Could not load resource_registry. Make sure you "
"pass --resource-registry to tuskar-load-roles.")
raise
parsed_registry_env = parser.parse_environment(db_registry_env)
registry = dict((role_name_from_path(e.filename), e.alias)
for e in parsed_registry_env.registry_entries)
special_properties = template_seed.get_property_map_for_role(
master_seed, registry[db_role.name])
# Use the combination logic to perform the addition.
role_namespace = name_utils.generate_role_namespace(db_role.name,
db_role.version)
template_filename = name_utils.role_template_filename(db_role.name,
db_role.version)
deployment_plan.add_template(role_namespace, role_template,
template_filename,
override_properties=special_properties)
# If there is a master seed, add its top-level elements to the plan.
# These calls are idempotent, so it's safe to call each time a role
# is added.
if master_seed is not None:
template_seed.add_top_level_parameters(
master_seed,
deployment_plan.master_template,
deployment_plan.environment)
template_seed.add_top_level_resources(
master_seed, deployment_plan.master_template)
template_seed.add_top_level_outputs(
master_seed, deployment_plan.master_template)
try:
role_type = registry[db_role.name]
except KeyError:
LOG.error(
"Role '%s' not found in seed template." % db_role.name)
raise
seed_role = template_seed.find_role_from_type(
master_seed.resources, role_type)
if seed_role is None:
LOG.error(
"Role '%s' of type '%s' not found in seed template." %
(db_role.name, role_type))
raise ValueError(db_role.name)
# These calls are idempotent, but must be called on each role as
# new references may have been added.
template_seed.update_role_resource_references(
deployment_plan.master_template,
seed_role,
plan.generate_group_id(role_namespace))
template_seed.update_role_property_references(
deployment_plan.master_template,
seed_role,
role_namespace)
# Save the updated plan.
updated = self._save_updated_plan(plan_uuid, deployment_plan)
return updated
def package_templates(self, plan_uuid):
"""Packages and returns all of the templates related to the given plan.
The returned dictionary is keyed by filename and contains the contents
of that file (a template or an environment file).
:type plan_uuid: str
:return: mapping of filename to contents for each file in the plan
:rtype: dict
:raises tuskar.storage.exceptions.UnknownUUID: if there is no plan
with the given UUID
"""
# Load and parse the plan.
db_plan = self.plan_store.retrieve(plan_uuid)
master_template = parser.parse_template(
db_plan.master_template.contents)
environment = parser.parse_environment(
db_plan.environment_file.contents)
# Compose the plan files and all plan roles and package them into
# a single dictionary.
plan_contents = composer.compose_template(master_template)
env_contents = composer.compose_environment(environment)
files_dict = {
'plan.yaml': plan_contents,
'environment.yaml': env_contents,
}
plan_roles = self._find_roles(environment)
manager = RoleManager()
for role in plan_roles:
contents = composer.compose_template(role.template)
filename = name_utils.role_template_filename(
role.name, role.version, role.relative_path)
files_dict[filename] = contents
def _add_template_extra_data_for(templates, template_store):
template_extra_data = manager.retrieve_db_role_extra()
for template in templates:
db_template = template_store.retrieve_by_name(template.name)
prefix = os_path.split(db_template.name)[0]
template_extra_paths = utils.resolve_template_extra_data(
db_template, template_extra_data)
extra_data_output = manager.template_extra_data_for_output(
template_extra_paths, prefix)
files_dict.update(extra_data_output)
# also grab any extradata files for the role
_add_template_extra_data_for(plan_roles, self.template_store)
# in addition to provider roles above, return non-role template files
reg_mapping = self.registry_mapping_store.list()
for entry in reg_mapping:
if os_path.splitext(entry.name)[1] in ('.yaml', '.yml'):
# if entry is an alias, don't include it
files_dict[entry.name] = entry.contents
# similarly, also grab extradata files for the non role templates
_add_template_extra_data_for(reg_mapping, self.registry_mapping_store)
return files_dict
def add_role_to_plan(self, plan_uuid, role_uuid):
"""Adds a role to the given plan, storing the changes in Tuskar's
storage.
:type plan_uuid: str
:type role_uuid: str
:return: updated plan model instance
:rtype: tuskar.manager.models.DeploymentPlan
:raises tuskar.storage.exceptions.UnknownUUID: if either the plan
or the role cannot be found
"""
# Load the plan and role from storage
db_plan = self.plan_store.retrieve(plan_uuid)
db_role = self.template_store.retrieve(role_uuid)
# Parse the plan and role template into template objects.
deployment_plan = self._plan_to_template_object(db_plan)
role_template = self._role_to_template_object(db_role)
# See if a master seed template has been set.
try:
db_master_seed = self.seed_store.retrieve_by_name(MASTER_SEED_NAME)
master_seed = parser.parse_template(db_master_seed.contents)
except UnknownName:
master_seed = None
special_properties = None
def _find_role_type(registry):
for path in registry.keys():
if path in db_role.registry_path:
return registry[path]
if master_seed is not None:
try:
db_registry_env = self.registry_store.retrieve_by_name(
RESOURCE_REGISTRY_NAME).contents
except UnknownName:
LOG.error("Could not load resource_registry. Make sure you "
"pass --resource-registry to tuskar-load-roles.")
raise
parsed_registry_env = parser.parse_environment(db_registry_env)
registry = dict((e.filename, e.alias)
for e in parsed_registry_env.registry_entries)
role_type = _find_role_type(registry)
special_properties = template_seed.get_property_map_for_role(
master_seed, role_type)
# Use the combination logic to perform the addition.
role_namespace = name_utils.generate_role_namespace(
db_role.name, db_role.version)
template_filename = (name_utils.role_template_filename(
db_role.name, db_role.version, db_role.relative_path))
deployment_plan.add_template(role_namespace,
role_template,
template_filename,
override_properties=special_properties)
# If there is a master seed, add its top-level elements to the plan.
# These calls are idempotent, so it's safe to call each time a role
# is added.
if master_seed is not None:
template_seed.add_top_level_parameters(
master_seed, deployment_plan.master_template,
deployment_plan.environment)
template_seed.add_top_level_resources(
master_seed, deployment_plan.master_template)
template_seed.add_top_level_outputs(
master_seed, deployment_plan.master_template)
if role_type is None:
LOG.error("Role '%s' not found in seed template." %
db_role.name)
raise ValueError(db_role.name)
seed_role = template_seed.find_role_from_type(
master_seed.resources, role_type)
if seed_role is None:
LOG.error(
"Role '%s' of type '%s' not found in seed template." %
(db_role.name, role_type))
raise ValueError(db_role.name)
# These calls are idempotent, but must be called on each role as
# new references may have been added.
template_seed.update_role_resource_references(
deployment_plan.master_template, seed_role, db_role.name)
template_seed.update_role_property_references(
deployment_plan.master_template, seed_role, role_namespace)
# Update environment file to add top level mappings, which is made
# up of all non-role files present in the resource registry, plus
# required aliases
reg_mapping = self.registry_mapping_store.list()
environment = deployment_plan.environment
for entry in parsed_registry_env.registry_entries:
# check if registry_mapping is in database, if so add to
# environment (later will become environment.yaml)
if any(x.name == entry.filename for x in reg_mapping):
additem = RegistryEntry(entry.alias, entry.filename)
environment.add_registry_entry(additem, unique=True)
# Save the updated plan.
updated = self._save_updated_plan(plan_uuid, deployment_plan)
return updated
def test_role_template_filename_with_relative_path(self):
filename = name_utils.role_template_filename('r1', 'v1', 'l1')
self.assertEqual('l1/provider-r1-v1.yaml', filename)