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), name=dict(required=True), organization=dict(required=True), repositories=dict(type='list'), state=dict(default='present', choices=['present_with_defaults', 'present', 'absent']), ), 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['organization'] = find_organization( module, name=entity_dict['organization']) if 'repositories' in entity_dict: 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 = naildown_entity_state(ContentView, content_view_dict, content_view_entity, state, module) module.exit_json(changed=changed)
def content_view_promote(module, name, organization, to_environment, **kwargs): changed = False organization = find_organization(module, organization) content_view = find_content_view(module, name=name, organization=organization) if kwargs['from_environment'] is not None: kwargs['from_environment'] = find_lifecycle_environment( module, name=kwargs['from_environment'], organization=organization) to_environment = find_lifecycle_environment(module, name=to_environment, organization=organization) content_view_version = find_content_view_version( module, content_view, environment=kwargs.pop('from_environment'), version=kwargs.pop('version')) request_data = {'environment_id': to_environment.id} request_data.update({k: v for k, v in kwargs.items() if v is not None}) current_environment_ids = map(lambda environment: environment.id, content_view_version.environment) if to_environment.id not in current_environment_ids: if to_environment.prior.id in current_environment_ids or kwargs[ 'force']: if not module.check_mode: content_view_version.promote(data=request_data) changed = True elif to_environment.prior.id not in current_environment_ids: module.fail_json( msg= "Cannot promote directly to {} without having already promoted to {} without the force parameter" .format(to_environment.name, to_environment.prior.read().name)) return changed
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 = 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), name=dict(required=True), organization=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']), ), supports_check_mode=True, mutually_exclusive=[['repositories', 'components']], ) 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['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 = 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), content_view=dict(required=True), organization=dict(required=True), state=dict(default='present', choices=['present', 'absent']), version=dict(), lifecycle_environments=dict(type='list', default=['Library']), force=dict(type='bool', aliases=['force_promote'], default=False), force_yum_metadata_regeneration=dict(type='bool', default=False), synchronous=dict(type='bool', default=True), current_lifecycle_environment=dict(), ), mutually_exclusive=[['current_lifecycle_environment', 'version']], supports_check_mode=True, ) if has_import_error: module.fail_json(msg=import_error_msg) set_task_timeout(3600000) # 60 minutes params_dict = dict([(k, v) for (k, v) in module.params.items() if v is not None]) server_url = module.params['server_url'] username = module.params['username'] password = module.params['password'] verify_ssl = module.params['verify_ssl'] state = module.params['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) organization = find_organization(module, params_dict['organization']) content_view = find_content_view(module, name=params_dict['content_view'], organization=organization) if 'current_lifecycle_environment' in params_dict: params_dict[ 'current_lifecycle_environment'] = find_lifecycle_environment( module, name=params_dict['current_lifecycle_environment'], organization=organization) content_view_version = find_content_view_version( module, content_view, environment=params_dict['current_lifecycle_environment']) elif 'version' in params_dict: content_view_version = find_content_view_version( module, content_view, version=params_dict['version'], failsafe=True) else: content_view_version = None changed = False if state == 'present': if content_view_version is None: kwargs = dict(data=dict()) if 'description' in params_dict: kwargs['data'].update(description=params_dict['description']) if 'force_metadata_regeneration' in params_dict: kwargs['data'].update( force_yum_metadata_regeneration=params_dict[ 'force_metadata_regeneration']) if 'version' in params_dict: kwargs['data'].update( major=map(int, str(params_dict['version']).split('.'))[0]) kwargs['data'].update( minor=map(int, str(params_dict['version']).split('.'))[1]) response = content_view.publish(params_dict['synchronous'], **kwargs) changed = True content_view_version = ContentViewVersion( id=response['output']['content_view_version_id']).read() if 'lifecycle_environments' in params_dict: lifecycle_environments = find_lifecycle_environments( module, names=params_dict['lifecycle_environments'], organization=organization) le_changed = promote_content_view_version( module, content_view_version, organization, lifecycle_environments, params_dict['synchronous'], force=params_dict['force'], force_yum_metadata_regeneration=params_dict[ 'force_yum_metadata_regeneration']) elif state == 'absent': changed = naildown_entity_state(ContentViewVersion, dict(), content_view_version, state, module) module.exit_json(changed=changed or le_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), name=dict(required=True), new_name=dict(), organization=dict(required=True), lifecycle_environment=dict(), content_view=dict(), subscriptions=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']], ], ) 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['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']) activation_key_dict = sanitize_entity_dict(entity_dict, name_map) activation_key_entity = find_activation_key( module, name=entity_dict['name'], organization=entity_dict['organization'], failsafe=True) 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 = map( lambda s: s.id, 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 = map(lambda s: s.id, current_subscriptions) if set(desired_subscription_ids) != set( current_subscription_ids): if not module.check_mode: for subscription_id in set( desired_subscription_ids) - set( current_subscription_ids): activation_key_entity.add_subscriptions( data={ 'quantity': 1, 'subscription_id': subscription_id }) for subscription_id in set( current_subscription_ids) - set( 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() for product in product_content['results']: if product['enabled_content_override'] is not None: current_content_overrides.add( (product['content']['label'], product['enabled_content_override'])) desired_content_overrides = set() for product in content_overrides: desired_content_overrides.add( (product['label'], override_to_boolnone(product['override']))) 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_to_boolnone( override)).lower() } }) changed = True module.exit_json(changed=changed) except Exception as e: module.fail_json(msg=e)
def main(): module = ForemanAnsibleModule( argument_spec=dict( name=dict(required=True), description=dict(), repositories=dict(type='list', default=[]), inclusion=dict(type='bool', default=False), content_view=dict(required=True), filter_type=dict(required=True, choices=['rpm', 'package_group', 'erratum', 'docker']), organization=dict(required=True), filter_state=dict(default='present', choices=['present', 'absent']), rule_state=dict(default='present', choices=['present', 'absent']), rule_name=dict(aliases=['package_name', 'package_group', 'tag']), date_type=dict(default='updated', choices=['issued', 'updated']), end_date=dict(), errata_id=dict(), max_version=dict(), min_version=dict(), start_date=dict(), types=dict(default=["bugfix", "enhancement", "security"], type='list'), version=dict(), ), supports_check_mode=False, ) entity_dict = module.parse_params() filter_state = entity_dict.pop('filter_state') rule_state = entity_dict.pop('rule_state') module.connect() organization = find_organization(module, name=entity_dict.pop('organization')) entity_dict['content_view'] = find_content_view(module, name=entity_dict['content_view'], organization=organization) if len(entity_dict['repositories']) > 0: entity_dict['repositories'] = find_repositories(module, entity_dict['repositories'], organization) content_view_filter_entity = find_content_view_filter(module, name=entity_dict['name'], content_view=entity_dict['content_view'], failsafe=True) content_view_filter_dict = sanitize_entity_dict(entity_dict, content_filter_map) content_view_filter_changed = naildown_entity_state(AbstractContentViewFilter, content_view_filter_dict, content_view_filter_entity, filter_state, module) if entity_dict['filter_type'] == 'erratum': entity_dict['rule_name'] = None elif 'rule_name' not in entity_dict: entity_dict['rule_name'] = entity_dict['name'] # Find content_view_filter again as it may have just been created entity_dict['content_view_filter'] = find_content_view_filter(module, name=entity_dict['name'], content_view=entity_dict['content_view'], failsafe=True) if entity_dict['content_view_filter'] is not None: if 'errata_id' in entity_dict: rule_map = content_filter_rule_erratum_id_map entity_dict['errata'] = find_errata(module, id=entity_dict['errata_id'], organization=organization) content_view_filter_rule_entity = find_content_view_filter_rule(module, content_view_filter=entity_dict['content_view_filter'], errata=entity_dict['errata'], failsafe=True) else: rule_map = globals()['content_filter_rule_%s_map' % (entity_dict['filter_type'])] content_view_filter_rule_entity = find_content_view_filter_rule(module, content_view_filter=entity_dict['content_view_filter'], name=entity_dict['rule_name'], failsafe=True) if entity_dict['filter_type'] == 'package_group': entity_dict['uuid'] = find_package_group(module, name=entity_dict['rule_name']).uuid content_view_filter_rule_dict = sanitize_entity_dict(entity_dict, rule_map) check_missing = ['min_version', 'max_version', 'version', 'start_date', 'end_date', 'architecture', 'date_type'] content_view_filter_rule_changed = naildown_entity_state(ContentViewFilterRule, content_view_filter_rule_dict, content_view_filter_rule_entity, rule_state, module, check_missing) changed = content_view_filter_changed or content_view_filter_rule_changed else: changed = content_view_filter_changed 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), name=dict(required=True), description=dict(), repositories=dict(type='list', default=[]), inclusion=dict(type='bool', default=False), content_view=dict(required=True), filter_type=dict( required=True, choices=['rpm', 'package_group', 'erratum', 'docker']), organization=dict(required=True), filter_state=dict(default='present', choices=['present', 'absent']), rule_state=dict(default='present', choices=['present', 'absent']), rule_name=dict(aliases=['package_name', 'package_group', 'tag']), date_type=dict(default='updated', choices=['issued', 'updated']), end_date=dict(), errata_id=dict(), max_version=dict(), min_version=dict(), start_date=dict(), types=dict(default=["bugfix", "enhancement", "security"], type='list'), version=dict(), ), supports_check_mode=False, ) 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') filter_state = entity_dict.pop('filter_state') rule_state = entity_dict.pop('rule_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) organization = find_organization(module, name=entity_dict.pop('organization')) entity_dict['content_view'] = find_content_view( module, name=entity_dict['content_view'], organization=organization) if len(entity_dict['repositories']) > 0: entity_dict['repositories'] = find_repositories( module, entity_dict['repositories'], organization) content_view_filter_entity = find_content_view_filter( module, name=entity_dict['name'], content_view=entity_dict['content_view'], failsafe=True) content_view_filter_dict = sanitize_entity_dict(entity_dict, content_filter_map) content_view_filter_changed = naildown_entity_state( AbstractContentViewFilter, content_view_filter_dict, content_view_filter_entity, filter_state, module) if entity_dict['filter_type'] == 'erratum': entity_dict['rule_name'] = None elif 'rule_name' not in entity_dict: entity_dict['rule_name'] = entity_dict['name'] # Find content_view_filter again as it may have just been created entity_dict['content_view_filter'] = find_content_view_filter( module, name=entity_dict['name'], content_view=entity_dict['content_view'], failsafe=True) if entity_dict['content_view_filter'] is not None: if 'errata_id' in entity_dict: rule_map = content_filter_rule_erratum_id_map entity_dict['errata'] = find_errata(module, id=entity_dict['errata_id'], organization=organization) content_view_filter_rule_entity = find_content_view_filter_rule( module, content_view_filter=entity_dict['content_view_filter'], errata=entity_dict['errata'], failsafe=True) else: rule_map = globals()['content_filter_rule_%s_map' % (entity_dict['filter_type'])] content_view_filter_rule_entity = find_content_view_filter_rule( module, content_view_filter=entity_dict['content_view_filter'], name=entity_dict['rule_name'], failsafe=True) if entity_dict['filter_type'] == 'package_group': entity_dict['uuid'] = find_package_group( module, name=entity_dict['rule_name']).uuid content_view_filter_rule_dict = sanitize_entity_dict( entity_dict, rule_map) check_missing = [ 'min_version', 'max_version', 'version', 'start_date', 'end_date', 'architecture', 'date_type' ] content_view_filter_rule_changed = naildown_entity_state( ContentViewFilterRule, content_view_filter_rule_dict, content_view_filter_rule_entity, rule_state, module, check_missing) changed = content_view_filter_changed or content_view_filter_rule_changed else: changed = content_view_filter_changed module.exit_json(changed=changed)