def main():
module = ForemanEntityAnsibleModule(
argument_spec=dict(
operatingsystem=dict(required=True),
template_kind=dict(required=True),
provisioning_template=dict(required=False),
state=dict(default='present',
choices=['present', 'present_with_defaults', 'absent']),
),
required_if=(
['state', 'present', ['provisioning_template']],
['state', 'present_with_defaults', ['provisioning_template']],
),
supports_check_mode=True,
)
(server_params, entity_dict, state) = module.parse_params()
try:
(server_url, username, password, verify_ssl) = server_params
create_server(server_url, (username, password), verify_ssl)
except Exception as e:
module.fail_json(msg="Failed to connect to Foreman server: %s " % e)
ping_server(module)
entity_dict['operatingsystem'] = find_operating_system_by_title(
module, entity_dict['operatingsystem'])
entity_dict['template_kind'] = find_entities_by_name(
TemplateKind, [entity_dict['template_kind']], module)[0]
entity = find_os_default_template(
module,
operatingsystem=entity_dict['operatingsystem'],
template_kind=entity_dict['template_kind'],
failsafe=True,
)
# Find Provisioning Template
if 'provisioning_template' in entity_dict:
if state == 'absent':
module.fail_json(
msg='Provisioning template must not be specified for deletion.'
)
entity_dict['provisioning_template'] = find_entities_by_name(
ProvisioningTemplate, [entity_dict['provisioning_template']],
module)[0]
if entity_dict['provisioning_template'].template_kind.id != entity_dict[
'template_kind'].id:
module.fail_json(msg='Provisioning template kind mismatching.')
entity_dict = sanitize_os_default_template_dict(entity_dict)
changed = naildown_entity_state(OSDefaultTemplate, entity_dict, entity,
state, module)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
argument_spec=dict(
operatingsystem=dict(required=True),
template_kind=dict(required=True),
provisioning_template=dict(required=False),
state=dict(default='present',
choices=['present', 'present_with_defaults', 'absent']),
),
required_if=(
['state', 'present', ['provisioning_template']],
['state', 'present_with_defaults', ['provisioning_template']],
),
)
(entity_dict, state) = module.parse_params()
module.connect()
entity_dict['operatingsystem'] = find_operating_system_by_title(
module, entity_dict['operatingsystem'])
entity_dict['template_kind'] = find_entities_by_name(
TemplateKind, [entity_dict['template_kind']], module)[0]
entity = find_os_default_template(
module,
operatingsystem=entity_dict['operatingsystem'],
template_kind=entity_dict['template_kind'],
failsafe=True,
)
# Find Provisioning Template
if 'provisioning_template' in entity_dict:
if state == 'absent':
module.fail_json(
msg='Provisioning template must not be specified for deletion.'
)
entity_dict['provisioning_template'] = find_entities_by_name(
ProvisioningTemplate, [entity_dict['provisioning_template']],
module)[0]
if entity_dict['provisioning_template'].template_kind.id != entity_dict[
'template_kind'].id:
module.fail_json(msg='Provisioning template kind mismatching.')
entity_dict = sanitize_os_default_template_dict(entity_dict)
changed = naildown_entity_state(OSDefaultTemplate, entity_dict, entity,
state, module)
module.exit_json(changed=changed)
def main():
module = AnsibleModule(
argument_spec=dict(
server_url=dict(required=True),
username=dict(required=True, no_log=True),
password=dict(required=True, no_log=True),
verify_ssl=dict(type='bool', default=True),
audit_comment=dict(),
kind=dict(choices=[
'finish',
'iPXE',
'job_template',
'POAP',
'provision',
'ptable',
'PXELinux',
'PXEGrub',
'PXEGrub2',
'script',
'snippet',
'user_data',
'ZTP',
]),
template=dict(),
file_name=dict(type='path'),
locations=dict(type='list'),
locked=dict(type='bool', default=False),
name=dict(),
organizations=dict(type='list'),
operatingsystems=dict(type='list'),
state=dict(default='present', choices=['absent', 'present_with_defaults', 'present']),
),
supports_check_mode=True,
mutually_exclusive=[
['file_name', 'template'],
],
required_one_of=[
['name', 'file_name', 'template'],
],
)
# We do not want a template text for bulk operations
if module.params['name'] == '*':
if module.params['file_name'] or module.params['template']:
module.fail_json(
msg="Neither file_name nor template allowed if 'name: *'!")
handle_no_nailgun(module, HAS_NAILGUN_PACKAGE)
entity_dict = dict(
[(k, v) for (k, v) in module.params.items() if v is not None])
server_url = entity_dict.pop('server_url')
username = entity_dict.pop('username')
password = entity_dict.pop('password')
verify_ssl = entity_dict.pop('verify_ssl')
state = entity_dict.pop('state')
file_name = entity_dict.pop('file_name', None)
if file_name or 'template' in entity_dict:
if file_name:
parsed_dict = parse_template_from_file(file_name, module)
else:
parsed_dict = parse_template(entity_dict['template'], module)
# sanitize name from template data
# The following condition can actually be hit, when someone is trying to import a
# template with the name set to '*'.
# Besides not being sensible, this would go horribly wrong in this module.
if 'name' in parsed_dict and parsed_dict['name'] == '*':
module.fail_json(msg="Cannot use '*' as a template name!")
# module params are priorized
parsed_dict.update(entity_dict)
entity_dict = parsed_dict
# make sure, we have a name
if 'name' not in entity_dict:
if file_name:
entity_dict['name'] = os.path.splitext(
os.path.basename(file_name))[0]
else:
module.fail_json(
msg='No name specified and no filename to infer it.')
name = entity_dict['name']
affects_multiple = name == '*'
# sanitize user input, filter unuseful configuration combinations with 'name: *'
if affects_multiple:
if state == 'present_with_defaults':
module.fail_json(msg="'state: present_with_defaults' and 'name: *' cannot be used together")
if state == 'absent':
if entity_dict.keys() != ['name', 'locked']:
module.fail_json(msg="When deleting all templates, there is no need to specify further parameters.")
try:
create_server(server_url, (username, password), verify_ssl)
except Exception as e:
module.fail_json(msg='Failed to connect to Foreman server: %s ' % e)
ping_server(module)
try:
if affects_multiple:
entities = find_entities(ProvisioningTemplate)
else:
entities = find_entities(ProvisioningTemplate, name=entity_dict['name'])
except Exception as e:
module.fail_json(msg='Failed to search for entities: %s ' % e)
# Set Locations of Template
if 'locations' in entity_dict:
entity_dict['locations'] = find_entities_by_name(
Location, entity_dict['locations'], module)
# Set Organizations of Template
if 'organizations' in entity_dict:
entity_dict['organizations'] = find_entities_by_name(
Organization, entity_dict['organizations'], module)
if 'operatingsystems' in entity_dict:
entity_dict['operatingsystems'] = [find_operating_system_by_title(module, title)
for title in entity_dict['operatingsystems']]
if not affects_multiple:
entity_dict = find_template_kind(entity_dict, module)
entity_dict = sanitize_entity_dict(entity_dict, name_map)
changed = False
if not affects_multiple:
if len(entities) == 0:
entity = None
else:
entity = entities[0]
changed = naildown_entity_state(
ProvisioningTemplate, entity_dict, entity, state, module)
else:
entity_dict.pop('name')
for entity in entities:
changed |= naildown_entity_state(
ProvisioningTemplate, entity_dict, entity, state, module)
module.exit_json(changed=changed)
def main():
module = AnsibleModule(
argument_spec=dict(
server_url=dict(required=True),
username=dict(required=True),
password=dict(required=True, no_log=True),
verify_ssl=dict(type='bool', default=True),
operatingsystem=dict(required=True),
template_kind=dict(required=True),
provisioning_template=dict(required=False),
state=dict(default='present', choices=['present', 'present_with_defaults', 'absent']),
),
required_if=(
['state', 'present', ['provisioning_template']],
['state', 'present_with_defaults', ['provisioning_template']],
),
supports_check_mode=True,
)
if has_import_error:
module.fail_json(msg=import_error_msg)
entity_dict = dict(
[(k, v) for (k, v) in module.params.items() if v is not None])
server_url = entity_dict.pop('server_url')
username = entity_dict.pop('username')
password = entity_dict.pop('password')
verify_ssl = entity_dict.pop('verify_ssl')
state = entity_dict.pop('state')
try:
create_server(server_url, (username, password), verify_ssl)
except Exception as e:
module.fail_json(msg="Failed to connect to Foreman server: %s " % e)
ping_server(module)
entity_dict['operatingsystem'] = find_operating_system_by_title(module, entity_dict['operatingsystem'])
entity_dict['template_kind'] = find_entities_by_name(
TemplateKind, [entity_dict['template_kind']], module)[0]
entity = find_os_default_template(
module,
operatingsystem=entity_dict['operatingsystem'],
template_kind=entity_dict['template_kind'],
failsafe=True,
)
# Find Provisioning Template
if 'provisioning_template' in entity_dict:
if state == 'absent':
module.fail_json(msg='Provisioning template must not be specified for deletion.')
entity_dict['provisioning_template'] = find_entities_by_name(
ProvisioningTemplate, [entity_dict['provisioning_template']], module)[0]
if entity_dict['provisioning_template'].template_kind.id != entity_dict['template_kind'].id:
module.fail_json(msg='Provisioning template kind mismatching.')
entity_dict = sanitize_os_default_template_dict(entity_dict)
changed = naildown_entity_state(OSDefaultTemplate, entity_dict, entity, state, module)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
argument_spec=dict(
name=dict(required=True),
release_name=dict(),
description=dict(),
family=dict(),
major=dict(),
minor=dict(),
architectures=dict(type='list'),
media=dict(type='list'),
ptables=dict(type='list'),
provisioning_templates=dict(type='list'),
password_hash=dict(choices=['MD5', 'SHA256', 'SHA512']),
state=dict(default='present', choices=['present', 'present_with_defaults', 'absent']),
),
supports_check_mode=True,
)
(server_params, operating_system_dict, state) = module.parse_params()
try:
(server_url, username, password, verify_ssl) = server_params
create_server(server_url, (username, password), verify_ssl)
except Exception as e:
module.fail_json(msg="Failed to connect to Foreman server: %s " % e)
ping_server(module)
try:
# Try to find the Operating System to work on
# name is however not unique, but description is, as well as "<name> <major>[.<minor>]"
entity = None
# If we have a description, search for it
if 'description' in operating_system_dict and operating_system_dict['description'] != '':
entity = find_operating_system_by_title(module, title=operating_system_dict['description'], failsafe=True)
# If we did not yet find a unique OS, search by name & version
if entity is None:
search_dict = {'name': operating_system_dict['name']}
if 'major' in operating_system_dict:
search_dict['major'] = operating_system_dict['major']
if 'minor' in operating_system_dict:
search_dict['minor'] = operating_system_dict['minor']
entities = find_entities(OperatingSystem, **search_dict)
if len(entities) == 1:
entity = entities[0]
except Exception as e:
module.fail_json(msg='Failed to find entity: %s ' % e)
if not entity and (state == 'present' or state == 'present_with_defaults'):
# we actually attempt to create a new one...
for param_name in ['major', 'family', 'password_hash']:
if param_name not in operating_system_dict.keys():
module.fail_json(msg='{} is a required parameter to create a new operating system.'.format(param_name))
# Set Architectures of Operating System
if 'architectures' in operating_system_dict:
operating_system_dict['architectures'] = find_entities_by_name(
Architecture, operating_system_dict['architectures'], module)
# Set Installation Media of Operating System
if 'media' in operating_system_dict:
operating_system_dict['media'] = find_entities_by_name(
Media, operating_system_dict['media'], module)
# Set Partition Tables of Operating System
if 'ptables' in operating_system_dict:
operating_system_dict['ptables'] = find_entities_by_name(
PartitionTable, operating_system_dict['ptables'], module)
# Set Provisioning Templates of Operating System
if 'provisioning_templates' in operating_system_dict:
operating_system_dict['provisioning_templates'] = find_entities_by_name(
ProvisioningTemplate, operating_system_dict['provisioning_templates'], module)
operating_system_dict = sanitize_entity_dict(operating_system_dict, name_map)
changed = naildown_entity_state(OperatingSystem, operating_system_dict, entity, state, module)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
argument_spec=dict(
name=dict(required=True),
release_name=dict(),
description=dict(),
family=dict(required=True),
major=dict(required=True),
minor=dict(),
architectures=dict(type='list'),
media=dict(type='list'),
ptables=dict(type='list'),
provisioning_templates=dict(type='list'),
password_hash=dict(choices=['MD5', 'SHA256', 'SHA512']),
parameters=dict(type='dict'),
state=dict(default='present', choices=['present', 'present_with_defaults', 'absent']),
),
)
(operating_system_dict, state) = module.parse_params()
module.connect()
try:
# Try to find the Operating System to work on
# name is however not unique, but description is, as well as "<name> <major>[.<minor>]"
entity = None
# If we have a description, search for it
if 'description' in operating_system_dict and operating_system_dict['description'] != '':
entity = find_operating_system_by_title(module, title=operating_system_dict['description'], failsafe=True)
# If we did not yet find a unique OS, search by name & version
if entity is None:
search_dict = {'name': operating_system_dict['name']}
if 'major' in operating_system_dict:
search_dict['major'] = operating_system_dict['major']
if 'minor' in operating_system_dict:
search_dict['minor'] = operating_system_dict['minor']
entities = find_entities(OperatingSystem, **search_dict)
if len(entities) == 1:
entity = entities[0]
except Exception as e:
module.fail_json(msg='Failed to find entity: %s ' % e)
if not entity and (state == 'present' or state == 'present_with_defaults'):
# we actually attempt to create a new one...
for param_name in ['major', 'family', 'password_hash']:
if param_name not in operating_system_dict.keys():
module.fail_json(msg='{} is a required parameter to create a new operating system.'.format(param_name))
# Set Architectures of Operating System
if 'architectures' in operating_system_dict:
operating_system_dict['architectures'] = find_entities_by_name(
Architecture, operating_system_dict['architectures'], module)
# Set Installation Media of Operating System
if 'media' in operating_system_dict:
operating_system_dict['media'] = find_entities_by_name(
Media, operating_system_dict['media'], module)
# Set Partition Tables of Operating System
if 'ptables' in operating_system_dict:
operating_system_dict['ptables'] = find_entities_by_name(
PartitionTable, operating_system_dict['ptables'], module)
# Set Provisioning Templates of Operating System
if 'provisioning_templates' in operating_system_dict:
operating_system_dict['provisioning_templates'] = find_entities_by_name(
ProvisioningTemplate, operating_system_dict['provisioning_templates'], module)
desired_parameters = operating_system_dict.get('parameters')
operating_system_dict = sanitize_entity_dict(operating_system_dict, name_map)
changed, operating_system = naildown_entity(OperatingSystem, operating_system_dict, entity, state, module)
if desired_parameters is not None:
if state == "present" or (state == "present_with_defaults" and entity is None):
if entity:
current_parameters = OperatingSystemParameter(operatingsystem=operating_system).search()
current_parameters = {p.name: p for p in current_parameters}
else:
current_parameters = {}
desired_parameters = {name: {'name': name, 'value': value, 'operatingsystem': operating_system} for name, value in desired_parameters.items()}
for name in desired_parameters:
current_parameter = current_parameters.pop(name, None)
changed |= naildown_entity_state(OperatingSystemParameter, desired_parameters[name], current_parameter, "present", module)
for current_parameter in current_parameters.values():
changed |= naildown_entity_state(OperatingSystemParameter, {}, current_parameter, "absent", module)
module.exit_json(changed=changed)
