def main():
module = KatelloEntityAnsibleModule(
argument_spec=dict(
name=dict(default=None),
product=dict(default=None),
label=dict(default=None),
repositories=dict(required=True, type='list'),
state=dict(default='enabled', choices=['disabled', 'enabled']),
),
required_one_of=[['label', 'name']],
)
(module_params, state) = module.parse_params()
name = module_params.get('name')
product = module_params.get('product')
label = module_params.get('label')
organization = module_params.get('organization')
repositories = module_params.get('repositories')
module.connect()
try:
changed = repository_set(module, name, organization, product, label, state, repositories=repositories)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg=e)
def main():
module = KatelloEntityAnsibleModule(
argument_spec=dict(
name=dict(required=True),
content_type=dict(required=True, choices=['gpg_key', 'cert']),
content=dict(required=True),
),
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['organization'] = find_organization(
module, name=entity_dict['organization'])
entity = find_content_credential(module,
name=entity_dict['name'],
organization=entity_dict['organization'],
failsafe=True)
entity_dict = sanitize_entity_dict(entity_dict, name_map)
changed = naildown_entity_state(ContentCredential, entity_dict, entity,
state, module)
module.exit_json(changed=changed)
def main():
module = KatelloEntityAnsibleModule(
argument_spec=dict(
product=dict(required=True),
label=dict(),
name=dict(required=True),
content_type=dict(
required=True,
choices=['docker', 'ostree', 'yum', 'puppet', 'file', 'deb']),
url=dict(),
gpg_key=dict(),
docker_upstream_name=dict(),
download_policy=dict(
choices=['background', 'immediate', 'on_demand']),
mirror_on_sync=dict(type='bool', default=True),
state=dict(default='present',
choices=['present_with_defaults', 'present', 'absent']),
),
supports_check_mode=True,
)
(entity_dict, state) = module.parse_params()
if entity_dict[
'content_type'] != 'docker' and 'docker_upstream_name' in entity_dict:
module.fail_json(
msg=
"docker_upstream_name should not be set unless content_type: docker"
)
module.connect()
entity_dict['organization'] = find_organization(
module, name=entity_dict['organization'])
entity_dict['product'] = find_product(
module,
name=entity_dict['product'],
organization=entity_dict['organization'])
if 'gpg_key' in entity_dict:
entity_dict['gpg_key'] = find_content_credential(
module,
name=entity_dict['gpg_key'],
organization=entity_dict['organization'])
entity = find_repository(module,
name=entity_dict['name'],
product=entity_dict['product'],
failsafe=True)
entity_dict = sanitize_entity_dict(entity_dict, name_map)
changed = naildown_entity_state(Repository, entity_dict, entity, state,
module)
module.exit_json(changed=changed)
def main():
module = KatelloEntityAnsibleModule(
argument_spec=dict(
name=dict(required=True),
label=dict(),
gpg_key=dict(),
sync_plan=dict(),
description=dict(),
state=dict(default='present',
choices=['present_with_defaults', 'present', 'absent']),
),
supports_check_mode=True,
)
(entity_dict, state) = module.parse_params()
module.connect()
entity_dict['organization'] = find_organization(
module, name=entity_dict['organization'])
if 'gpg_key' in entity_dict:
entity_dict['gpg_key'] = find_content_credential(
module,
name=entity_dict['gpg_key'],
organization=entity_dict['organization'])
if 'sync_plan' in entity_dict:
entity_dict['sync_plan'] = find_sync_plan(
module,
name=entity_dict['sync_plan'],
organization=entity_dict['organization'])
entity = find_product(module,
name=entity_dict['name'],
organization=entity_dict['organization'],
failsafe=True)
entity_dict = sanitize_entity_dict(entity_dict, name_map)
changed = naildown_entity_state(Product, entity_dict, entity, state,
module)
module.exit_json(changed=changed)
def main():
module = KatelloEntityAnsibleModule(
argument_spec=dict(
name=dict(required=True),
label=dict(),
description=dict(),
prior=dict(),
),
supports_check_mode=True,
)
(server_params, module_params, state) = module.parse_params()
name = module_params.get('name')
label = module_params.get(
'label') if module_params.get('label') != '' else None
description = module_params.get('description')
prior = None if module_params.get('prior') == '' else module_params.get(
'prior')
organization = module_params.get('organization')
(server_url, username, password, verify_ssl) = server_params
create_server(server_url, (username, password), verify_ssl)
ping_server(module)
validate_params(module,
state,
label=label,
description=description,
prior=prior)
try:
changed = lifecycle_environment(module,
name,
organization,
state,
label=label,
description=description,
prior=prior)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg=e)
def main():
module = KatelloEntityAnsibleModule(argument_spec=dict(
name=dict(required=True),
label=dict(),
description=dict(),
prior=dict(),
), )
(module_params, state) = module.parse_params()
name = module_params.get('name')
label = module_params.get(
'label') if module_params.get('label') != '' else None
description = module_params.get('description')
prior = None if module_params.get('prior') == '' else module_params.get(
'prior')
organization = module_params.get('organization')
module.connect()
validate_params(module,
state,
label=label,
description=description,
prior=prior)
try:
changed = lifecycle_environment(module,
name,
organization,
state,
label=label,
description=description,
prior=prior)
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg=e)
def main():
module = KatelloEntityAnsibleModule(
argument_spec=dict(
name=dict(required=True),
new_name=dict(),
lifecycle_environment=dict(),
content_view=dict(),
subscriptions=dict(type='list'),
host_collections=dict(type='list'),
content_overrides=dict(type='list'),
auto_attach=dict(type='bool', default=True),
state=dict(default='present',
choices=[
'present', 'present_with_defaults', 'absent',
'copied'
]),
),
supports_check_mode=True,
required_if=[
['state', 'copied', ['new_name']],
],
)
(entity_dict, state) = module.parse_params()
module.connect()
entity_dict['organization'] = find_organization(
module, name=entity_dict['organization'])
if 'lifecycle_environment' in entity_dict:
entity_dict['lifecycle_environment'] = find_lifecycle_environment(
module, entity_dict['lifecycle_environment'],
entity_dict['organization'])
if 'content_view' in entity_dict:
entity_dict['content_view'] = find_content_view(
module, entity_dict['content_view'], entity_dict['organization'])
if 'host_collections' in entity_dict:
entity_dict['host_collections'] = find_host_collections(
module, entity_dict['host_collections'],
entity_dict['organization'])
activation_key_entity = find_activation_key(
module,
name=entity_dict['name'],
organization=entity_dict['organization'],
failsafe=True)
activation_key_dict = sanitize_entity_dict(entity_dict, name_map)
try:
changed, activation_key_entity = naildown_entity(
ActivationKey, activation_key_dict, activation_key_entity, state,
module)
# only update subscriptions of newly created or updated AKs
# copied keys inherit the subscriptions of the origin, so one would not have to specify them again
# deleted keys don't need subscriptions anymore either
if state == 'present' or (state == 'present_with_defaults'
and changed):
if 'subscriptions' in entity_dict:
subscriptions = entity_dict['subscriptions']
desired_subscription_ids = set(
s.id for s in find_subscriptions(
module, subscriptions, entity_dict['organization']))
current_subscriptions = [
Subscription(**result)
for result in Subscription().search_normalize(
activation_key_entity.subscriptions()['results'])
]
current_subscription_ids = set(s.id
for s in current_subscriptions)
if desired_subscription_ids != current_subscription_ids:
if not module.check_mode:
for subscription_id in (desired_subscription_ids -
current_subscription_ids):
activation_key_entity.add_subscriptions(
data={
'quantity': 1,
'subscription_id': subscription_id
})
for subscription_id in (current_subscription_ids -
desired_subscription_ids):
activation_key_entity.remove_subscriptions(
data={'subscription_id': subscription_id})
changed = True
if 'content_overrides' in entity_dict:
content_overrides = entity_dict['content_overrides']
product_content = activation_key_entity.product_content()
current_content_overrides = set(
(product['content']['label'],
product['enabled_content_override'])
for product in product_content['results']
if product['enabled_content_override'] is not None)
desired_content_overrides = set(
(product['label'],
override_to_boolnone(product['override']))
for product in content_overrides)
if desired_content_overrides != current_content_overrides:
if not module.check_mode:
for (
label, override
) in current_content_overrides - desired_content_overrides:
activation_key_entity.content_override(
data={
'content_override': {
'content_label': label,
'value': 'default'
}
})
for (
label, override
) in desired_content_overrides - current_content_overrides:
activation_key_entity.content_override(
data={
'content_override': {
'content_label': label,
'value': str(override).lower()
}
})
changed = True
module.exit_json(changed=changed)
except Exception as e:
module.fail_json(msg=e)
def main():
module = KatelloEntityAnsibleModule(
argument_spec=dict(
name=dict(required=True),
composite=dict(type='bool', default=False),
auto_publish=dict(type='bool', default=False),
components=dict(type='list'),
repositories=dict(type='list'),
state=dict(default='present',
choices=['present_with_defaults', 'present', 'absent']),
),
mutually_exclusive=[['repositories', 'components']],
)
(entity_dict, state) = module.parse_params()
module.connect()
entity_dict['organization'] = find_organization(
module, name=entity_dict['organization'])
if 'repositories' in entity_dict and not entity_dict['composite']:
entity_dict['repositories'] = find_repositories(
module, entity_dict['repositories'], entity_dict['organization'])
content_view_entity = find_content_view(
module,
name=entity_dict['name'],
organization=entity_dict['organization'],
failsafe=True)
content_view_dict = sanitize_entity_dict(entity_dict, name_map)
changed, content_view_entity = naildown_entity(ContentView,
content_view_dict,
content_view_entity, state,
module)
# only update CVC's of newly created or updated CCV's
if state == 'present' or (state == 'present_with_defaults' and changed):
current_cvcs = []
if hasattr(content_view_entity, 'content_view_component'):
current_cvcs = [
cvc.read()
for cvc in content_view_entity.content_view_component
]
if 'components' in entity_dict and content_view_entity.composite:
for component in entity_dict['components']:
cvc = component.copy()
cvc['content_view'] = find_content_view(
module,
name=component['content_view'],
organization=entity_dict['organization'])
cvc_matched = None
for _cvc in current_cvcs:
if _cvc.content_view.id == cvc['content_view'].id:
cvc_matched = _cvc
force_update = list()
if 'version' in component:
cvc['version'] = find_content_view_version(
module,
cvc['content_view'],
version=component['version'])
cvc['latest'] = False
if cvc_matched and cvc_matched.latest:
# When changing to latest=False & version is the latest we must send 'content_view_version' to the server
force_update.append('content_view_version')
if cvc_matched:
cvc['composite_content_view'] = content_view_entity
cvc_dict = sanitize_entity_dict(cvc, cvc_map)
cvc_changed = naildown_entity_state(
ContentViewComponent,
cvc_dict,
cvc_matched,
'present',
module,
force_update=force_update)
current_cvcs.remove(cvc_matched)
if cvc_changed:
changed = cvc_changed
else:
for attr in ['latest', 'version']:
if attr not in cvc:
cvc[attr] = None
ContentViewComponent(
composite_content_view=content_view_entity,
content_view=cvc['content_view'],
latest=cvc['latest'],
content_view_version=cvc['version']).add()
changed = True
for cvc in current_cvcs:
# desired cvcs have already been updated and removed from `current_cvcs`
cvc.remove()
changed = True
module.exit_json(changed=changed)
def main():
module = KatelloEntityAnsibleModule(
argument_spec=dict(
product=dict(required=True),
label=dict(),
name=dict(required=True),
content_type=dict(
required=True,
choices=['docker', 'ostree', 'yum', 'puppet', 'file', 'deb']),
url=dict(),
gpg_key=dict(),
docker_upstream_name=dict(),
download_policy=dict(
choices=['background', 'immediate', 'on_demand']),
state=dict(default='present',
choices=['present_with_defaults', 'present', 'absent']),
),
supports_check_mode=True,
)
(server_params, entity_dict, state) = module.parse_params()
if entity_dict[
'content_type'] != 'docker' and 'docker_upstream_name' in entity_dict:
module.fail_json(
msg=
"docker_upstream_name should not be set unless content_type: docker"
)
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['organization'] = find_organization(
module, name=entity_dict['organization'])
entity_dict['product'] = find_product(
module,
name=entity_dict['product'],
organization=entity_dict['organization'])
if 'gpg_key' in entity_dict:
entity_dict['gpg_key'] = find_content_credential(
module,
name=entity_dict['gpg_key'],
organization=entity_dict['organization'])
entity = find_repository(module,
name=entity_dict['name'],
product=entity_dict['product'],
failsafe=True)
entity_dict = sanitize_entity_dict(entity_dict, name_map)
changed = naildown_entity_state(Repository, entity_dict, entity, state,
module)
module.exit_json(changed=changed)
