def test_positive_update_template(self):
"""Create an operating system that points at provisioning template and
then update it to point to another template
:id: 02125a7a-905a-492a-a49b-768adf4ac00c
:expectedresults: The operating system is updated and points at the
expected provisioning template.
:CaseLevel: Integration
"""
template_1 = entities.ProvisioningTemplate(
organization=[self.org]).create()
template_2 = entities.ProvisioningTemplate(
organization=[self.org]).create()
os = entities.OperatingSystem(
provisioning_template=[template_1]).create()
self.assertEqual(len(os.provisioning_template), 1)
self.assertEqual(os.provisioning_template[0].id, template_1.id)
os = entities.OperatingSystem(id=os.id,
provisioning_template=[
template_2
]).update(['provisioning_template'])
self.assertEqual(len(os.provisioning_template), 1)
self.assertEqual(os.provisioning_template[0].id, template_2.id)
def module_provisioningtemplate_pxe(module_org, module_location):
pxe_template = entities.ProvisioningTemplate().search(
query={'search': f'name="{DEFAULT_PXE_TEMPLATE}"'})
pxe_template = pxe_template[0].read()
pxe_template.organization.append(module_org)
pxe_template.location.append(module_location)
pxe_template.update(['organization', 'location'])
pxe_template = entities.ProvisioningTemplate(id=pxe_template.id).read()
return pxe_template
def module_provisioningtemplate_default(module_org, module_location):
provisioning_template = entities.ProvisioningTemplate().search(
query={'search': 'name="{0}"'.format(DEFAULT_TEMPLATE)})
provisioning_template = provisioning_template[0].read()
provisioning_template.organization.append(module_org)
provisioning_template.location.append(module_location)
provisioning_template.update(['organization', 'location'])
provisioning_template = entities.ProvisioningTemplate(
id=provisioning_template.id).read()
return provisioning_template
def test_positive_update_template(self):
"""Add and Remove config template.
:id: 67bec745-5f10-494c-92a7-173ee63e8297
:expectedresults: Config Template is added and then removed.
:CaseLevel: Integration
"""
with Session(self.browser) as session:
org_name = gen_string('alpha')
make_org(session, org_name=org_name)
for template_name in generate_strings_list():
with self.subTest(template_name):
# Create config template using nailgun
template = entities.ProvisioningTemplate(
name=template_name).create()
self.assertEqual(template.name, template_name)
kwargs = {
'org_name': org_name,
'entity_type': 'templates',
'entity_name': template_name
}
self.assertIsNotNone(self.org.add_entity(**kwargs))
self.assertIsNotNone(self.org.remove_entity(**kwargs))
def test_positive_update_template(session, module_org):
"""Update operating system with new provisioning template value
:id: 0b90eb24-8fc9-4e42-8709-6eee8ffbbdb5
:expectedresults: OS is updated with new template
:CaseLevel: Integration
"""
name = gen_string('alpha')
major_version = gen_string('numeric', 2)
os = entities.OperatingSystem(name=name,
major=major_version,
family='Redhat').create()
template = entities.ProvisioningTemplate(
organization=[module_org],
snippet=False,
template_kind=entities.TemplateKind().search(
query={'search': 'name="provision"'})[0],
operatingsystem=[os],
).create()
with session:
os_full_name = '{} {}'.format(name, major_version)
values = session.operatingsystem.read(os_full_name)
assert values['templates']['resources'][
'Provisioning template'] == DEFAULT_TEMPLATE
session.operatingsystem.update(
os_full_name,
{'templates.resources': {
'Provisioning template': template.name
}})
values = session.operatingsystem.read(os_full_name)
assert values['templates']['resources'][
'Provisioning template'] == template.name
def function_template_combination(module_hostgroup_and_environment):
"""Create ProvisioningTemplate and TemplateConfiguration for each test
and at the end delete ProvisioningTemplate used on tests
"""
template = entities.ProvisioningTemplate(
snippet=False,
template_combinations=[{
'hostgroup_id':
module_hostgroup_and_environment['hostgroup'].id,
'environment_id':
module_hostgroup_and_environment['env'].id,
}],
)
template = template.create()
template_combination_dct = template.template_combinations[0]
template_combination = entities.TemplateCombination(
id=template_combination_dct['id'],
environment=module_hostgroup_and_environment['env'],
provisioning_template=template,
hostgroup=module_hostgroup_and_environment['hostgroup'],
)
yield {'template': template, 'template_combination': template_combination}
# Clean combination if it is not already deleted
try:
template_combination.delete()
except HTTPError:
pass
template.delete()
def test_positive_update_template(session):
"""Add/Remove template from/to location
:id: 8faf60d1-f4d6-4a58-a484-606a42957ce7
:expectedresults: config template is removed and then added to the location
:CaseLevel: Integration
"""
template = entities.ProvisioningTemplate().create()
loc = entities.Location().create()
with session:
session.location.update(
loc.name, {
'provisioning_templates.all_templates': False,
'provisioning_templates.resources.unassigned': [template.name]
})
loc_values = session.location.read(loc.name)
assert loc_values['provisioning_templates']['resources']['unassigned'][
0] == template.name
session.location.update(
loc.name,
{'provisioning_templates.resources.assigned': [template.name]})
new_loc_values = session.location.read(loc.name)
assert len(new_loc_values[
'provisioning_templates']['resources']['assigned']) == \
len(loc_values[
'provisioning_templates']['resources']['assigned']) + 1
assert template.name in new_loc_values['provisioning_templates'][
'resources']['assigned']
def test_positive_update_template(session):
"""Add and remove provisioning template from/to organization.
:id: 67bec745-5f10-494c-92a7-173ee63e8297
:expectedresults: Provisioning Template is added and then removed.
:CaseLevel: Integration
"""
template = entities.ProvisioningTemplate().create()
org = entities.Organization().create()
with session:
session.organization.update(
org.name,
{'provisioning_templates.resources.assigned': [template.name]}
)
org_values = session.organization.read(org.name)
assert template.name in org_values[
'provisioning_templates']['resources']['assigned']
session.organization.update(
org.name,
{'provisioning_templates.resources.unassigned': [template.name]}
)
org_values = session.organization.read(org.name)
assert template.name in org_values[
'provisioning_templates']['resources']['unassigned']
def test_positive_build_pxe_default(self, tftpboot):
"""Call the "build_pxe_default" path.
:id: ca19d9da-1049-4b39-823b-933fc1a0cebd
:expectedresults: The response is a JSON payload, all templates are deployed to TFTP/HTTP
and are rendered correctly
:CaseLevel: Integration
:CaseImportance: Critical
:BZ: 1202564
"""
response = client.post(
entities.ProvisioningTemplate().path('build_pxe_default'),
auth=settings.server.get_credentials(),
verify=False,
)
response.raise_for_status()
assert type(response.json()) == dict
for template in tftpboot.values():
if template['path'].startswith('http'):
r = client.get(template['path'], verify=False)
r.raise_for_status()
rendered = r.text
else:
rendered = ssh.command(f"cat {template['path']}").stdout[0]
assert (rendered == f"{settings.server.scheme}://"
f"{settings.server.hostname} {template['kind']}")
def test_positive_clone(session, clone_setup):
"""Assure ability to clone a provisioning template
:id: 912f1619-4bb0-4e0f-88ce-88b5726fdbe0
:Steps:
1. Go to Provisioning template UI
2. Choose a template and attempt to clone it
:expectedresults: The template is cloned
:CaseLevel: Integration
"""
clone_name = gen_string('alpha')
with session:
session.provisioningtemplate.clone(
clone_setup['pt'].name,
{
'template.name': clone_name,
'association.applicable_os.assigned': clone_setup['os_list'],
},
)
pt = entities.ProvisioningTemplate().search(
query={'search': 'name=={0}'.format(clone_name)})
assigned_oses = [os.read() for os in pt[0].read().operatingsystem]
assert pt, (
'Template {0} expected to exist but is not included in the search'
'results'.format(clone_name))
assert set(clone_setup['os_list']) == set(
'{0} {1}'.format(os.name, os.major) for os in assigned_oses)
def test_positive_update_with_manager_role(self):
"""Create template providing the initial name, then update its name
with manager user role.
:id: 463790a2-c384-4851-99d2-78777762b6df
:expectedresults: Provisioning Template is created, and its name can
be updated.
:CaseImportance: Critical
:BZ: 1277308
"""
new_name = gen_string('alpha')
user_login = gen_string('alpha')
user_password = gen_string('alpha')
template = entities.ProvisioningTemplate(
organization=[self.organization], location=[self.loc]).create()
# Create user with Manager role
role = entities.Role().search(query={'search': 'name="Manager"'})[0]
entities.User(
role=[role],
admin=False,
login=user_login,
password=user_password,
organization=[self.organization],
default_organization=self.organization,
location=[self.loc],
).create()
with Session(self, user=user_login, password=user_password):
self.template.update(name=template.name, new_name=new_name)
self.assertIsNotNone(self.template.search(new_name))
def provisioning_env(module_org, module_loc):
# Build PXE default template to get default PXE file
entities.ProvisioningTemplate().build_pxe_default()
return configure_provisioning(
org=module_org,
loc=module_loc,
os='Redhat {0}'.format(RHELRepository().repo_data['version']),
)
def provisioning_env(discovery_org, discovery_location):
# Build PXE default template to get default PXE file
entities.ProvisioningTemplate().build_pxe_default()
return configure_provisioning(
org=discovery_org,
loc=discovery_location,
os='Redhat {}'.format(RHELRepository().repo_data['version']),
)
def test_positive_import_force_locked_template(
self, module_org, create_import_export_local_dir):
"""Assure locked templates are updated from repository when `force` is
specified.
:id: b80fbfc4-bcab-4a5d-b6c1-0e22906cd8ab
:Steps:
1. Import some of the locked template specifying the `force`
parameter `false`.
2. After ensuring the template is not updated, Import same locked template
specifying the `force` parameter `true`.
:expectedresults:
1. Assert result is {'message': 'success'}
2. With force - false, assert that locked template is not updated.
3. With force - true, assert that the locked template is updated.
:CaseImportance: Medium
:CaseAutomation: NotAutomated
"""
prefix = gen_string('alpha')
_, dir_path = create_import_export_local_dir
TemplateSync.imports({
'repo': dir_path,
'prefix': prefix,
'organization-ids': module_org.id,
'lock': 'true'
})
ptemplate = entities.ProvisioningTemplate().search(
query={
'per_page': 10,
'search': f'name~{prefix}',
'organization_id': module_org.id
})
if ptemplate:
assert ptemplate[0].read().locked
update_txt = 'updated a little'
ssh.command(
f"echo {update_txt} >> {dir_path}/example_template.erb")
TemplateSync.imports({
'repo': dir_path,
'prefix': prefix,
'organization-id': module_org.id
})
assert update_txt not in Template.dump(
{'name': f'{prefix}example template'})
TemplateSync.imports({
'repo': dir_path,
'prefix': prefix,
'organization-id': module_org.id,
'force': 'true',
})
assert update_txt in Template.dump(
{'name': f'{prefix}example template'})
else:
pytest.fail('The template is not imported for force test')
def test_import_filtered_templates_from_git_with_negate(self, module_org):
"""Assure templates with a given filter regex are NOT pulled from
git repo.
:id: a6857454-249b-4a2e-9b53-b5d7b4eb34e3
:Steps:
1. Using nailgun or direct API call
import the templates NOT matching with regex e.g: `^freebsd.*`
refer to: `/apidoc/v2/template/import.html` using the
{'negate': true} in POST body to negate the filter regex.
:expectedresults:
1. Assert result is {'message': 'success'}
2. Assert templates mathing the regex were not pulled.
:CaseImportance: Medium
"""
prefix = gen_string('alpha')
filtered_imported_templates = entities.Template().imports(
data={
'repo': FOREMAN_TEMPLATE_IMPORT_URL,
'branch': 'automation',
'filter': 'robottelo',
'organization_ids': [module_org.id],
'prefix': prefix,
'negate': True,
})
not_imported_count = [
template['imported']
for template in filtered_imported_templates['message']['templates']
].count(False)
assert not_imported_count == 9
ptemplates = entities.ProvisioningTemplate().search(
query={
'per_page': '100',
'search': 'name~jenkins',
'organization_id': module_org.id
})
assert len(ptemplates) == 6
ptables = entities.PartitionTable().search(
query={
'per_page': '100',
'search': 'name~jenkins',
'organization_id': module_org.id
})
assert len(ptables) == 1
rtemplates = entities.ReportTemplate().search(
query={
'per_page': '100',
'search': 'name~jenkins',
'organization_id': module_org.id
})
assert len(rtemplates) == 1
def make_entities(self):
"""Set up reusable entities for tests."""
return dict(
domain=entities.Domain().create(),
subnet=entities.Subnet().create(),
env=entities.Environment().create(),
host_group=entities.HostGroup().create(),
template=entities.ProvisioningTemplate().create(),
test_cr=entities.LibvirtComputeResource().create(),
new_user=entities.User().create(),
)
def setUpClass(cls):
"""Set up reusable entities for tests."""
super(LocationTestCase, cls).setUpClass()
cls.org = entities.Organization().create()
cls.org2 = entities.Organization().create()
cls.domain = entities.Domain().create()
cls.subnet = entities.Subnet().create()
cls.env = entities.Environment().create()
cls.host_group = entities.HostGroup().create()
cls.template = entities.ProvisioningTemplate().create()
cls.test_cr = entities.LibvirtComputeResource().create()
cls.new_user = entities.User().create()
def test_positive_delete_by_type(self):
"""Delete some entities of different types and check audit logs for
these events using entity type and performed action as search criteria
:id: 69dcd846-5cef-457f-ae75-c1cf76071d00
:expectedresults: Audit logs contain corresponding entries per each
delete event
"""
with Session(self):
for entity_item in [
{
'entity': entities.Architecture(),
'entity_type': 'architecture'
},
{
'entity': entities.Domain(),
'entity_type': 'domain'
},
{
'entity': entities.HostGroup(),
'entity_type': 'hostgroup'
},
{
'entity': entities.Location(),
'entity_type': 'location'
},
{
'entity': entities.PartitionTable(),
'entity_type': 'ptable',
},
{
'entity': entities.Role(),
'entity_type': 'role'
},
{
'entity': entities.ProvisioningTemplate(),
'entity_type': 'template',
},
{
'entity': entities.UserGroup(),
'entity_type': 'usergroup'
},
]:
entity = entity_item['entity'].create()
entity.delete()
self.audit.filter('type={} and action=delete'.format(
entity_item['entity_type']))
result = self.audit.get_last_entry()
self.assertIn('destroyed', result['full_statement'])
self.assertEqual(result['entity_name'], entity.name)
def test_positive_create_with_template(self, module_org):
"""Create an operating system that points at a provisioning template.
:id: df73ecba-5a1c-4201-9c2f-b2e03e8fec25
:expectedresults: The operating system is created and points at the
expected provisioning template.
:CaseLevel: Integration
"""
template = entities.ProvisioningTemplate(organization=[module_org]).create()
operating_sys = entities.OperatingSystem(provisioning_template=[template]).create()
assert len(operating_sys.provisioning_template) == 1
assert operating_sys.provisioning_template[0].id == template.id
def clone_setup(module_org, module_loc):
name = gen_string('alpha')
content = gen_string('alpha')
os_list = [entities.OperatingSystem().create().title for _ in range(2)]
return {
'pt': entities.ProvisioningTemplate(
name=name,
organization=[module_org],
location=[module_loc],
template=content,
snippet=False,
).create(),
'os_list': os_list,
}
def test_positive_update_with_manager_role(self):
"""Create template providing the initial name, then update its name
with manager user role.
:id: 0aed79f0-7c9a-4789-99ba-56f2db82f097
:expectedresults: Provisioning Template is created, and its name can
be updated.
:CaseImportance: Critical
:BZ: 1277308
"""
user_login = gen_string('alpha')
user_password = gen_string('alpha')
new_name = gen_string('alpha')
org = entities.Organization().create()
loc = entities.Location().create()
template = entities.ProvisioningTemplate(organization=[org],
location=[loc]).create()
# Create user with Manager role
role = entities.Role().search(query={'search': 'name="Manager"'})[0]
entities.User(
role=[role],
admin=False,
login=user_login,
password=user_password,
organization=[org],
location=[loc],
).create()
# Update template name with that user
cfg = get_nailgun_config()
cfg.auth = (user_login, user_password)
updated = entities.ProvisioningTemplate(cfg,
id=template.id,
name=new_name).update(['name'])
self.assertEqual(updated.name, new_name)
def test_positive_import_locked_template(self, module_org):
"""Assure locked templates are pulled from repository while using force parameter.
:id: 936c91cc-1947-45b0-8bf0-79ba4be87b97
:Steps:
1. Using nailgun try to import a locked template with force parameter
:expectedresults:
1. Assert locked template is updated
:CaseImportance: Medium
"""
# import template with lock
output = entities.Template().imports(
data={
'repo': FOREMAN_TEMPLATE_IMPORT_URL,
'branch': 'locked',
'organization_ids': [module_org.id],
'dirname': 'locked',
'force': True,
'lock': True,
}
)
assert output['message']['templates'][0]['imported']
# force import same template with changed content
output = entities.Template().imports(
data={
'repo': FOREMAN_TEMPLATE_IMPORT_URL,
'branch': 'locked',
'organization_ids': [module_org.id],
'dirname': 'after_lock',
'force': True,
}
)
# assert template was changed
assert output['message']['templates'][0]['imported']
assert output['message']['templates'][0]['changed']
res = requests.get(
url=f"{FOREMAN_TEMPLATE_IMPORT_API_URL}/contents/after_lock/robottelo_locked.erb",
headers={'Authorization': f'token {settings.git.github_token}'},
params={'ref': 'locked'},
)
res.raise_for_status()
git_content = base64.b64decode(json.loads(res.text)['content'])
sat_content = entities.ProvisioningTemplate(
id=output['message']['templates'][0]['id']
).read()
assert git_content.decode('utf-8') == sat_content.template
def test_positive_create_with_template_kind(self):
"""Create a provisioning template providing the template_kind.
:id: d7309be8-b5c9-4f77-8c4e-e9f2b8982076
:expectedresults: Provisioning Template is created and contains
provided template kind.
:CaseImportance: Critical
"""
template_kind = choice(entities.TemplateKind().search())
template = entities.ProvisioningTemplate(
snippet=False, template_kind=template_kind,
).create()
self.assertEqual(template.template_kind.id, template_kind.id)
def setUpClass(cls):
"""Set up reusable entities for tests."""
super().setUpClass()
cls.subnet = entities.Subnet().create()
cls.env = entities.Environment().create()
cls.env2 = entities.Environment().create()
cls.domain = entities.Domain().create()
cls.domain2 = entities.Domain().create()
cls.medium = make_medium()
cls.host_group = entities.HostGroup().create()
cls.host_group2 = entities.HostGroup().create()
cls.host_group3 = entities.HostGroup().create()
cls.comp_resource = entities.LibvirtComputeResource().create()
cls.template = entities.ProvisioningTemplate().create()
cls.user = entities.User().create()
def setUpClass(cls):
"""Steps to Configure foreman discovery
1. Build PXE default template
2. Create Organization/Location
3. Update Global parameters to set default org and location for
discovered hosts.
4. Enable auto_provision flag to perform discovery via discovery
rules.
"""
super().setUpClass()
# Build PXE default template to get default PXE file
entities.ProvisioningTemplate().build_pxe_default()
# let's just modify the timeouts to speed things up
ssh.command("sed -ie 's/TIMEOUT [[:digit:]]\\+/TIMEOUT 1/g' "
"/var/lib/tftpboot/pxelinux.cfg/default")
ssh.command(
"sed -ie '/APPEND initrd/s/$/ fdi.countdown=1 fdi.ssh=1 fdi.rootpw=changeme/' "
"/var/lib/tftpboot/pxelinux.cfg/default")
# Create Org and location
cls.org = entities.Organization().create()
cls.loc = entities.Location().create()
# Get default settings values
cls.default_disco_settings = {
i.name: i
for i in entities.Setting().search(
query={'search': 'name~discovery'})
}
# Update discovery taxonomies settings
cls.discovery_loc = copy(
cls.default_disco_settings['discovery_location'])
cls.discovery_loc.value = cls.loc.name
cls.discovery_loc.update(['value'])
cls.discovery_org = copy(
cls.default_disco_settings['discovery_organization'])
cls.discovery_org.value = cls.org.name
cls.discovery_org.update(['value'])
# Enable flag to auto provision discovered hosts via discovery rules
cls.discovery_auto = copy(cls.default_disco_settings['discovery_auto'])
cls.discovery_auto.value = 'true'
cls.discovery_auto.update(['value'])
# Flag which shows whether environment is fully configured for
# discovered host provisioning.
cls.configured_env = False
def test_negative_import_locked_template(self, module_org):
"""Assure locked templates are not pulled from repository.
:id: 88e21cad-448e-45e0-add2-94493a1319c5
:Steps:
1. Using nailgun try to import a locked template
:expectedresults:
1. Assert locked template is not updated
:CaseImportance: Medium
"""
# import template with lock
output = entities.Template().imports(
data={
'repo': FOREMAN_TEMPLATE_IMPORT_URL,
'branch': 'locked',
'organization_ids': [module_org.id],
'dirname': 'locked',
'force': True,
'lock': True,
}
)
assert output['message']['templates'][0]['imported']
# try to import same template with changed content
output = entities.Template().imports(
data={
'repo': FOREMAN_TEMPLATE_IMPORT_URL,
'branch': 'locked',
'organization_ids': [module_org.id],
'dirname': 'after_lock',
}
)
# assert content wasn't changed
assert not output['message']['templates'][0]['imported']
res = requests.get(
url=f"{FOREMAN_TEMPLATE_IMPORT_API_URL}/contents/locked/robottelo_locked.erb",
headers={'Authorization': f'token {settings.git.github_token}'},
params={'ref': 'locked'},
)
res.raise_for_status()
git_content = base64.b64decode(json.loads(res.text)['content'])
sat_content = entities.ProvisioningTemplate(
id=output['message']['templates'][0]['id']
).read()
assert git_content.decode('utf-8') == sat_content.template
def test_positive_add_org_hostgroup_template(session):
"""Add a organization, hostgroup, provisioning template by using
the location name
:id: 27d56d64-6866-46b6-962d-1ac2a11ae136
:expectedresults: organization, hostgroup, provisioning template are
added to location
:CaseLevel: Integration
"""
org = entities.Organization().create()
loc = entities.Location().create()
hostgroup = entities.HostGroup().create()
template = entities.ProvisioningTemplate().create()
with session:
session.location.update(
loc.name,
{
'organizations.resources.assigned': [org.name],
'host_groups.all_hostgroups': False,
'host_groups.resources.unassigned': [hostgroup.name],
'provisioning_templates.all_templates': False,
'provisioning_templates.resources.unassigned': [template.name],
},
)
loc_values = session.location.read(loc.name)
assert loc_values['organizations']['resources']['assigned'][
0] == org.name
assert hostgroup.name in loc_values['host_groups']['resources'][
'unassigned']
assert template.name in loc_values['provisioning_templates'][
'resources']['unassigned']
session.location.update(
loc.name,
{
'host_groups.resources.assigned': [hostgroup.name],
'provisioning_templates.resources.assigned': [template.name],
},
)
loc_values = session.location.read(loc.name)
assert hostgroup.name in loc_values['host_groups']['resources'][
'assigned']
assert template.name in loc_values['provisioning_templates'][
'resources']['assigned']
def setUp(self):
"""Create ProvisioningTemplate and TemplateConfiguration for each test"""
super(TemplateCombinationTestCase, self).setUp()
self.template = entities.ProvisioningTemplate(
snippet=False,
template_combinations=[{
'hostgroup_id': self.hostgroup.id,
'environment_id': self.env.id
}],
)
self.template = self.template.create()
template_combination_dct = self.template.template_combinations[0]
self.template_combination = entities.TemplateCombination(
id=template_combination_dct['id'],
environment=self.env,
provisioning_template=self.template,
hostgroup=self.hostgroup,
)
def test_positive_create_with_template_kind_name(self):
"""Create a provisioning template providing existing
template_kind name.
:id: 4a1410e4-aa3c-4d27-b062-089e34722bd9
:expectedresults: Provisioning Template is created
:BZ: 1379006
:CaseImportance: Critical
"""
template_kind = choice(entities.TemplateKind().search())
template = entities.ProvisioningTemplate(snippet=False)
template.create_missing()
template.template_kind = None
template.template_kind_name = template_kind.name
template = template.create(create_missing=False)
self.assertEqual(template.template_kind.id, template_kind.id)
def discovery_settings(module_org, module_location):
"""Steps to Configure foreman discovery
1. Build PXE default template
2. Create Organization/Location
3. Update Global parameters to set default org and location for
discovered hosts.
4. Enable auto_provision flag to perform discovery via discovery
rules.
"""
# Build PXE default template to get default PXE file
entities.ProvisioningTemplate().build_pxe_default()
# let's just modify the timeouts to speed things up
ssh.command("sed -ie 's/TIMEOUT [[:digit:]]\\+/TIMEOUT 1/g' "
"/var/lib/tftpboot/pxelinux.cfg/default")
ssh.command(
"sed -ie '/APPEND initrd/s/$/ fdi.countdown=1 fdi.ssh=1 fdi.rootpw=changeme/' "
"/var/lib/tftpboot/pxelinux.cfg/default")
# Get default settings values
default_disco_settings = {
i.name: i
for i in entities.Setting().search(query={'search': 'name~discovery'})
}
# Update discovery taxonomies settings
discovery_loc = copy(default_disco_settings['discovery_location'])
discovery_loc.value = module_location.name
discovery_loc.update(['value'])
discovery_org = copy(default_disco_settings['discovery_organization'])
discovery_org.value = module_org.name
discovery_org.update(['value'])
# Enable flag to auto provision discovered hosts via discovery rules
discovery_auto = copy(default_disco_settings['discovery_auto'])
discovery_auto.value = 'true'
discovery_auto.update(['value'])
yield
# Restore default global setting's values
default_disco_settings['discovery_location'].update(['value'])
default_disco_settings['discovery_organization'].update(['value'])
default_disco_settings['discovery_auto'].update(['value'])
