def do_differ(current, desired): system = desired.get('system') if system and utils.do_differ(current.get('system'), system): return True subs = desired.get('subscriptions') if subs is not None and set(subs) != set(current.get('subscriptions', [])): return True return utils.do_differ(current, desired, 'system', 'subscriptions')
def do_differ(current, desired): if utils.do_differ_v1(current, desired, "client"): return True current_client = current["spec"]["client"] desired_client = desired["spec"]["client"] # Sensu Go API returns 'agent_address' field in the client spec, # but this field is not meant to be set via the providers API. if utils.do_differ(current_client, desired_client, "agent_address", "tls"): return True # Sensu Go API returns some extra fields in the tls spec. # We ignore them, as they are not meant to be set via the # providers API. return utils.do_differ(current_client["tls"], desired_client.get("tls") or {}, "insecure", "tls_server_name", "ca_path")
def sync(state, client, list_path, resource_path, payload, check_mode): datastore = _get(client, resource_path) # When we are deleting stores, we do not care if there is more than one # datastore present. We just make sure the currently manipulated store is # gone. This makes our module useful in "let us clean up the mess" # scenarios. if state == "absent" and datastore is None: return False, None if state == "absent": if not check_mode: utils.delete(client, resource_path) return True, None # If the store exists, update it and ignore the fact that there might be # more than one present. if datastore: if utils.do_differ(datastore, payload["spec"]): if check_mode: return True, payload["spec"] utils.put(client, resource_path, payload) return True, _get(client, resource_path) return False, datastore # When adding a new datastore, we first make sure there is no other # datastore present because we do not want to be the ones who brought # backends into an inconsistent state. if utils.get(client, list_path): raise errors.Error("Some other external datastore is already active.") if check_mode: return True, payload["spec"] utils.put(client, resource_path, payload) return True, _get(client, resource_path)
def sync(client, path, payload, check_mode): remote_object = get(client, path) if utils.do_differ(remote_object, payload): if check_mode: return True, payload utils.put(client, path, payload) return True, get(client, path) return False, remote_object
def do_proxy_requests_differ(current, desired): if 'proxy_requests' not in desired: return False current = current.get('proxy_requests') or {} desired = desired['proxy_requests'] return (('entity_attributes' in desired and do_sets_differ(current, desired, 'entity_attributes')) or utils.do_differ(current, desired, 'entity_attributes'))
def sync(remote_object, state, client, path, payload, check_mode): if state == 'disabled' and remote_object is not None: if not check_mode: utils.delete(client, path) return True, utils.get(client, path) if utils.do_differ(remote_object, payload): if check_mode: return True, payload utils.put(client, path, payload) return True, utils.get(client, path) return False, remote_object
def do_differ(current, desired): return (utils.do_differ( current, desired, 'proxy_requests', 'subscriptions', 'handlers', 'runtime_assets', 'check_hooks', 'output_metric_handlers', 'env_vars', ) or do_proxy_requests_differ(current, desired) or do_sets_differ(current, desired, 'subscriptions') or do_sets_differ(current, desired, 'handlers') or do_sets_differ(current, desired, 'runtime_assets') or do_check_hooks_differ(current, desired) or do_sets_differ(current, desired, 'output_metric_handlers') or do_sets_differ(current, desired, 'env_vars'))
def do_differ(current, desired): system = desired.get('system') if system and utils.do_differ(current.get('system'), system): return True return utils.do_differ(current, desired, 'system')
def test_ignore_keys_do_not_mask_other_differences(self): assert utils.do_differ(dict(a=1, b=1), dict(a=2, b=2), "a") is True
def test_ignore_keys_do_not_affect_the_outcome(self): assert utils.do_differ(dict(a=1), dict(a=2), "a") is False
def test_metadata_detects_change_in_presence_of_created_by(self): assert utils.do_differ( dict(metadata=dict(a=1, created_by=2)), dict(metadata=dict(a=2)), ) is True
def test_metadata_detects_change(self): assert utils.do_differ( dict(metadata=dict(a=1)), dict(metadata=dict(a=2)), ) is True
def test_metadata_ignores_created_by(self): assert utils.do_differ( dict(metadata=dict(a=1, created_by=2)), dict(metadata=dict(a=1)), ) is False
def do_differ(current, desired): if _do_builds_differ(current['builds'], desired['builds']): return True return utils.do_differ(current, desired, 'builds')
def test_detect_missing_keys_in_current(self): assert utils.do_differ({"a": "b"}, {"c": "d"}) is True
def test_detect_different_values(self): assert utils.do_differ({"a": "b"}, {"a": "c"}) is True
def do_role_bindings_differ(current, desired): if _do_subjects_differ(current['subjects'], desired['subjects']): return True return utils.do_differ(current, desired, 'subjects')
def do_roles_differ(current, desired): if _do_rules_differ(current['rules'], desired['rules']): return True return utils.do_differ(current, desired, 'rules')
def test_current_none_always_differ(self, desired): assert utils.do_differ(None, desired) is True
def _do_differ(remote, payload): return utils.do_differ(remote["spec"], payload["spec"])
def test_desired_none_values_are_ignored(self): assert utils.do_differ({"a": "b"}, {"c": None}) is False
def test_extra_keys_in_current_do_not_matter(self): assert utils.do_differ({"a": "b", "c": 3}, {"a": "b"}) is False
def do_differ(current, desired): return ( utils.do_differ(current, desired, "secrets") or utils.do_secrets_differ(current, desired) )