def main():
required_if = [('state', 'present', ['action', 'expressions'])]
module = AnsibleModule(
required_if=required_if,
supports_check_mode=True,
argument_spec=dict(
arguments.MUTATION_ARGUMENTS,
action=dict(choices=['allow', 'deny']),
expressions=dict(type='list', ),
runtime_assets=dict(type='list', ),
),
)
client = arguments.get_sensu_client(module.params['auth'])
path = '/filters/{0}'.format(module.params['name'])
payload = arguments.get_mutation_payload(module.params, 'action',
'expressions', 'runtime_assets')
try:
changed, sensu_filter = utils.sync(
module.params['state'],
client,
path,
payload,
module.check_mode,
)
module.exit_json(changed=changed, object=sensu_filter)
except errors.Error as e:
module.fail_json(msg=str(e))
def main():
required_if = [
('state', 'present', ['action', 'expressions'])
]
module = AnsibleModule(
required_if=required_if,
supports_check_mode=True,
argument_spec=dict(
arguments.get_spec(
"auth", "name", "state", "labels", "annotations", "namespace",
),
action=dict(choices=['allow', 'deny']),
expressions=dict(
type='list', elements='str',
),
runtime_assets=dict(
type='list', elements='str',
),
),
)
client = arguments.get_sensu_client(module.params['auth'])
path = utils.build_core_v2_path(
module.params['namespace'], 'filters', module.params['name'],
)
payload = arguments.get_mutation_payload(
module.params, 'action', 'expressions', 'runtime_assets'
)
try:
changed, sensu_filter = utils.sync(
module.params['state'], client, path, payload, module.check_mode,
)
module.exit_json(changed=changed, object=sensu_filter)
except errors.Error as e:
module.fail_json(msg=str(e))
def main():
required_if = [("state", "present", ["cluster_role"])]
module = AnsibleModule(required_if=required_if,
supports_check_mode=True,
argument_spec=dict(
arguments.get_spec("auth", "name", "state"),
cluster_role=dict(),
users=dict(type="list", ),
groups=dict(type="list", ),
))
msg = role_utils.validate_binding_module_params(module.params)
if msg:
module.fail_json(msg=msg)
client = arguments.get_sensu_client(module.params["auth"])
path = utils.build_core_v2_path(
None,
"clusterrolebindings",
module.params["name"],
)
payload = build_api_payload(module.params)
try:
changed, cluster_role_binding = utils.sync(
module.params["state"], client, path, payload, module.check_mode,
role_utils.do_role_bindings_differ)
module.exit_json(changed=changed, object=cluster_role_binding)
except errors.Error as e:
module.fail_json(msg=str(e))
def main():
required_if = [('state', 'present', ['handlers'])]
module = AnsibleModule(
supports_check_mode=True,
required_if=required_if,
argument_spec=dict(
arguments.get_spec(
"auth",
"name",
"state",
"labels",
"annotations",
),
handlers=dict(type='list'),
),
)
client = arguments.get_sensu_client(module.params['auth'])
path = '/handlers/{0}'.format(module.params['name'])
payload = arguments.get_mutation_payload(module.params, 'handlers')
payload['type'] = 'set'
try:
changed, handler = utils.sync(
module.params['state'],
client,
path,
payload,
module.check_mode,
)
module.exit_json(changed=changed, object=handler)
except errors.Error as e:
module.fail_json(msg=str(e))
def main():
required_if = [('state', 'present', ['command'])]
module = AnsibleModule(
required_if=required_if,
supports_check_mode=True,
argument_spec=dict(
arguments.MUTATION_ARGUMENTS,
command=dict(),
timeout=dict(type='int', ),
env_vars=dict(type='dict'),
runtime_assets=dict(type='list'),
),
)
client = arguments.get_sensu_client(module.params['auth'])
path = '/mutators/{0}'.format(module.params['name'])
payload = arguments.get_mutation_payload(module.params, 'command',
'timeout', 'runtime_assets')
if module.params['env_vars']:
payload['env_vars'] = utils.dict_to_key_value_strings(
module.params['env_vars'])
try:
changed, mutator = utils.sync(
module.params['state'],
client,
path,
payload,
module.check_mode,
)
module.exit_json(changed=changed, object=mutator)
except errors.Error as e:
module.fail_json(msg=str(e))
def test_absent_no_current_object_check(self, mocker):
client = mocker.Mock()
client.get.return_value = http.Response(404, "")
changed, object = utils.sync("absent", client, "/path", {}, True)
assert changed is False
assert object is None
def test_absent_current_object_present_check(self, mocker):
client = mocker.Mock()
client.get.return_value = http.Response(200, '{}')
client.delete.return_value = http.Response(204, "")
changed, object = utils.sync("absent", client, "/path", {}, True)
assert changed is True
assert object is None
client.delete.assert_not_called()
def test_present_no_current_object_check(self, mocker):
client = mocker.Mock()
client.get.return_value = http.Response(404, "")
changed, object = utils.sync(
"present", client, "/path", {"my": "data"}, True,
)
assert changed is True
assert {"my": "data"} == object
client.put.assert_not_called()
def test_present_current_object_does_not_differ(self, mocker):
client = mocker.Mock()
client.get.return_value = http.Response(200, '{"my": "data"}')
changed, object = utils.sync(
"present", client, "/path", {"my": "data"}, False,
)
assert changed is False
assert {"my": "data"} == object
client.put.assert_not_called()
def main():
required_if = [('state', 'present', ['entity_class'])]
module = AnsibleModule(
required_if=required_if,
supports_check_mode=True,
argument_spec=dict(arguments.get_spec(
"auth",
"name",
"state",
"labels",
"annotations",
"namespace",
),
entity_class=dict(),
subscriptions=dict(
type='list',
elements='str',
),
system=dict(type='dict'),
last_seen=dict(type='int'),
deregister=dict(type='bool'),
deregistration_handler=dict(),
redact=dict(
type='list',
elements='str',
),
user=dict()),
)
client = arguments.get_sensu_client(module.params['auth'])
path = utils.build_core_v2_path(
module.params['namespace'],
'entities',
module.params['name'],
)
payload = arguments.get_mutation_payload(module.params, 'entity_class',
'subscriptions', 'system',
'last_seen', 'deregister',
'redact', 'user')
if module.params['deregistration_handler']:
payload['deregistration'] = dict(
handler=module.params['deregistration_handler'])
try:
changed, entity = utils.sync(
module.params['state'],
client,
path,
payload,
module.check_mode,
do_differ,
)
module.exit_json(changed=changed, object=entity)
except errors.Error as e:
module.fail_json(msg=str(e))
def main():
required_if = [('state', 'present', ['command'])]
module = AnsibleModule(
supports_check_mode=True,
required_if=required_if,
argument_spec=dict(
arguments.get_spec(
"auth",
"name",
"state",
"labels",
"annotations",
"namespace",
),
command=dict(),
filters=dict(
type='list',
elements='str',
),
mutator=dict(),
timeout=dict(type='int'),
env_vars=dict(type='dict'),
runtime_assets=dict(
type='list',
elements='str',
),
),
)
client = arguments.get_sensu_client(module.params['auth'])
path = utils.build_core_v2_path(
module.params['namespace'],
'handlers',
module.params['name'],
)
payload = arguments.get_mutation_payload(module.params, 'command',
'filters', 'mutator', 'timeout',
'runtime_assets')
payload['type'] = 'pipe'
if module.params['env_vars']:
payload['env_vars'] = utils.dict_to_key_value_strings(
module.params['env_vars'])
try:
changed, handler = utils.sync(
module.params['state'],
client,
path,
payload,
module.check_mode,
)
module.exit_json(changed=changed, object=handler)
except errors.Error as e:
module.fail_json(msg=str(e))
def main():
module = AnsibleModule(
supports_check_mode=True,
argument_spec=dict(
arguments.get_spec("auth", "name", "state"),
rules=dict(
type="list",
elements="dict",
options=dict(
verbs=dict(
required=True,
type="list",
elements="str",
choices=["get", "list", "create", "update", "delete"],
),
resources=dict(
required=True,
type="list",
elements="str",
),
resource_names=dict(
type="list",
elements="str",
),
)
)
)
)
msg = role_utils.validate_module_params(module.params)
if msg:
module.fail_json(msg=msg)
client = arguments.get_sensu_client(module.params["auth"])
path = utils.build_core_v2_path(
None, "clusterroles", module.params["name"],
)
payload = arguments.get_mutation_payload(
module.params, "rules"
)
try:
changed, cluster_role = utils.sync(
module.params['state'], client, path,
payload, module.check_mode, role_utils.do_roles_differ
)
module.exit_json(changed=changed, object=cluster_role)
except errors.Error as e:
module.fail_json(msg=str(e))
def test_present_current_object_differ(self, mocker):
client = mocker.Mock()
client.get.side_effect = (
http.Response(200, '{"current": "data"}'),
http.Response(200, '{"new": "data"}'),
)
client.put.return_value = http.Response(201, "")
changed, object = utils.sync(
"present", client, "/path", {"my": "data"}, False,
)
assert changed is True
assert {"new": "data"} == object
client.put.assert_called_once_with("/path", {"my": "data"})
def main():
required_if = [("state", "present", ["builds"])]
module = AnsibleModule(
required_if=required_if,
supports_check_mode=True,
argument_spec=dict(
arguments.get_spec(
"auth",
"name",
"namespace",
"state",
"labels",
"annotations",
),
builds=dict(type="list",
elements="dict",
options=dict(
url=dict(required=True, ),
sha512=dict(required=True, ),
filters=dict(
type="list",
elements="str",
),
headers=dict(type="dict", ),
)),
),
)
msg = validate_module_params(module.params)
if msg:
module.fail_json(msg=msg)
client = arguments.get_sensu_client(module.params["auth"])
path = utils.build_core_v2_path(
module.params["namespace"],
"assets",
module.params["name"],
)
payload = build_api_payload(module.params)
try:
changed, asset = utils.sync(module.params["state"], client, path,
payload, module.check_mode, do_differ)
module.exit_json(changed=changed, object=asset)
except errors.Error as e:
module.fail_json(msg=str(e))
def main():
required_if = [('state', 'present', ['type', 'host', 'port'])]
module = AnsibleModule(
supports_check_mode=True,
required_if=required_if,
argument_spec=dict(arguments.get_spec(
"auth",
"name",
"state",
"labels",
"annotations",
"namespace",
),
type=dict(choices=['tcp', 'udp']),
filters=dict(
type='list',
elements='str',
),
mutator=dict(),
timeout=dict(type='int'),
host=dict(),
port=dict(type='int')),
)
client = arguments.get_sensu_client(module.params['auth'])
path = utils.build_core_v2_path(
module.params['namespace'],
'handlers',
module.params['name'],
)
payload = arguments.get_mutation_payload(module.params, 'type', 'filters',
'mutator', 'timeout')
payload['socket'] = dict(host=module.params['host'],
port=module.params['port'])
try:
changed, handler = utils.sync(
module.params['state'],
client,
path,
payload,
module.check_mode,
)
module.exit_json(changed=changed, object=handler)
except errors.Error as e:
module.fail_json(msg=str(e))
def main():
required_one_of = [['subscription', 'check']]
module = AnsibleModule(
supports_check_mode=True,
required_one_of=required_one_of,
argument_spec=dict(arguments.get_spec(
'auth',
'state',
'labels',
'annotations',
'namespace',
),
subscription=dict(),
check=dict(),
begin=dict(type='int', ),
expire=dict(type='int', ),
expire_on_resolve=dict(type='bool'),
reason=dict()),
)
name = '{0}:{1}'.format(module.params['subscription'] or '*',
module.params['check'] or '*')
client = arguments.get_sensu_client(module.params['auth'])
path = utils.build_core_v2_path(
module.params['namespace'],
'silenced',
name,
)
# We add name parameter because it is actually required and must match the name that is
# autogenerated on the API
module.params['name'] = name
payload = arguments.get_mutation_payload(module.params, 'subscription',
'check', 'begin', 'expire',
'expire_on_resolve', 'reason')
try:
changed, silence = utils.sync(
module.params['state'],
client,
path,
payload,
module.check_mode,
)
module.exit_json(changed=changed, object=silence)
except errors.Error as e:
module.fail_json(msg=str(e))
def main():
module = AnsibleModule(
supports_check_mode=True,
argument_spec=arguments.get_spec("auth", "name", "state"),
)
module.params['auth']['namespace'] = None
client = arguments.get_sensu_client(module.params['auth'])
path = '/namespaces/{0}'.format(module.params['name'])
payload = arguments.get_spec_payload(
module.params, 'name'
)
try:
changed, namespace = utils.sync(
module.params['state'], client, path, payload, module.check_mode,
)
module.exit_json(changed=changed, object=namespace)
except errors.Error as e:
module.fail_json(msg=str(e))
def main():
required_if = [('state', 'present', ['command', 'timeout'])]
module = AnsibleModule(
required_if=required_if,
supports_check_mode=True,
argument_spec=dict(
arguments.get_spec(
"auth",
"name",
"state",
"labels",
"annotations",
"namespace",
),
command=dict(),
timeout=dict(type='int', ),
stdin=dict(type='bool'),
runtime_assets=dict(
type='list',
elements='str',
),
),
)
client = arguments.get_sensu_client(module.params['auth'])
path = utils.build_core_v2_path(
module.params['namespace'],
'hooks',
module.params['name'],
)
payload = arguments.get_mutation_payload(module.params, 'command',
'timeout', 'stdin',
'runtime_assets')
try:
changed, hook = utils.sync(
module.params['state'],
client,
path,
payload,
module.check_mode,
)
module.exit_json(changed=changed, object=hook)
except errors.Error as e:
module.fail_json(msg=str(e))
def main():
required_if = [("state", "present", ["url", "sha512"])]
module = AnsibleModule(
required_if=required_if,
supports_check_mode=True,
argument_spec=dict(
arguments.get_spec(
"auth",
"name",
"state",
"labels",
"annotations",
),
url=dict(),
sha512=dict(),
filters=dict(type="list", ),
headers=dict(type="dict", ),
),
)
client = arguments.get_sensu_client(module.params["auth"])
path = "/assets/{0}".format(module.params["name"])
payload = arguments.get_mutation_payload(
module.params,
"url",
"sha512",
"filters",
"headers",
)
try:
changed, asset = utils.sync(
module.params["state"],
client,
path,
payload,
module.check_mode,
)
module.exit_json(changed=changed, object=asset)
except errors.Error as e:
module.fail_json(msg=str(e))
def main():
required_if = [
('state', 'present', ['type', 'host', 'port'])
]
module = AnsibleModule(
supports_check_mode=True,
required_if=required_if,
argument_spec=dict(
arguments.MUTATION_ARGUMENTS,
type=dict(choices=['tcp', 'udp']),
filters=dict(
type='list',
),
mutator=dict(),
timeout=dict(
type='int'
),
host=dict(),
port=dict(
type='int'
)
),
)
client = arguments.get_sensu_client(module.params['auth'])
path = '/handlers/{0}'.format(module.params['name'])
payload = arguments.get_mutation_payload(
module.params, 'type', 'filters', 'mutator', 'timeout'
)
payload['socket'] = dict(host=module.params['host'], port=module.params['port'])
try:
changed, handler = utils.sync(
module.params['state'], client, path, payload, module.check_mode,
)
module.exit_json(changed=changed, object=handler)
except errors.Error as e:
module.fail_json(msg=str(e))
def main():
required_if = [('state', 'present', ['entity_class'])]
module = AnsibleModule(
required_if=required_if,
supports_check_mode=True,
argument_spec=dict(arguments.MUTATION_ARGUMENTS,
entity_class=dict(),
subscriptions=dict(type='list', ),
system=dict(type='dict'),
last_seen=dict(type='int'),
deregister=dict(type='bool'),
deregistration_handler=dict(),
redact=dict(type='list'),
user=dict()),
)
client = arguments.get_sensu_client(module.params['auth'])
path = '/entities/{0}'.format(module.params['name'])
payload = arguments.get_mutation_payload(module.params, 'entity_class',
'subscriptions', 'system',
'last_seen', 'deregister',
'redact', 'user')
if module.params['deregistration_handler']:
payload['deregistration'] = dict(
handler=module.params['deregistration_handler'])
try:
changed, entity = utils.sync(
module.params['state'],
client,
path,
payload,
module.check_mode,
)
module.exit_json(changed=changed, object=entity)
except errors.Error as e:
module.fail_json(msg=str(e))
def main():
required_if = [
('state', 'present', ['entity_class'])
]
module = AnsibleModule(
required_if=required_if,
supports_check_mode=True,
argument_spec=dict(
arguments.get_spec(
"auth", "name", "state", "labels", "annotations", "namespace",
),
entity_class=dict(),
subscriptions=dict(
type='list', elements='str',
),
system=dict(
type='dict'
),
last_seen=dict(
type='int'
),
deregister=dict(
type='bool'
),
deregistration_handler=dict(),
redact=dict(
type='list', elements='str',
),
user=dict()
),
)
client = arguments.get_sensu_client(module.params['auth'])
path = utils.build_core_v2_path(
module.params['namespace'], 'entities', module.params['name'],
)
payload = arguments.get_mutation_payload(
module.params, 'entity_class', 'subscriptions', 'system', 'last_seen', 'deregister',
'redact', 'user'
)
if module.params['deregistration_handler']:
payload['deregistration'] = dict(handler=module.params['deregistration_handler'])
# As per conversation with @echlebek, the only two supported entity
# classes are agent and proxy. All other classes can lead to undefined
# behavior and should not be used.
eclass = payload.get('entity_class')
if eclass and eclass not in ('agent', 'proxy'):
module.deprecate(
'The `entity_class` parameter should be set to either `agent` or '
'`proxy`. All other values can result in undefined behavior of '
'the Sensu Go backend.',
version='2.0.0'
)
# Agent entities always have entity:{entity_name} subscription enabled
# even if we pass an empty subscriptions. In order to prevent falsely
# reporting changed: true, we always add this subscription to the agent
# entities.
if eclass == 'agent':
entity_sub = 'entity:' + module.params['name']
subs = payload.get('subscriptions', [])
if entity_sub not in subs:
# Copy subs in order to avoid mutating module params
payload['subscriptions'] = subs + [entity_sub]
try:
changed, entity = utils.sync(
module.params['state'], client, path, payload, module.check_mode,
do_differ,
)
module.exit_json(changed=changed, object=entity)
except errors.Error as e:
module.fail_json(msg=str(e))
def main():
required_if = [('state', 'present', ['subscriptions', 'command'])]
mutually_exclusive = [('interval', 'cron')]
module = AnsibleModule(
supports_check_mode=True,
required_if=required_if,
mutually_exclusive=mutually_exclusive,
argument_spec=dict(
arguments.get_spec(
"auth",
"name",
"state",
"labels",
"annotations",
"namespace",
),
command=dict(),
subscriptions=dict(type='list'),
handlers=dict(type='list'),
interval=dict(type='int'),
cron=dict(),
publish=dict(type='bool'),
timeout=dict(type='int'),
ttl=dict(type='int'),
stdin=dict(type='bool'),
env_vars=dict(type='dict'),
low_flap_threshold=dict(type='int'),
high_flap_threshold=dict(type='int'),
runtime_assets=dict(type='list'),
check_hooks=dict(type='dict'),
proxy_entity_name=dict(),
proxy_requests=dict(type='dict',
options=dict(
entity_attributes=dict(type='list'),
splay=dict(type='bool'),
splay_coverage=dict(type='int'))),
output_metric_format=dict(choices=[
'nagios_perfdata', 'graphite_plaintext', 'influxdb_line',
'opentsdb_line'
]),
output_metric_handlers=dict(type='list'),
round_robin=dict(type='bool')))
validate_module_params(module)
client = arguments.get_sensu_client(module.params['auth'])
path = utils.build_core_v2_path(
module.params['namespace'],
'checks',
module.params['name'],
)
payload = build_api_payload(module.params)
try:
changed, check = utils.sync(
module.params['state'],
client,
path,
payload,
module.check_mode,
)
module.exit_json(changed=changed, object=check)
except errors.Error as e:
module.fail_json(msg=str(e))
