def main():
module = ForemanEntityAnsibleModule(
argument_spec=dict(
updated_name=dict(),
),
entity_spec=dict(
name=dict(required=True),
operatingsystems=dict(type='entity_list', flat_name='operatingsystem_ids'),
),
)
entity_dict = module.clean_params()
module.connect()
entity = module.find_resource_by_name('architectures', name=entity_dict['name'], failsafe=True)
if not module.desired_absent:
if entity and 'updated_name' in entity_dict:
entity_dict['name'] = entity_dict.pop('updated_name')
if 'operatingsystems' in entity_dict:
entity_dict['operatingsystems'] = module.find_operatingsystems(entity_dict['operatingsystems'], thin=True)
module.ensure_entity('architectures', entity_dict, entity)
module.exit_json()
def main():
module = ForemanEntityAnsibleModule(entity_spec=dict(
compute_profile=dict(required=True,
type='entity',
flat_name='compute_profile_id'),
compute_resource=dict(required=True,
type='entity',
flat_name='compute_resource_id'),
vm_attrs=dict(type='dict', aliases=['vm_attributes']),
), )
entity_dict = module.clean_params()
module.connect()
entity_dict['compute_resource'] = module.find_resource_by_name(
'compute_resources',
name=entity_dict['compute_resource'],
failsafe=False,
thin=False)
compute_attributes = entity_dict['compute_resource'].get(
'compute_attributes')
entity_dict['compute_profile'] = module.find_resource_by_name(
'compute_profiles',
name=entity_dict['compute_profile'],
failsafe=False,
thin=True)
entity = next((item for item in compute_attributes if item.get(
'compute_profile_id') == entity_dict['compute_profile']['id']), None)
module.ensure_entity('compute_attributes', entity_dict, entity)
module.exit_json()
def main():
module = ForemanEntityAnsibleModule(entity_spec=dict(
name=dict(required=True),
realm_proxy=dict(type='entity',
flat_name='realm_proxy_id',
required=True),
realm_type=dict(required=True,
choices=[
'Red Hat Identity Management', 'FreeIPA',
'Active Directory'
]),
), )
entity_dict = module.clean_params()
module.connect()
entity = module.find_resource_by_name('realms',
name=entity_dict['name'],
failsafe=True)
if not module.desired_absent:
entity_dict['realm_proxy'] = module.find_resource_by_name(
'smart_proxies', entity_dict['realm_proxy'], thin=True)
changed = module.ensure_entity_state('realms', entity_dict, entity)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(entity_spec=dict(
name=dict(aliases=['hostname'], required=True),
state=dict(default='state',
choices=[
'on', 'start', 'off', 'stop', 'soft', 'reboot', 'cycle',
'reset', 'state', 'status'
]),
), )
entity_dict = module.clean_params()
module.connect()
params = {'id': entity_dict['name']}
_power_state_changed, power_state = module.resource_action('hosts',
'power_status',
params=params)
if module.state in ['state', 'status']:
module.exit_json(changed=False, power_state=power_state['state'])
elif ((module.state in ['on', 'start'] and power_state['state'] == 'on') or
(module.state in ['off', 'stop'] and power_state['state'] == 'off')):
module.exit_json(changed=False)
else:
params['power_action'] = module.state
changed, power_state = module.resource_action('hosts',
'power',
params=params)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
entity_spec=dict(
name=dict(required=True),
locations=dict(type='entity_list', flat_name='location_ids'),
organizations=dict(type='entity_list', flat_name='organization_ids'),
),
)
entity_dict = module.clean_params()
module.connect()
entity = module.find_resource_by_name('environments', name=entity_dict['name'], failsafe=True)
if not module.desired_absent:
if 'locations' in entity_dict:
entity_dict['locations'] = module.find_resources_by_title('locations', entity_dict['locations'], thin=True)
if 'organizations' in entity_dict:
entity_dict['organizations'] = module.find_resources_by_name('organizations', entity_dict['organizations'], thin=True)
changed = module.ensure_entity_state('environments', entity_dict, entity)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
argument_spec=dict(
host=dict(required=True),
state=dict(default='present',
choices=['present', 'absent', 'reverted']),
),
entity_spec=dict(
name=dict(required=True),
description=dict(),
),
)
snapshot_dict = module.clean_params()
module.connect()
host = module.find_resource_by_name('hosts',
name=snapshot_dict['host'],
failsafe=False,
thin=True)
scope = {'host_id': host['id']}
entity = module.find_resource_by_name('snapshots',
name=snapshot_dict['name'],
params=scope,
failsafe=True)
changed = module.ensure_entity_state('snapshots',
snapshot_dict,
entity,
params=scope)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
argument_spec=dict(
name=dict(required=True),
value=dict(),
state=dict(default='present',
choices=['present_with_defaults', 'present', 'absent']),
),
required_if=(
['state', 'present_with_defaults', ['value']],
['state', 'present', ['value']],
),
)
(global_parameter_dict, state) = module.parse_params()
module.connect()
try:
entities = find_entities(CommonParameter,
name=global_parameter_dict['name'])
if len(entities) > 0:
entity = entities[0]
else:
entity = None
except Exception as e:
module.fail_json(msg='Failed to find entity: %s ' % e)
global_parameter_dict = sanitize_entity_dict(global_parameter_dict,
name_map)
changed = naildown_entity_state(CommonParameter, global_parameter_dict,
entity, state, module)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
entity_spec=dict(
name=dict(required=True),
usergroup=dict(required=True),
auth_source_ldap=dict(required=True, type='entity', flat_name='auth_source_id'),
),
)
entity_dict = module.clean_params()
module.connect()
params = {"usergroup_id": entity_dict.pop('usergroup')}
entity = None
# There is no way to find by name via API search, so we need
# to iterate over all external user groups of a given usergroup
for external_usergroup in module.list_resource("external_usergroups", params=params):
if external_usergroup['name'] == entity_dict['name']:
entity = external_usergroup
entity_dict['auth_source_ldap'] = module.find_resource_by_name('auth_sources', entity_dict['auth_source_ldap'], thin=True)
changed = module.ensure_entity_state('external_usergroups', entity_dict, entity, params)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
entity_spec=dict(
name=dict(required=True),
puppetclasses=dict(type='entity_list', flat_name='puppetclass_ids'),
),
)
entity_dict = module.clean_params()
module.connect()
entity = module.find_resource_by_name('config_groups', name=entity_dict['name'], failsafe=True)
if not module.desired_absent:
if 'puppetclasses' in entity_dict:
# puppet classes API return puppet classes grouped by puppet module name
puppet_classes = []
for puppet_class in entity_dict['puppetclasses']:
search = 'name="{0}"'.format(puppet_class)
results = module.list_resource('puppetclasses', search)
# verify that only one puppet module is returned with only one puppet class inside
# as provided search results have to be like "results": { "ntp": [{"id": 1, "name": "ntp" ...}]}
# and get the puppet class id
if len(results) == 1 and len(list(results.values())[0]) == 1:
puppet_classes.append({'id': list(results.values())[0][0]['id']})
else:
module.fail_json(msg='No data found for name="%s"' % search)
entity_dict['puppetclasses'] = puppet_classes
changed = module.ensure_entity_state('config_groups', entity_dict, entity)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
entity_spec=dict(
name=dict(required=True),
controller=dict(required=True),
public=dict(default='true', type='bool'),
query=dict(),
),
argument_spec=dict(state=dict(
default='present',
choices=['present_with_defaults', 'present', 'absent']), ),
required_if=(
['state', 'present', ['query']],
['state', 'present_with_defaults', ['query']],
),
)
entity_dict = module.clean_params()
module.connect()
search = 'name="{0}",controller="{1}"'.format(entity_dict['name'],
entity_dict['controller'])
entity = module.find_resource('bookmarks', search, failsafe=True)
module.ensure_entity('bookmarks', entity_dict, entity)
module.exit_json()
def main():
module = ForemanEntityAnsibleModule(
entity_spec=dict(
name=dict(required=True),
locations=dict(type='entity_list', flat_name='location_ids'),
organizations=dict(type='entity_list', flat_name='organization_ids'),
operatingsystems=dict(type='entity_list', flat_name='operatingsystem_ids'),
os_family=dict(choices=['AIX', 'Altlinux', 'Archlinux', 'Coreos', 'Debian', 'Freebsd', 'Gentoo', 'Junos', 'NXOS',
'Rancheros', 'Redhat', 'Solaris', 'Suse', 'VRP', 'Windows', 'Xenserver']),
path=dict(),
),
)
entity_dict = module.clean_params()
module.connect()
name = entity_dict['name']
affects_multiple = name == '*'
# sanitize user input, filter unuseful configuration combinations with 'name: *'
if affects_multiple:
if module.state == 'present_with_defaults':
module.fail_json(msg="'state: present_with_defaults' and 'name: *' cannot be used together")
if module.desired_absent:
if list(entity_dict.keys()) != ['name']:
entity_dict.pop('name', None)
module.fail_json(msg='When deleting all installation media, there is no need to specify further parameters: %s ' % entity_dict.keys())
if affects_multiple:
entities = module.list_resource('media')
if not module.desired_absent: # not 'thin'
entities = [module.show_resource('media', entity['id']) for entity in entities]
if not entities:
# Nothing to do shortcut to exit
module.exit_json(changed=False)
else:
entity = module.find_resource_by_name('media', name=entity_dict['name'], failsafe=True)
if not module.desired_absent:
if 'operatingsystems' in entity_dict:
entity_dict['operatingsystems'] = module.find_operatingsystems(entity_dict['operatingsystems'], thin=True)
if not affects_multiple and len(entity_dict['operatingsystems']) == 1 and 'os_family' not in entity_dict and entity is None:
entity_dict['os_family'] = module.show_resource('operatingsystems', entity_dict['operatingsystems'][0]['id'])['family']
if 'locations' in entity_dict:
entity_dict['locations'] = module.find_resources_by_title('locations', entity_dict['locations'], thin=True)
if 'organizations' in entity_dict:
entity_dict['organizations'] = module.find_resources_by_name('organizations', entity_dict['organizations'], thin=True)
changed = False
if not affects_multiple:
changed = module.ensure_entity_state('media', entity_dict, entity)
else:
entity_dict.pop('name')
for entity in entities:
changed |= module.ensure_entity_state('media', entity_dict, entity)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
entity_spec=dict(
name=dict(required=True),
host=dict(required=True),
port=dict(type='int', default=389),
account=dict(),
account_password=dict(no_log=True),
base_dn=dict(),
attr_login=dict(),
attr_firstname=dict(),
attr_lastname=dict(),
attr_mail=dict(),
attr_photo=dict(),
onthefly_register=dict(type='bool'),
usergroup_sync=dict(type='bool'),
tls=dict(type='bool'),
groups_base=dict(),
server_type=dict(
choices=["free_ipa", "active_directory", "posix"]),
ldap_filter=dict(),
locations=dict(type='entity_list', flat_name='location_ids'),
organizations=dict(type='entity_list',
flat_name='organization_ids'),
use_netgroups=dict(type='bool'),
),
required_if=[[
'onthefly_register', True,
['attr_login', 'attr_firstname', 'attr_lastname', 'attr_mail']
]],
)
entity_dict = module.clean_params()
# additional parameter checks
if 'use_netgroups' in entity_dict and entity_dict[
'server_type'] == 'active_directory':
module.fail_json(
msg='use_netgroups cannot be used when server_type=active_directory'
)
module.connect()
entity = module.find_resource_by_name('auth_source_ldaps',
name=entity_dict['name'],
failsafe=True)
if not module.desired_absent:
if 'locations' in entity_dict:
entity_dict['locations'] = module.find_resources_by_title(
'locations', entity_dict['locations'], thin=True)
if 'organizations' in entity_dict:
entity_dict['organizations'] = module.find_resources_by_name(
'organizations', entity_dict['organizations'], thin=True)
module.ensure_entity('auth_source_ldaps', entity_dict, entity)
module.exit_json()
def main():
module = ForemanEntityAnsibleModule(
argument_spec=dict(
operatingsystem=dict(required=True),
state=dict(default='present',
choices=['present', 'present_with_defaults', 'absent']),
),
entity_spec=dict(
template_kind=dict(required=True,
type='entity',
flat_name='template_kind_id'),
provisioning_template=dict(type='entity',
flat_name='provisioning_template_id'),
),
required_if=(
['state', 'present', ['provisioning_template']],
['state', 'present_with_defaults', ['provisioning_template']],
),
)
entity_dict = module.clean_params()
module.connect()
entity_dict['operatingsystem'] = module.find_operatingsystem(
entity_dict['operatingsystem'], thin=True)
entity_dict['template_kind'] = module.find_resource_by_name(
'template_kinds', entity_dict['template_kind'], thin=True)
scope = {'operatingsystem_id': entity_dict['operatingsystem']['id']}
# Default templates do not support a scoped search
# see: https://projects.theforeman.org/issues/27722
entities = module.list_resource('os_default_templates', params=scope)
entity = next(
(item for item in entities
if item['template_kind_id'] == entity_dict['template_kind']['id']),
None)
# Find Provisioning Template
if 'provisioning_template' in entity_dict:
if module.desired_absent:
module.fail_json(
msg='Provisioning template must not be specified for deletion.'
)
entity_dict['provisioning_template'] = module.find_resource_by_name(
'provisioning_templates', entity_dict['provisioning_template'])
if entity_dict['provisioning_template'][
'template_kind_id'] != entity_dict['template_kind']['id']:
module.fail_json(msg='Provisioning template kind mismatching.')
module.ensure_entity('os_default_templates',
entity_dict,
entity,
params=scope)
module.exit_json()
def main():
module = ForemanEntityAnsibleModule(
entity_spec=dict(
name=dict(required=True),
hostgroup=dict(type='entity', flat_name='hostgroup_id'),
location=dict(type='entity', flat_name='location_id'),
organization=dict(type='entity', flat_name='organization_id'),
enabled=dict(type='bool'),
managed=dict(type='bool'),
build=dict(type='bool'),
),
required_if=(
['managed', True, ['hostgroup']],
['build', True, ['hostgroup']],
),
)
entity_dict = module.clean_params()
# additional param validation
if '.' not in entity_dict['name']:
module.fail_json(msg="The hostname must be FQDN")
if not module.desired_absent:
if 'hostgroup' not in entity_dict and entity_dict.get('managed', True):
module.fail_json(msg='Hostgroup can be omitted only with managed=False')
if 'build' in entity_dict and entity_dict['build']:
# When 'build'=True, 'managed' has to be True. Assuming that user's priority is to build.
if 'managed' in entity_dict and not entity_dict['managed']:
module.warn("when 'build'=True, 'managed' is ignored and forced to True")
entity_dict['managed'] = True
elif 'build' not in entity_dict and 'managed' in entity_dict and not entity_dict['managed']:
# When 'build' is not given and 'managed'=False, have to clear 'build' context that might exist on the server.
entity_dict['build'] = False
module.connect()
entity = module.find_resource_by_name('hosts', name=entity_dict['name'], failsafe=True)
if not module.desired_absent:
if 'hostgroup' in entity_dict:
entity_dict['hostgroup'] = module.find_resource_by_name('hostgroups', entity_dict['hostgroup'], thin=True)
if 'location' in entity_dict:
entity_dict['location'] = module.find_resource_by_title('locations', entity_dict['location'], thin=True)
if 'organization' in entity_dict:
entity_dict['organization'] = module.find_resource_by_name('organizations', entity_dict['organization'], thin=True)
changed, host = module.ensure_entity('hosts', entity_dict, entity)
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']],
),
supports_check_mode=True,
)
(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 = ForemanEntityAnsibleModule(
entity_spec=dict(
name=dict(required=True),
compute_attributes=dict(type='nested_list',
entity_spec=compute_attribute_entity_spec),
),
argument_spec=dict(updated_name=dict(), ),
)
entity_dict = module.clean_params()
updated_name = entity_dict.get('updated_name')
compute_attributes = entity_dict.pop('compute_attributes', None)
module.connect()
entity = module.find_resource_by_name('compute_profiles',
name=entity_dict['name'],
failsafe=True)
if module.state == 'present' and updated_name:
entity_dict['name'] = updated_name
changed, compute_profile = module.ensure_entity('compute_profiles',
entity_dict, entity)
# Apply changes on underlying compute attributes only when present
if module.state == 'present' and compute_attributes is not None:
# Update or create compute attributes
scope = {'compute_profile_id': compute_profile['id']}
for ca_entity_dict in compute_attributes:
ca_entity_dict['compute_resource'] = module.find_resource_by_name(
'compute_resources',
name=ca_entity_dict['compute_resource'],
failsafe=False,
thin=False)
ca_entities = ca_entity_dict['compute_resource'].get(
'compute_attributes', [])
ca_entity = next(
(item for item in ca_entities
if item.get('compute_profile_id') == compute_profile['id']),
None)
changed |= module.ensure_entity_state(
'compute_attributes',
ca_entity_dict,
ca_entity,
entity_spec=compute_attribute_entity_spec,
params=scope)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
argument_spec=dict(updated_name=dict(), ),
entity_spec=dict(
name=dict(required=True),
description=dict(aliases=['fullname'], flat_name='fullname'),
dns_proxy=dict(type='entity', flat_name='dns_id', aliases=['dns']),
locations=dict(type='entity_list', flat_name='location_ids'),
organizations=dict(type='entity_list',
flat_name='organization_ids'),
parameters=dict(type='nested_list',
entity_spec=parameter_entity_spec),
),
)
entity_dict = module.clean_params()
module.connect()
# Try to find the Domain to work on
entity = module.find_resource_by_name('domains',
name=entity_dict['name'],
failsafe=True)
if not module.desired_absent:
if entity and 'updated_name' in entity_dict:
entity_dict['name'] = entity_dict.pop('updated_name')
if 'dns_proxy' in entity_dict:
entity_dict['dns_proxy'] = module.find_resource_by_name(
'smart_proxies', entity_dict['dns_proxy'], thin=True)
if 'locations' in entity_dict:
entity_dict['locations'] = module.find_resources_by_title(
'locations', entity_dict['locations'], thin=True)
if 'organizations' in entity_dict:
entity_dict['organizations'] = module.find_resources_by_name(
'organizations', entity_dict['organizations'], thin=True)
parameters = entity_dict.get('parameters')
domain = module.ensure_entity('domains', entity_dict, entity)
if domain:
scope = {'domain_id': domain['id']}
module.ensure_scoped_parameters(scope, entity, parameters)
module.exit_json()
def main():
module = ForemanEntityAnsibleModule(
entity_spec=dict(
name=dict(required=True),
description=dict(),
locations=dict(type='entity_list', flat_name='location_ids'),
organizations=dict(type='entity_list', flat_name='organization_ids'),
filters=dict(type='entity_list', flat_name='filter_ids'),
),
)
filters_entity_spec = dict(
permissions=dict(type='entity_list', flat_name='permission_ids'),
resource=dict(),
search=dict(),
role_id=dict(required=True)
)
entity_dict = module.clean_params()
module.connect()
entity = module.find_resource_by_name('roles', name=entity_dict['name'], failsafe=True)
if not module.desired_absent:
if 'locations' in entity_dict:
entity_dict['locations'] = module.find_resources_by_title('locations', entity_dict['locations'], thin=True)
if 'organizations' in entity_dict:
entity_dict['organizations'] = module.find_resources_by_name('organizations', entity_dict['organizations'], thin=True)
filters = entity_dict.pop("filters", None)
changed, entity = module.ensure_entity('roles', entity_dict, entity)
if not module.desired_absent and not module.check_mode:
if filters is not None:
for role_filter in filters:
role_filter['role_id'] = entity['id']
role_filter['permissions'] = module.find_resources_by_name('permissions', role_filter['permissions'], thin=True)
module.ensure_entity_state('filters', role_filter, None, None, 'present', filters_entity_spec)
old_filters = entity.get('filter_ids', [])
for old_filter in old_filters:
module.ensure_entity('filters', None, {'id': old_filter}, {}, 'absent')
if len(old_filters) != len(filters):
changed = True
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
argument_spec=dict(updated_name=dict(), ),
entity_spec=dict(
name=dict(required=True),
admin=dict(required=False, type='bool', default=False),
users=dict(required=False,
type='entity_list',
flat_name='user_ids'),
usergroups=dict(required=False,
type='entity_list',
flat_name='usergroup_ids'),
roles=dict(required=False,
type='entity_list',
flat_name='role_ids'),
),
)
entity_dict = module.clean_params()
module.connect()
entity = module.find_resource_by_name('usergroups',
entity_dict['name'],
failsafe=True)
if not module.desired_absent:
if entity and 'updated_name' in entity_dict:
entity_dict['name'] = entity_dict.pop('updated_name')
if 'roles' in entity_dict:
entity_dict['roles'] = module.find_resources_by_name(
'roles', entity_dict['roles'], thin=True)
if 'users' in entity_dict:
entity_dict['users'] = module.find_resources('users', [
'login="******"'.format(login) for login in entity_dict['users']
],
thin=True)
if 'usergroups' in entity_dict:
entity_dict['usergroups'] = module.find_resources_by_name(
'usergroups', entity_dict['usergroups'], thin=True)
module.ensure_entity('usergroups', entity_dict, entity)
module.exit_json()
def main():
module = ForemanEntityAnsibleModule(
entity_spec=dict(
name=dict(required=True),
value=dict(type='raw'),
parameter_type=dict(default='string',
choices=[
'string', 'boolean', 'integer', 'real',
'array', 'hash', 'yaml', 'json'
]),
),
argument_spec=dict(
state=dict(default='present',
choices=['present_with_defaults', 'present', 'absent']),
updated_name=dict(),
),
required_if=(
['state', 'present_with_defaults', ['value']],
['state', 'present', ['value']],
),
)
entity_dict = module.clean_params()
module.connect()
entity = module.find_resource_by_name('common_parameters',
name=entity_dict['name'],
failsafe=True)
if not module.desired_absent:
if entity and 'updated_name' in entity_dict:
entity_dict['name'] = entity_dict.pop('updated_name')
# Convert values according to their corresponding parameter_type
if entity and 'parameter_type' not in entity:
entity['parameter_type'] = 'string'
entity_dict['value'] = parameter_value_to_str(
entity_dict['value'], entity_dict['parameter_type'])
if entity and 'value' in entity:
entity['value'] = parameter_value_to_str(
entity['value'], entity.get('parameter_type', 'string'))
changed = module.ensure_entity_state('common_parameters', entity_dict,
entity)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
argument_spec=dict(
name=dict(required=True),
updated_name=dict(),
compute_attributes=dict(type='list'),
),
supports_check_mode=True,
)
(compute_profile_dict, state) = module.parse_params()
name = compute_profile_dict.get('name')
updated_name = compute_profile_dict.get('updated_name')
compute_attributes = compute_profile_dict.pop('compute_attributes', list())
if len(compute_attributes) > 0 and state == 'absent':
module.fail_json(
msg='compute_attributes not allowed when state=absent')
module.connect()
try:
# Try to find the compute_profile to work on
compute_profile = find_compute_profile(
module, name=compute_profile_dict['name'], failsafe=True)
except Exception as e:
module.fail_json(msg='Failed to find entity: %s ' % e)
if state == 'present' and updated_name:
compute_profile_dict['name'] = updated_name
compute_profile_dict = sanitize_entity_dict(compute_profile_dict, name_map)
(changed,
compute_profile) = naildown_entity(ComputeProfile, compute_profile_dict,
compute_profile, state, module)
# Apply changes on underlying compute attributes only when present
if state == 'present':
# Update or create compute attributes
for compute_attribute_dict in compute_attributes:
changed |= compute_attribute(module, compute_profile,
compute_attribute_dict)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(entity_spec=dict(
name=dict(required=True),
description=dict(),
label=dict(),
), )
entity_dict = module.clean_params()
module.connect()
entity = module.find_resource_by_name('organizations',
name=entity_dict['name'],
failsafe=True)
changed = module.ensure_entity_state('organizations', entity_dict, entity)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(entity_spec=dict(
name=dict(required=True),
host=dict(required=True),
port=dict(type='int', default=389),
account=dict(),
account_password=dict(no_log=True),
base_dn=dict(),
attr_login=dict(),
attr_firstname=dict(),
attr_lastname=dict(),
attr_mail=dict(),
attr_photo=dict(),
onthefly_register=dict(type='bool'),
usergroup_sync=dict(type='bool'),
tls=dict(type='bool'),
groups_base=dict(),
server_type=dict(choices=["free_ipa", "active_directory", "posix"]),
ldap_filter=dict(),
locations=dict(type='entity_list', flat_name='location_ids'),
organizations=dict(type='entity_list', flat_name='organization_ids'),
), )
entity_dict = module.clean_params()
module.connect()
entity = module.find_resource_by_name('auth_source_ldaps',
name=entity_dict['name'],
failsafe=True)
if not module.desired_absent:
if 'locations' in entity_dict:
entity_dict['locations'] = module.find_resources_by_title(
'locations', entity_dict['locations'], thin=True)
if 'organizations' in entity_dict:
entity_dict['organizations'] = module.find_resources_by_name(
'organizations', entity_dict['organizations'], thin=True)
changed = module.ensure_entity_state('auth_source_ldaps', entity_dict,
entity)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(argument_spec=dict(
hostname=dict(required=True),
state=dict(default='present', choices=['on', 'off', 'state']),
), )
(host_dict, state) = module.parse_params()
module.connect()
entity = find_host(module, host_dict['hostname'], failsafe=True)
if state == 'state':
power_state = query_power_state(module, entity)
module.exit_json(changed=False, power_state=power_state)
else:
changed = naildown_power_state(module, entity, state)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
argument_spec=dict(
name=dict(required=True),
hostgroup=dict(),
location=dict(),
organization=dict(),
enabled=dict(default='true', type='bool'),
state=dict(default='present',
choices=['present_with_defaults', 'present', 'absent']),
),
required_if=(
['state', 'present_with_defaults', ['hostgroup']],
['state', 'present', ['hostgroup']],
),
supports_check_mode=True,
)
(host_dict, state) = module.parse_params()
module.connect()
host_dict['hostgroup'] = find_hostgroup(module,
host_dict['hostgroup'],
failsafe=True)
host_dict['name'] = host_dict['name'] + '.' + \
host_dict['hostgroup'].domain.read().fullname
entity = find_host(module, host_dict['name'], failsafe=True)
if 'location' in host_dict:
host_dict['location'] = find_location(module, host_dict['location'])
if 'organization' in host_dict:
host_dict['organization'] = find_organization(
module, host_dict['organization'])
host_dict = sanitize_entity_dict(host_dict, name_map)
changed = naildown_entity_state(Host, host_dict, entity, state, module)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(entity_spec=dict(
name=dict(required=True),
parent=dict(type='entity', flat_name='parent_id'),
organizations=dict(type='entity_list', flat_name='organization_ids'),
), )
entity_dict = module.clean_params()
module.connect()
# Get short name and parent from provided name
name, parent = split_fqn(entity_dict['name'])
entity_dict['name'] = name
if 'parent' in entity_dict:
if parent:
module.fail_json(
msg=
"Please specify the parent either separately, or as part of the title."
)
parent = entity_dict['parent']
if parent:
entity_dict['parent'] = module.find_resource_by_title(
'locations', parent, thin=True, failsafe=module.desired_absent)
if module.desired_absent and entity_dict['parent'] is None:
# Parent location does not exist so just exit here
module.exit_json()
if not module.desired_absent:
if 'organizations' in entity_dict:
entity_dict['organizations'] = module.find_resources_by_name(
'organizations', entity_dict['organizations'], thin=True)
entity = module.find_resource_by_title('locations',
build_fqn(name, parent),
failsafe=True)
module.ensure_entity('locations', entity_dict, entity)
module.exit_json()
def main():
module = ForemanEntityAnsibleModule(entity_spec=dict(
name=dict(aliases=['hostname'], required=True),
state=dict(default='state',
choices=[
'on', 'start', 'off', 'stop', 'soft', 'reboot', 'cycle',
'reset', 'state', 'status'
]),
), )
entity_dict = module.clean_params()
module.connect()
# power_status endpoint was only added in foreman 1.22.0 per https://projects.theforeman.org/issues/25436
# Delete this piece when versions below 1.22 are off common use
# begin delete
if 'power_status' not in module.foremanapi.resource('hosts').actions:
params = {'id': entity_dict['name'], 'power_action': 'status'}
power_state = module.resource_action('hosts',
'power',
params=params,
ignore_check_mode=True)
power_state[
'state'] = 'on' if power_state['power'] == 'running' else 'off'
else:
# end delete (on delete un-indent the below two lines)
params = {'id': entity_dict['name']}
power_state = module.resource_action('hosts',
'power_status',
params=params,
ignore_check_mode=True)
if module.state in ['state', 'status']:
module.exit_json(power_state=power_state['state'])
elif ((module.state in ['on', 'start'] and power_state['state'] == 'on') or
(module.state in ['off', 'stop'] and power_state['state'] == 'off')):
module.exit_json()
else:
params['power_action'] = module.state
module.resource_action('hosts', 'power', params=params)
module.exit_json()
def main():
module = ForemanEntityAnsibleModule(
argument_spec=dict(
name=dict(required=True),
locations=dict(type='list'),
organizations=dict(type='list'),
operatingsystems=dict(type='list'),
os_family=dict(),
path=dict(),
),
supports_check_mode=True,
)
(medium_dict, state) = module.parse_params()
module.connect()
entity = find_installation_medium(module,
name=medium_dict['name'],
failsafe=True)
if 'operatingsystems' in medium_dict:
medium_dict['operatingsystems'] = find_operating_systems_by_title(
module, medium_dict['operatingsystems'])
if len(medium_dict['operatingsystems']
) == 1 and 'os_family' not in medium_dict and entity is None:
medium_dict['os_family'] = medium_dict['operatingsystems'][
0].family
if 'locations' in medium_dict:
medium_dict['locations'] = find_locations(module,
medium_dict['locations'])
if 'organizations' in medium_dict:
medium_dict['organizations'] = find_organizations(
module, medium_dict['organizations'])
medium_dict = sanitize_entity_dict(medium_dict, name_map)
changed = naildown_entity_state(Media, medium_dict, entity, state, module)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
argument_spec=dict(
name=dict(required=True),
label=dict(),
),
supports_check_mode=True,
)
(entity_dict, state) = module.parse_params()
module.connect()
entity = find_organization(module, name=entity_dict['name'], failsafe=True)
entity_dict = sanitize_entity_dict(entity_dict, name_map)
changed = naildown_entity_state(Organization, entity_dict, entity, state,
module)
module.exit_json(changed=changed)
def main():
module = ForemanEntityAnsibleModule(
argument_spec=dict(
name=dict(required=True),
parent=dict(),
organizations=dict(type='list'),
),
supports_check_mode=True,
)
(entity_dict, state) = module.parse_params()
module.connect()
name_or_title = entity_dict.pop('name')
parent = entity_dict.pop('parent', None)
# Get short name and parent from provided name
parent_from_title, name = split_fqn(name_or_title)
entity_dict['name'] = name
if parent:
entity_dict['parent'] = find_location(module, parent)
elif parent_from_title:
entity_dict['parent'] = find_location(module, parent_from_title)
if 'organizations' in entity_dict:
entity_dict['organizations'] = find_organizations(
module, entity_dict['organizations'])
entity = find_location(module,
title=build_fqn(name_or_title, parent),
failsafe=True)
entity_dict = sanitize_entity_dict(entity_dict, name_map)
changed = naildown_entity_state(Location, entity_dict, entity, state,
module)
module.exit_json(changed=changed)
