def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(
dict(template_name=dict(type='str', required=True),
omit_date=dict(type='bool', required=False, default=False),
format=dict(type='str', choices=['json', 'xml'], default='json')))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False)
template_name = module.params['template_name']
omit_date = module.params['omit_date']
format = module.params['format']
template_info = TemplateInfo(module)
template_id = template_info.get_template_id(template_name)
if not template_id:
module.fail_json(msg='Template not found: %s' % template_name)
if format == 'json':
module.exit_json(changed=False,
template_json=template_info.dump_template(
template_id,
template_type='json',
omit_date=omit_date))
elif format == 'xml':
module.exit_json(changed=False,
template_xml=template_info.dump_template(
template_id,
template_type='xml',
omit_date=omit_date))
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(
dict(
name=dict(type='str', required=True),
parent=dict(type='str', required=False),
sla=dict(type='float', required=False),
calculate_sla=dict(type='bool', required=False, default=False),
algorithm=dict(default='one_child',
required=False,
choices=['no', 'one_child', 'all_children']),
trigger_name=dict(type='str', required=False),
trigger_host=dict(type='str', required=False),
state=dict(default="present", choices=['present', 'absent']),
))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
name = module.params['name']
parent = module.params['parent']
sla = module.params['sla']
calculate_sla = module.params['calculate_sla']
algorithm = module.params['algorithm']
trigger_name = module.params['trigger_name']
trigger_host = module.params['trigger_host']
state = module.params['state']
# Load service module
service = Service(module)
service_ids = service.get_service_ids(name)
if service_ids:
service.dump_services(service_ids)
# Delete service
if state == "absent":
if not service_ids:
module.exit_json(changed=False,
msg="Service not found, no change: %s" % name)
service.delete_service(service_ids)
module.exit_json(changed=True,
result="Successfully deleted service(s) %s" % name)
elif state == "present":
if (trigger_name and not trigger_host) or (trigger_host
and not trigger_name):
module.fail_json(
msg=
"Specify either both trigger_host and trigger_name or none to create or update a service"
)
# Does not exists going to create it
if not service_ids:
service.create_service(name, parent, sla, calculate_sla,
trigger_name, trigger_host, algorithm)
module.exit_json(changed=True, msg="Service %s created" % name)
# Else we update it if needed
else:
service.update_service(service_ids[0], name, parent, sla,
calculate_sla, trigger_name, trigger_host,
algorithm)
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(dict(
host_identifier=dict(type='str', required=True),
host_id_type=dict(
default='hostname',
type='str',
choices=['hostname', 'visible_name', 'hostid']),
trigger_severity=dict(
type='str',
required=False,
default='average',
choices=['not_classified', 'information', 'warning', 'average', 'high', 'disaster']),
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
trigger_severity_map = {'not_classified': 0, 'information': 1, 'warning': 2, 'average': 3, 'high': 4, 'disaster': 5}
host_id = module.params['host_identifier']
host_id_type = module.params['host_id_type']
trigger_severity = trigger_severity_map[module.params['trigger_severity']]
host_inventory = 'hostid'
host = Host(module)
if host_id_type == 'hostname':
zabbix_host = host.get_host(host_id, host_inventory, 'host')
host_id = zabbix_host['hostid']
elif host_id_type == 'visible_name':
zabbix_host = host.get_host(host_id, host_inventory, 'name')
host_id = zabbix_host['hostid']
elif host_id_type == 'hostid':
''' check hostid exist'''
zabbix_host = host.get_host(host_id, host_inventory, 'hostid')
triggers = host.get_triggers_by_host_id_in_problem_state(host_id, trigger_severity)
triggers_ok = []
triggers_problem = []
for trigger in triggers:
# tGet last event for trigger with problem value = 1
# https://www.zabbix.com/documentation/3.4/manual/api/reference/trigger/object
if int(trigger['value']) == 1:
event = host.get_last_event_by_trigger_id(trigger['triggerid'])
trigger['last_event'] = event
triggers_problem.append(trigger)
else:
triggers_ok.append(trigger)
module.exit_json(ok=True, triggers_ok=triggers_ok, triggers_problem=triggers_problem)
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(dict(alias=dict(type='str', required=True), ))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
alias = module.params['alias']
user = User(module)
zabbix_user = user.get_user_by_user_alias(alias)
module.exit_json(changed=False, zabbix_user=zabbix_user)
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(
dict(
host_groups=dict(type='list',
required=True,
aliases=['host_group']),
state=dict(type='str',
default="present",
choices=['present', 'absent']),
))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if not HAS_ZABBIX_API:
module.fail_json(msg=missing_required_lib(
'zabbix-api', url='https://pypi.org/project/zabbix-api/'),
exception=ZBX_IMP_ERR)
host_groups = module.params['host_groups']
state = module.params['state']
hostGroup = HostGroup(module)
group_ids = []
group_list = []
if host_groups:
group_ids, group_list = hostGroup.get_group_ids(host_groups)
if state == "absent":
# delete host groups
if group_ids:
delete_group_names = []
hostGroup.delete_host_group(group_ids)
for group in group_list:
delete_group_names.append(group['name'])
module.exit_json(changed=True,
result="Successfully deleted host group(s): %s." %
",".join(delete_group_names))
else:
module.exit_json(changed=False,
result="No host group(s) to delete.")
else:
# create host groups
group_add_list = hostGroup.create_host_group(host_groups)
if len(group_add_list) > 0:
module.exit_json(changed=True,
result="Successfully created host group(s): %s" %
group_add_list)
else:
module.exit_json(changed=False)
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(dict(
host_name=dict(type='str', required=True),
macro_name=dict(type='str', required=True),
macro_value=dict(type='str', required=False),
macro_type=dict(type='str', default='text', choices=['text', 'secret', 'vault']),
state=dict(type='str', default='present', choices=['present', 'absent']),
force=dict(type='bool', default=True)
))
module = AnsibleModule(
argument_spec=argument_spec,
required_if=[
['state', 'present', ['macro_value']]
],
supports_check_mode=True
)
host_name = module.params['host_name']
macro_name = normalize_macro_name(module.params['macro_name'])
macro_value = module.params['macro_value']
state = module.params['state']
force = module.params['force']
if module.params['macro_type'] == 'secret':
macro_type = '1'
elif module.params['macro_type'] == 'vault':
macro_type = '2'
else:
macro_type = '0'
host_macro_class_obj = HostMacro(module)
if host_name:
host_id = host_macro_class_obj.get_host_id(host_name)
host_macro_obj = host_macro_class_obj.get_host_macro(macro_name, host_id)
if state == 'absent':
if not host_macro_obj:
module.exit_json(changed=False, msg="Host Macro %s does not exist" % macro_name)
else:
# delete a macro
host_macro_class_obj.delete_host_macro(host_macro_obj, macro_name)
else:
if not host_macro_obj:
# create host macro
host_macro_class_obj.create_host_macro(macro_name, macro_value, macro_type, host_id)
elif force:
# update host macro
host_macro_class_obj.update_host_macro(host_macro_obj, macro_name, macro_value, macro_type)
else:
module.exit_json(changed=False, result="Host macro %s already exists and force is set to no" % macro_name)
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(dict(
host_name=dict(type='str', default='', required=False),
host_ip=dict(type='list', default=[], required=False),
exact_match=dict(type='bool', required=False, default=False),
remove_duplicate=dict(type='bool', required=False, default=True),
host_inventory=dict(type='list', default=[], required=False)
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
if module._name == 'zabbix_host_facts':
module.deprecate("The 'zabbix_host_facts' module has been renamed to 'zabbix_host_info'",
collection_name="community.zabbix", version='2.0.0') # was 2.13
host_name = module.params['host_name']
host_ips = module.params['host_ip']
exact_match = module.params['exact_match']
is_remove_duplicate = module.params['remove_duplicate']
host_inventory = module.params['host_inventory']
if not host_inventory:
host_inventory = 'extend'
host = Host(module)
if host_name:
hosts = host.get_hosts_by_host_name(host_name, exact_match, host_inventory)
if is_remove_duplicate:
hosts = host.delete_duplicate_hosts(hosts)
extended_hosts = []
for zabbix_host in hosts:
zabbix_host['hostinterfaces'] = host._zapi.hostinterface.get({
'output': 'extend', 'hostids': zabbix_host['hostid']
})
extended_hosts.append(zabbix_host)
module.exit_json(ok=True, hosts=extended_hosts)
elif host_ips:
extended_hosts = host.get_hosts_by_ip(host_ips, host_inventory)
if is_remove_duplicate:
hosts = host.delete_duplicate_hosts(extended_hosts)
module.exit_json(ok=True, hosts=extended_hosts)
else:
module.exit_json(ok=False, hosts=[], result="No Host present")
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(dict(
name=dict(type='str', required=True, aliases=['map_name']),
data=dict(type='str', required=False, aliases=['dot_data']),
width=dict(type='int', default=800),
height=dict(type='int', default=600),
state=dict(type='str', default="present", choices=['present', 'absent']),
default_image=dict(type='str', required=False, aliases=['image']),
margin=dict(type='int', default=40),
expand_problem=dict(type='bool', default=True),
highlight=dict(type='bool', default=True),
label_type=dict(type='str', default='name', choices=['label', 'ip', 'name', 'status', 'nothing', 'custom']),
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
if not HAS_PYDOTPLUS:
module.fail_json(msg=missing_required_lib('pydotplus', url='https://pypi.org/project/pydotplus/'), exception=PYDOT_IMP_ERR)
if not HAS_WEBCOLORS:
module.fail_json(msg=missing_required_lib('webcolors', url='https://pypi.org/project/webcolors/'), exception=WEBCOLORS_IMP_ERR)
if not HAS_PIL:
module.fail_json(msg=missing_required_lib('Pillow', url='https://pypi.org/project/Pillow/'), exception=PIL_IMP_ERR)
sysmap = Map(module)
if sysmap.state == "absent":
if sysmap.map_exists():
sysmap.delete_map()
module.exit_json(changed=True, result="Successfully deleted map: %s" % sysmap.map_name)
else:
module.exit_json(changed=False)
else:
map_config = sysmap.get_map_config()
if sysmap.map_exists():
if sysmap.is_exist_map_correct(map_config):
module.exit_json(changed=False)
else:
sysmap.update_map(map_config)
module.exit_json(changed=True, result="Successfully updated map: %s" % sysmap.map_name)
else:
sysmap.create_map(map_config)
module.exit_json(changed=True, result="Successfully created map: %s" % sysmap.map_name)
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(
dict(hostgroup_name=dict(type='list', required=True), ))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if module._name == 'zabbix_group_facts':
module.deprecate(
"The 'zabbix_group_facts' module has been renamed to 'zabbix_group_info'",
collection_name="community.zabbix",
version='2.0.0') # was 2.13
hostgroup_name = module.params['hostgroup_name']
host = Host(module)
host_groups = host.get_group_ids_by_group_names(hostgroup_name)
module.exit_json(host_groups=host_groups)
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(dict(
proxy_name=dict(type='str', required=True),
proxy_hosts=dict(type='bool', required=False, default=False),
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
name = module.params['proxy_name']
hosts = module.params['proxy_hosts']
proxy = Proxy(module)
result = proxy.get_proxy(name, hosts)
module.exit_json(changed=False, zabbix_proxy=result)
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(
dict(
template_name=dict(type='str', required=False),
template_json=dict(type='json', required=False),
template_xml=dict(type='str', required=False),
template_groups=dict(type='list', required=False),
link_templates=dict(type='list', required=False),
clear_templates=dict(type='list', required=False),
macros=dict(type='list',
elements='dict',
options=dict(macro=dict(type='str', required=True),
value=dict(type='str', required=True))),
omit_date=dict(type='bool', required=False, default=False),
dump_format=dict(type='str',
required=False,
default='json',
choices=['json', 'xml']),
state=dict(type='str',
default="present",
choices=['present', 'absent', 'dump']),
))
module = AnsibleModule(
argument_spec=argument_spec,
required_one_of=[['template_name', 'template_json', 'template_xml']],
mutually_exclusive=[['template_name', 'template_json',
'template_xml']],
required_if=[['state', 'absent', ['template_name']],
['state', 'dump', ['template_name']]],
supports_check_mode=True)
template_name = module.params['template_name']
template_json = module.params['template_json']
template_xml = module.params['template_xml']
template_groups = module.params['template_groups']
link_templates = module.params['link_templates']
clear_templates = module.params['clear_templates']
template_macros = module.params['macros']
omit_date = module.params['omit_date']
dump_format = module.params['dump_format']
state = module.params['state']
template = Template(module)
# Identify template names for IDs retrieval
# Template names are expected to reside in ['zabbix_export']['templates'][*]['template'] for both data types
template_content, template_type = None, None
if template_json is not None:
template_type = 'json'
template_content = template_json
json_parsed = template.load_json_template(template_content)
template_names = list(
t['template'] for t in json_parsed['zabbix_export']['templates'])
elif template_xml is not None:
template_type = 'xml'
template_content = template_xml
xml_parsed = template.load_xml_template(template_content)
template_names = list(
t.find('template').text
for t in list(xml_parsed.find('templates')))
else:
template_names = [template_name]
template_ids = template.get_template_ids(template_names)
if state == "absent":
if not template_ids:
module.exit_json(changed=False,
msg="Template not found. No changed: %s" %
template_name)
template.delete_template(template_ids)
module.exit_json(changed=True,
result="Successfully deleted template %s" %
template_name)
elif state == "dump":
module.deprecate(
"The 'dump' state has been deprecated and will be removed, use 'zabbix_template_info' module instead.",
collection_name="community.zabbix",
version='3.0.0') # was 2.14
if not template_ids:
module.fail_json(msg='Template not found: %s' % template_name)
if dump_format == 'json':
module.exit_json(changed=False,
template_json=template.dump_template(
template_ids,
template_type='json',
omit_date=omit_date))
elif dump_format == 'xml':
module.exit_json(changed=False,
template_xml=template.dump_template(
template_ids,
template_type='xml',
omit_date=omit_date))
elif state == "present":
# Load all subelements for template that were provided by user
group_ids = None
if template_groups is not None:
group_ids = template.get_group_ids_by_group_names(template_groups)
link_template_ids = None
if link_templates is not None:
link_template_ids = template.get_template_ids(link_templates)
clear_template_ids = None
if clear_templates is not None:
clear_template_ids = template.get_template_ids(clear_templates)
if template_macros is not None:
# Zabbix configuration.export does not differentiate python types (numbers are returned as strings)
for macroitem in template_macros:
for key in macroitem:
macroitem[key] = str(macroitem[key])
if not template_ids:
# Assume new templates are being added when no ID's were found
if template_content is not None:
template.import_template(template_content, template_type)
module.exit_json(changed=True,
result="Template import successful")
else:
if group_ids is None:
module.fail_json(
msg=
'template_groups are required when creating a new Zabbix template'
)
template.add_template(template_name, group_ids,
link_template_ids, template_macros)
module.exit_json(changed=True,
result="Successfully added template: %s" %
template_name)
else:
changed = template.check_template_changed(
template_ids, template_groups, link_templates, clear_templates,
template_macros, template_content, template_type)
if module.check_mode:
module.exit_json(changed=changed)
if changed:
if template_type is not None:
template.import_template(template_content, template_type)
else:
template.update_template(template_ids, group_ids,
link_template_ids,
clear_template_ids,
template_macros)
module.exit_json(changed=changed,
result="Template successfully updated")
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(
name=dict(type='str', required=True),
iprange=dict(type='list', required=False, elements='str'),
dchecks=dict(
type='list',
required=False,
aliases=['dcheck'],
elements='dict',
options=dict(
type=dict(type='str', choices=[
'SSH',
'LDAP',
'SMTP',
'FTP',
'HTTP',
'POP',
'NNTP',
'IMAP',
'TCP',
'Zabbix',
'SNMPv1',
'SNMPv2',
'ICMP',
'SNMPv3',
'HTTPS',
'Telnet']
),
ports=dict(type='str'),
key=dict(type='str', no_log=False),
snmp_community=dict(type='str'),
snmpv3_authpassphrase=dict(type='str', no_log=True),
snmpv3_authprotocol=dict(type='str', choices=['MD5', 'SHA']),
snmpv3_contextname=dict(type='str'),
snmpv3_privpassphrase=dict(type='str', no_log=True),
snmpv3_privprotocol=dict(type='str', choices=['DES', 'AES']),
snmpv3_securitylevel=dict(type='str', choices=['noAuthNoPriv', 'authNoPriv', 'authPriv']),
snmpv3_securityname=dict(type='str'),
uniq=dict(type='bool', default=False),
host_source=dict(type='str', choices=['DNS', 'IP', 'discovery'], default='DNS'),
name_source=dict(type='str', choices=['None', 'DNS', 'IP', 'discovery'], default='None')
),
required_if=[
['type', 'SSH', ['ports']],
['type', 'LDAP', ['ports']],
['type', 'SMTP', ['ports']],
['type', 'FTP', ['ports']],
['type', 'HTTP', ['ports']],
['type', 'POP', ['ports']],
['type', 'NNTP', ['ports']],
['type', 'IMAP', ['ports']],
['type', 'TCP', ['ports']],
['type', 'Zabbix', ['ports', 'key']],
['type', 'SNMPv1', ['ports', 'key', 'snmp_community']],
['type', 'SNMPv2', ['ports', 'key', 'snmp_community']],
['type', 'SNMPv3', ['ports', 'key']],
['type', 'HTTPS', ['ports']],
['type', 'Telnet', ['ports']],
['snmpv3_securitylevel', 'authPriv', ['snmpv3_privpassphrase']]
]
),
delay=dict(type='str', required=False, default='1h'),
proxy=dict(type='str', required=False, default=None),
status=dict(type='str', default="enabled", choices=["enabled", "disabled"]),
state=dict(type='str', default='present', choices=['present', 'absent'])
)
module = AnsibleModule(
argument_spec=argument_spec,
required_if=[
['state', 'present', ['name', 'iprange', 'dchecks']],
['state', 'absent', ['name']],
],
supports_check_mode=True
)
state = module.params['state']
name = module.params['name']
iprange = module.params['iprange']
dchecks = module.params['dchecks']
delay = module.params['delay']
proxy = module.params['proxy']
status = module.params['status']
drule = DiscoveryRule(module)
# reuse zabbix-api login
zbx = drule._zapi
dcks = Dchecks(module, zbx)
drule_exists = drule.check_if_drule_exists(name)
if drule_exists:
drule_id = drule.get_drule_by_drule_name(name)['druleid']
if state == "absent":
drule.delete_drule(drule_id)
module.exit_json(changed=True, state=state, drule=name, druleid=drule_id, msg="Discovery Rule deleted: %s, ID: %s" % (name, drule_id))
else:
difference = drule.check_difference(
drule_id=drule_id,
name=name,
iprange=iprange,
dchecks=dcks.construct_the_data(dchecks),
delay=delay,
proxy=proxy,
status=status
)
if difference == {}:
module.exit_json(changed=False, state=state, drule=name, druleid=drule_id, msg="Discovery Rule is up to date: %s" % name)
else:
drule_id = drule.update_drule(
drule_id=drule_id,
**difference
)
module.exit_json(changed=True, state=state, drule=name, druleid=drule_id, msg="Discovery Rule updated: %s, ID: %s" % (name, drule_id))
else:
if state == "absent":
module.exit_json(changed=False, state=state, drule=name, msg="Discovery rule %s does not exist, nothing to delete" % name)
else:
drule_id = drule.add_drule(
name=name,
iprange=iprange,
dchecks=dcks.construct_the_data(dchecks),
delay=delay,
proxy=proxy,
status=status
)
module.exit_json(changed=True, state=state, drule=name, druleid=drule_id, msg="Discovery Rule created: %s, ID: %s" % (name, drule_id))
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(
name=dict(type='str', required=True, aliases=['user_group']),
gui_access=dict(type='str', required=False, default='default', choices=['default', 'internal', 'LDAP', 'disable']),
debug_mode=dict(type='str', required=False, default='disabled', choices=['disabled', 'enabled']),
status=dict(type='str', required=False, default='enabled', choices=['enabled', 'disabled']),
rights=dict(type='list', elements='dict', required=False, options=dict(
host_group=dict(type='str', required=True),
permission=dict(type='str', required=True, choices=['denied', 'read-only', 'read-write'])
)),
tag_filters=dict(type='list', elements='dict', required=False, options=dict(
host_group=dict(type='str', required=True),
tag=dict(type='str', default=''),
value=dict(type='str', default='')
)),
state=dict(type='str', default='present', choices=['present', 'absent'])
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
name = module.params['name']
gui_access = module.params['gui_access']
debug_mode = module.params['debug_mode']
status = module.params['status']
rights = module.params['rights']
tag_filters = module.params['tag_filters']
state = module.params['state']
zbx = None
# login to zabbix
zbx = ZabbixBase(module)
userGroup = UserGroup(module, zbx)
rgts = Rights(module, zbx)
tgflts = TagFilters(module, zbx)
usergroup_exists = userGroup.check_if_usergroup_exists(name)
if usergroup_exists:
usrgrpid = userGroup.get_usergroup_by_usergroup_name(name)['usrgrpid']
if state == 'absent':
userGroup.delete(usrgrpid)
module.exit_json(changed=True, state=state, usergroup=name, usrgrpid=usrgrpid, msg='User group deleted: %s, ID: %s' % (name, usrgrpid))
else:
difference = userGroup.check_difference(
usrgrpid=usrgrpid,
name=name,
gui_access=gui_access,
debug_mode=debug_mode,
status=status,
rights=rgts.construct_the_data(rights),
tag_filters=tgflts.construct_the_data(tag_filters)
)
if difference == {}:
module.exit_json(changed=False, state=state, usergroup=name, usrgrpid=usrgrpid, msg='User group is up to date: %s' % name)
else:
userGroup.update(
usrgrpid=usrgrpid,
**difference
)
module.exit_json(changed=True, state=state, usergroup=name, usrgrpid=usrgrpid, msg='User group updated: %s, ID: %s' % (name, usrgrpid))
else:
if state == 'absent':
module.exit_json(changed=False, state=state, usergroup=name, msg='User group %s does not exists, nothing to delete' % name)
else:
usrgrpid = userGroup.add(
name=name,
gui_access=gui_access,
debug_mode=debug_mode,
status=status,
rights=rgts.construct_the_data(rights),
tag_filters=tgflts.construct_the_data(tag_filters)
)
module.exit_json(changed=True, state=state, usergroup=name, usrgrpid=usrgrpid, msg='User group created: %s, ID: %s' % (name, usrgrpid))
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(
dict(
name=dict(type='str', required=True),
description=dict(type='str', required=False, default=''),
state=dict(type='str',
default='present',
choices=['present', 'absent']),
type=dict(type='str',
choices=[
'email', 'script', 'sms', 'webhook', 'jabber',
'ez_texting'
],
required=True),
status=dict(type='str',
default='enabled',
choices=['enabled', 'disabled'],
required=False),
max_sessions=dict(type='int', default=1, required=False),
max_attempts=dict(type='int', default=3, required=False),
attempt_interval=dict(type='int', default=10, required=False),
# Script
script_name=dict(type='str', required=False),
script_params=dict(type='list', required=False),
# SMS
gsm_modem=dict(type='str', required=False),
# Jabber
username=dict(type='str', required=False),
password=dict(type='str', required=False, no_log=True),
# Email
smtp_server=dict(type='str', default='localhost', required=False),
smtp_server_port=dict(type='int', default=25, required=False),
smtp_helo=dict(type='str', default='localhost', required=False),
smtp_email=dict(type='str', required=False),
smtp_security=dict(type='str',
required=False,
choices=['None', 'STARTTLS', 'SSL/TLS']),
smtp_authentication=dict(type='bool',
default=False,
required=False),
smtp_verify_host=dict(type='bool', default=False, required=False),
smtp_verify_peer=dict(type='bool', default=False, required=False),
# EZ Text
message_text_limit=dict(type='str',
required=False,
choices=['USA', 'Canada']),
# Webhook
webhook_script=dict(type='str'),
webhook_timeout=dict(type='str', default='30s'),
process_tags=dict(type='bool', default=False),
event_menu=dict(type='bool', default=False),
event_menu_url=dict(type='str'),
event_menu_name=dict(type='str'),
webhook_params=dict(type='list',
elements='dict',
default=[],
required=False,
options=dict(name=dict(type='str',
required=True),
value=dict(type='str',
default=''))),
message_templates=dict(
type='list',
elements='dict',
default=[],
required=False,
options=dict(eventsource=dict(type='str',
choices=[
'triggers', 'discovery',
'autoregistration',
'internal'
]),
recovery=dict(type='str',
choices=[
'operations',
'recovery_operations',
'update_operations'
]),
subject=dict(type='str', default=''),
body=dict(type='str', default='')),
required_together=[['eventsource', 'recovery']],
)))
# this is used to simulate `required_if` of `AnsibleModule`, but only when state=present
required_params = [
['type', 'email', ['smtp_email']], ['type', 'script', ['script_name']],
['type', 'sms', ['gsm_modem']],
['type', 'jabber', ['username', 'password']],
['type', 'ez_texting', ['username', 'password', 'message_text_limit']],
['type', 'webhook', ['webhook_script']],
['event_menu', True, ['event_menu_url', 'event_menu_name']],
['smtp_authentication', True, ['username', 'password']]
]
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
state = module.params['state']
name = module.params['name']
mediatype = MediaTypeModule(module)
if module.params['state'] == 'present':
mediatype.validate_params(required_params)
mediatype_exists, mediatype_id = mediatype.check_if_mediatype_exists(name)
parameters = mediatype.construct_parameters()
if mediatype_exists:
if state == 'absent':
if module.check_mode:
module.exit_json(
changed=True,
msg=
"Mediatype would have been deleted. Name: {name}, ID: {_id}"
.format(name=name, _id=mediatype_id))
mediatype_id = mediatype.delete_mediatype(mediatype_id)
module.exit_json(
changed=True,
msg="Mediatype deleted. Name: {name}, ID: {_id}".format(
name=name, _id=mediatype_id))
else:
params_to_update, diff = mediatype.get_update_params(
mediatype_id, **parameters)
if params_to_update == {}:
module.exit_json(
changed=False,
msg="Mediatype is up to date: {name}".format(name=name))
else:
if module.check_mode:
module.exit_json(
changed=True,
diff=diff,
msg=
"Mediatype would have been updated. Name: {name}, ID: {_id}"
.format(name=name, _id=mediatype_id))
mediatype_id = mediatype.update_mediatype(
mediatypeid=mediatype_id, **params_to_update)
module.exit_json(
changed=True,
diff=diff,
msg="Mediatype updated. Name: {name}, ID: {_id}".format(
name=name, _id=mediatype_id))
else:
if state == "absent":
module.exit_json(changed=False)
else:
if module.check_mode:
module.exit_json(
changed=True,
msg=
"Mediatype would have been created. Name: {name}, ID: {_id}"
.format(name=name, _id=mediatype_id))
mediatype_id = mediatype.create_mediatype(**parameters)
module.exit_json(changed=True,
msg="Mediatype created: {name}, ID: {_id}".format(
name=name, _id=mediatype_id))
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(dict(
host_name=dict(type='str', required=True),
host_groups=dict(type='list', required=False),
link_templates=dict(type='list', required=False),
status=dict(type='str', default="enabled", choices=['enabled', 'disabled']),
state=dict(type='str', default="present", choices=['present', 'absent']),
inventory_mode=dict(type='str', required=False, choices=['automatic', 'manual', 'disabled']),
ipmi_authtype=dict(type='int', default=None),
ipmi_privilege=dict(type='int', default=None),
ipmi_username=dict(type='str', required=False, default=None),
ipmi_password=dict(type='str', required=False, default=None, no_log=True),
tls_connect=dict(type='int', default=1),
tls_accept=dict(type='int', default=1),
tls_psk_identity=dict(type='str', required=False),
tls_psk=dict(type='str', required=False),
ca_cert=dict(type='str', required=False, aliases=['tls_issuer']),
tls_subject=dict(type='str', required=False),
inventory_zabbix=dict(type='dict', required=False),
interfaces=dict(
type='list',
elements='dict',
default=[],
options=dict(
type=dict(type='str', required=True, choices=['agent', '1', 'snmp', '2', 'ipmi', '3', 'jmx', '4']),
main=dict(type='int', choices=[0, 1], default=0),
useip=dict(type='int', choices=[0, 1], default=0),
ip=dict(type='str', default=''),
dns=dict(type='str', default=''),
port=dict(type='str'),
bulk=dict(type='int', choices=[0, 1], default=1),
details=dict(
type='dict',
default={},
options=dict(
version=dict(type='int', choices=[1, 2, 3], default=2),
bulk=dict(type='int', choices=[0, 1], default=1),
community=dict(type='str'),
securityname=dict(type='str', default=''),
contextname=dict(type='str', default=''),
securitylevel=dict(type='int', choices=[0, 1, 2], default=0),
authprotocol=dict(type='int', choices=[0, 1], default=0),
authpassphrase=dict(type='str', default='', no_log=True),
privprotocol=dict(type='int', choices=[0, 1], default=0),
privpassphrase=dict(type='str', default='', no_log=True)
)
)
),
required_if=[
['useip', 0, ['dns']],
['useip', 1, ['ip']]
]
),
force=dict(type='bool', default=True),
proxy=dict(type='str', required=False),
visible_name=dict(type='str', required=False),
description=dict(type='str', required=False),
macros=dict(
type='list',
elements='dict',
aliases=['user_macros'],
options=dict(
macro=dict(type='str', required=True),
value=dict(type='str', required=True),
description=dict(type='str', default=''),
type=dict(type='str', default='text', choices=['text', 'secret'])
)
),
tags=dict(
type='list',
elements='dict',
aliases=['host_tags'],
options=dict(
tag=dict(type='str', required=True),
value=dict(type='str', default='')
)
)
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
host_name = module.params['host_name']
visible_name = module.params['visible_name']
description = module.params['description']
host_groups = module.params['host_groups']
link_templates = module.params['link_templates']
inventory_mode = module.params['inventory_mode']
ipmi_authtype = module.params['ipmi_authtype']
ipmi_privilege = module.params['ipmi_privilege']
ipmi_username = module.params['ipmi_username']
ipmi_password = module.params['ipmi_password']
tls_connect = module.params['tls_connect']
tls_accept = module.params['tls_accept']
tls_psk_identity = module.params['tls_psk_identity']
tls_psk = module.params['tls_psk']
tls_issuer = module.params['ca_cert']
tls_subject = module.params['tls_subject']
inventory_zabbix = module.params['inventory_zabbix']
status = module.params['status']
state = module.params['state']
interfaces = module.params['interfaces']
force = module.params['force']
proxy = module.params['proxy']
macros = module.params['macros']
tags = module.params['tags']
# convert enabled to 0; disabled to 1
status = 1 if status == "disabled" else 0
host = Host(module)
template_ids = []
if link_templates:
template_ids = host.get_template_ids(link_templates)
group_ids = []
if host_groups:
group_ids = host.get_group_ids_by_group_names(host_groups)
interfaces, ip = host.construct_host_interfaces(interfaces)
if macros:
# convert macros to zabbix native format - {$MACRO}
for macro in macros:
macro['macro'] = normalize_macro_name(macro['macro'])
if LooseVersion(host._zbx_api_version) <= LooseVersion('4.4.0'):
if 'description' in macro:
macro.pop('description', False)
if 'type' in macro:
if LooseVersion(host._zbx_api_version) < LooseVersion('5.0.0'):
macro.pop('type')
else:
if macro['type'] == 'text':
macro['type'] = 0
elif macro['type'] == 'secret':
macro['type'] = 1
# Use proxy specified, or set to 0
if proxy:
proxy_id = host.get_proxyid_by_proxy_name(proxy)
else:
proxy_id = 0
# check if host exist
is_host_exist = host.is_host_exist(host_name)
if is_host_exist:
# get host id by host name
zabbix_host_obj = host.get_host_by_host_name(host_name)
host_id = zabbix_host_obj['hostid']
# If proxy is not specified as a module parameter, use the existing setting
if proxy is None:
proxy_id = int(zabbix_host_obj['proxy_hostid'])
if state == "absent":
# remove host
host.delete_host(host_id, host_name)
module.exit_json(changed=True, result="Successfully delete host %s" % host_name)
else:
if not host_groups:
# if host_groups have not been specified when updating an existing host, just
# get the group_ids from the existing host without updating them.
group_ids = host.get_group_ids_by_host_id(host_id)
# get existing host's interfaces
exist_interfaces = host._zapi.hostinterface.get({'output': 'extend', 'hostids': host_id})
exist_interfaces.sort(key=lambda x: int(x['interfaceid']))
# When force=no is specified, append existing interfaces to interfaces to update. When
# no interfaces have been specified, copy existing interfaces as specified from the API.
# Do the same with templates and host groups.
if not force or not interfaces:
for interface in copy.deepcopy(exist_interfaces):
# remove values not used during hostinterface.add/update calls
for key in tuple(interface.keys()):
if key in ['interfaceid', 'hostid']:
interface.pop(key, None)
for index in interface.keys():
if index in ['useip', 'main', 'type', 'bulk']:
interface[index] = int(interface[index])
elif index == 'details' and not interface[index]:
interface[index] = {}
if interface not in interfaces:
interfaces.append(interface)
if not force or link_templates is None:
template_ids = list(set(template_ids + host.get_host_templates_by_host_id(host_id)))
if not force:
for group_id in host.get_group_ids_by_host_id(host_id):
if group_id not in group_ids:
group_ids.append(group_id)
# Macros not present in host.update will be removed if we dont copy them when force=no
if macros is not None and 'macros' in zabbix_host_obj.keys():
provided_macros = [m['macro'] for m in macros]
existing_macros = zabbix_host_obj['macros']
for macro in existing_macros:
if macro['macro'] not in provided_macros:
macros.append(macro)
# Tags not present in host.update will be removed if we dont copy them when force=no
if tags is not None and 'tags' in zabbix_host_obj.keys():
provided_tags = [t['tag'] for t in tags]
existing_tags = zabbix_host_obj['tags']
for tag in existing_tags:
if tag['tag'] not in provided_tags:
tags.append(tag)
# update host
if host.check_all_properties(
host_id, group_ids, status, interfaces, template_ids, exist_interfaces, zabbix_host_obj, proxy_id,
visible_name, description, host_name, inventory_mode, inventory_zabbix, tls_accept,
tls_psk_identity, tls_psk, tls_issuer, tls_subject, tls_connect, ipmi_authtype, ipmi_privilege,
ipmi_username, ipmi_password, macros, tags):
host.update_host(
host_name, group_ids, status, host_id, interfaces, exist_interfaces, proxy_id, visible_name,
description, tls_connect, tls_accept, tls_psk_identity, tls_psk, tls_issuer, tls_subject,
ipmi_authtype, ipmi_privilege, ipmi_username, ipmi_password, macros, tags)
host.link_or_clear_template(
host_id, template_ids, tls_connect, tls_accept, tls_psk_identity, tls_psk, tls_issuer,
tls_subject, ipmi_authtype, ipmi_privilege, ipmi_username, ipmi_password)
host.update_inventory_mode(host_id, inventory_mode)
host.update_inventory_zabbix(host_id, inventory_zabbix)
module.exit_json(changed=True,
result="Successfully update host %s (%s) and linked with template '%s'"
% (host_name, ip, link_templates))
else:
module.exit_json(changed=False)
else:
if state == "absent":
# the host is already deleted.
module.exit_json(changed=False)
if not group_ids:
module.fail_json(msg="Specify at least one group for creating host '%s'." % host_name)
if not interfaces or (interfaces and len(interfaces) == 0):
if LooseVersion(host._zbx_api_version) < LooseVersion('5.2.0'):
module.fail_json(msg="Specify at least one interface for creating host '%s'." % host_name)
# create host
host_id = host.add_host(
host_name, group_ids, status, interfaces, proxy_id, visible_name, description, tls_connect, tls_accept,
tls_psk_identity, tls_psk, tls_issuer, tls_subject, ipmi_authtype, ipmi_privilege, ipmi_username,
ipmi_password, macros, tags)
host.link_or_clear_template(
host_id, template_ids, tls_connect, tls_accept, tls_psk_identity, tls_psk, tls_issuer, tls_subject,
ipmi_authtype, ipmi_privilege, ipmi_username, ipmi_password)
host.update_inventory_mode(host_id, inventory_mode)
host.update_inventory_zabbix(host_id, inventory_zabbix)
module.exit_json(changed=True, result="Successfully added host %s (%s) and linked with template '%s'" % (
host_name, ip, link_templates))
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(
dict(screens=dict(type='list',
elements='dict',
required=True,
options=dict(
screen_name=dict(type='str', required=True),
host_group=dict(type='list',
aliases=['host_groups'],
elements='str'),
state=dict(type='str',
default='present',
choices=['absent', 'present']),
graph_names=dict(type='list', elements='str'),
graph_width=dict(type='int', default=None),
graph_height=dict(type='int', default=None),
graphs_in_row=dict(type='int', default=3),
sort=dict(default=False, type='bool'),
),
required_if=[['state', 'present', ['host_group']]])))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
screens = module.params['screens']
screen = Screen(module)
created_screens = []
changed_screens = []
deleted_screens = []
for zabbix_screen in screens:
screen_name = zabbix_screen['screen_name']
screen_id = screen.get_screen_id(screen_name)
state = zabbix_screen['state']
sort = zabbix_screen['sort']
if state == "absent":
if screen_id:
screen_item_list = screen.get_screen_items(screen_id)
screen_item_id_list = []
for screen_item in screen_item_list:
screen_item_id = screen_item['screenitemid']
screen_item_id_list.append(screen_item_id)
screen.delete_screen_items(screen_id, screen_item_id_list)
screen.delete_screen(screen_id, screen_name)
deleted_screens.append(screen_name)
else:
host_group = zabbix_screen['host_group']
graph_names = zabbix_screen['graph_names']
graphs_in_row = zabbix_screen['graphs_in_row']
graph_width = zabbix_screen['graph_width']
graph_height = zabbix_screen['graph_height']
host_group_ids = screen.get_host_group_ids(host_group)
hosts = screen.get_host_ids_by_group_ids(host_group_ids, sort)
if not hosts:
module.fail_json(
msg="No hosts found belongin to all given groups: %s" %
host_group)
screen_item_id_list = []
resource_id_list = []
graph_ids, v_size = screen.get_graph_ids(hosts, graph_names)
h_size, v_size = screen.get_hsize_vsize(hosts, v_size,
graphs_in_row)
if not screen_id:
# create screen
screen_id = screen.create_screen(screen_name, h_size, v_size)
screen.create_screen_items(screen_id, hosts, graph_names,
graph_width, graph_height, h_size,
graphs_in_row)
created_screens.append(screen_name)
else:
screen_item_list = screen.get_screen_items(screen_id)
for screen_item in screen_item_list:
screen_item_id = screen_item['screenitemid']
resource_id = screen_item['resourceid']
screen_item_id_list.append(screen_item_id)
resource_id_list.append(resource_id)
# when the screen items changed, then update
if graph_ids != resource_id_list:
deleted = screen.delete_screen_items(
screen_id, screen_item_id_list)
if deleted:
screen.update_screen(screen_id, screen_name, h_size,
v_size)
screen.create_screen_items(screen_id, hosts,
graph_names, graph_width,
graph_height, h_size,
graphs_in_row)
changed_screens.append(screen_name)
if created_screens and changed_screens:
module.exit_json(
changed=True,
result=
"Successfully created screen(s): %s, and updated screen(s): %s" %
(",".join(created_screens), ",".join(changed_screens)))
elif created_screens:
module.exit_json(changed=True,
result="Successfully created screen(s): %s" %
",".join(created_screens))
elif changed_screens:
module.exit_json(changed=True,
result="Successfully updated screen(s): %s" %
",".join(changed_screens))
elif deleted_screens:
module.exit_json(changed=True,
result="Successfully deleted screen(s): %s" %
",".join(deleted_screens))
else:
module.exit_json(changed=False)
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(
dict(name=dict(type='str', required=True),
state=dict(type='str',
default='present',
choices=['present', 'absent']),
mappings=dict(type='list',
elements='dict',
options=dict(value=dict(type='str', required=True),
map_to=dict(type='str',
required=True)))))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'present', ['mappings']],
])
vm = ValuemapModule(module)
name = module.params['name']
state = module.params['state']
mappings = module.params['mappings']
valuemap_exists, valuemap_object = vm.check_if_valuemap_exists(name)
parameters = construct_parameters(name=name, mappings=mappings)
if valuemap_exists:
valuemap_id = valuemap_object['valuemapid']
if state == 'absent':
if module.check_mode:
module.exit_json(
changed=True,
msg=
"Value map would have been deleted. Name: {name}, ID: {_id}"
.format(name=name, _id=valuemap_id))
valuemap_id = vm.delete(valuemap_id)
module.exit_json(
changed=True,
msg="Value map deleted. Name: {name}, ID: {_id}".format(
name=name, _id=valuemap_id))
else:
params_to_update, diff = get_update_params(valuemap_object,
**parameters)
if params_to_update == {}:
module.exit_json(
changed=False,
msg="Value map is up to date: {name}".format(name=name))
else:
if module.check_mode:
module.exit_json(
changed=True,
diff=diff,
msg=
"Value map would have been updated. Name: {name}, ID: {_id}"
.format(name=name, _id=valuemap_id))
valuemap_id = vm.update(valuemapid=valuemap_id,
**params_to_update)
module.exit_json(
changed=True,
diff=diff,
msg="Value map updated. Name: {name}, ID: {_id}".format(
name=name, _id=valuemap_id))
else:
if state == "absent":
module.exit_json(changed=False)
else:
if module.check_mode:
module.exit_json(
changed=True,
msg=
"Value map would have been created. Name: {name}, ID: {_id}"
.format(name=name, _id=valuemap_id))
valuemap_id = vm.create(**parameters)
module.exit_json(changed=True,
msg="Value map created: {name}, ID: {_id}".format(
name=name, _id=valuemap_id))
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(
dict(
state=dict(type='str',
required=False,
default='present',
choices=['present', 'absent']),
host_names=dict(type='list',
required=False,
default=None,
aliases=['host_name']),
minutes=dict(type='int', required=False, default=10),
host_groups=dict(type='list',
required=False,
default=None,
aliases=['host_group']),
name=dict(type='str', required=True),
desc=dict(type='str', required=False,
default="Created by Ansible"),
collect_data=dict(type='bool', required=False, default=True),
))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
maint = MaintenanceModule(module)
host_names = module.params['host_names']
host_groups = module.params['host_groups']
state = module.params['state']
minutes = module.params['minutes']
name = module.params['name']
desc = module.params['desc']
collect_data = module.params['collect_data']
if collect_data:
maintenance_type = 0
else:
maintenance_type = 1
changed = False
if state == "present":
if not host_names and not host_groups:
module.fail_json(
msg=
"At least one host_name or host_group must be defined for each created maintenance."
)
now = datetime.datetime.now().replace(second=0)
start_time = time.mktime(now.timetuple())
period = 60 * int(minutes) # N * 60 seconds
if host_groups:
(rc, group_ids, error) = maint.get_group_ids(host_groups)
if rc != 0:
module.fail_json(msg="Failed to get group_ids: %s" % error)
else:
group_ids = []
if host_names:
(rc, host_ids, error) = maint.get_host_ids(host_names)
if rc != 0:
module.fail_json(msg="Failed to get host_ids: %s" % error)
else:
host_ids = []
(rc, maintenance, error) = maint.get_maintenance(name)
if rc != 0:
module.fail_json(
msg="Failed to check maintenance %s existence: %s" %
(name, error))
if maintenance and (
sorted(group_ids) != sorted(maintenance["groupids"])
or sorted(host_ids) != sorted(maintenance["hostids"])
or str(maintenance_type) != maintenance["maintenance_type"]
or str(int(start_time)) != maintenance["active_since"]
or str(int(start_time + period)) != maintenance["active_till"]
or str(desc) != maintenance['description']):
if module.check_mode:
changed = True
else:
(rc, data, error) = maint.update_maintenance(
maintenance["maintenanceid"], group_ids, host_ids,
start_time, maintenance_type, period, desc)
if rc == 0:
changed = True
else:
module.fail_json(msg="Failed to update maintenance: %s" %
error)
if not maintenance:
if module.check_mode:
changed = True
else:
(rc, data, error) = maint.create_maintenance(
group_ids, host_ids, start_time, maintenance_type, period,
name, desc)
if rc == 0:
changed = True
else:
module.fail_json(msg="Failed to create maintenance: %s" %
error)
if state == "absent":
(rc, maintenance, error) = maint.get_maintenance(name)
if rc != 0:
module.fail_json(
msg="Failed to check maintenance %s existence: %s" %
(name, error))
if maintenance:
if module.check_mode:
changed = True
else:
(rc, data, error) = maint.delete_maintenance(
maintenance["maintenanceid"])
if rc == 0:
changed = True
else:
module.fail_json(msg="Failed to remove maintenance: %s" %
error)
module.exit_json(changed=changed)
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(
dict(state=dict(type='str',
required=False,
default='present',
choices=['present', 'absent']),
host_names=dict(type='list',
required=False,
default=None,
aliases=['host_name']),
minutes=dict(type='int', required=False, default=10),
host_groups=dict(type='list',
required=False,
default=None,
aliases=['host_group']),
name=dict(type='str', required=True),
desc=dict(type='str',
required=False,
default="Created by Ansible"),
collect_data=dict(type='bool', required=False, default=True),
visible_name=dict(type='bool', required=False, default=True),
tags=dict(type='list',
elements='dict',
required=False,
options=dict(tag=dict(type='str', required=True),
operator=dict(type='int', default=2),
value=dict(type='str', default='')))))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
maint = MaintenanceModule(module)
host_names = module.params['host_names']
host_groups = module.params['host_groups']
state = module.params['state']
minutes = module.params['minutes']
name = module.params['name']
desc = module.params['desc']
collect_data = module.params['collect_data']
visible_name = module.params['visible_name']
tags = module.params['tags']
if collect_data:
maintenance_type = 0
else:
maintenance_type = 1
if tags is not None:
module.fail_json(
msg=
"Tags cannot be provided for maintenance without data collection."
)
if visible_name:
zabbix_host = "name"
else:
zabbix_host = "host"
changed = False
if state == "present":
if not host_names and not host_groups:
module.fail_json(
msg=
"At least one host_name or host_group must be defined for each created maintenance."
)
now = datetime.datetime.now().replace(second=0)
start_time = time.mktime(now.timetuple())
period = 60 * int(minutes) # N * 60 seconds
if host_groups:
(rc, group_ids, error) = maint.get_group_ids(host_groups)
if rc != 0:
module.fail_json(msg="Failed to get group_ids: %s" % error)
else:
group_ids = []
if host_names:
(rc, host_ids, error) = maint.get_host_ids(host_names, zabbix_host)
if rc != 0:
module.fail_json(msg="Failed to get host_ids: %s" % error)
else:
host_ids = []
(rc, maintenance, error) = maint.get_maintenance(name)
if rc != 0:
module.fail_json(
msg="Failed to check maintenance %s existence: %s" %
(name, error))
if maintenance and maint.check_maint_properties(
maintenance, group_ids, host_ids, maintenance_type, start_time,
period, desc, tags):
if module.check_mode:
changed = True
else:
(rc, data, error) = maint.update_maintenance(
maintenance["maintenanceid"], group_ids, host_ids,
start_time, maintenance_type, period, desc, tags)
if rc == 0:
changed = True
else:
module.fail_json(msg="Failed to update maintenance: %s" %
error)
if not maintenance:
if module.check_mode:
changed = True
else:
(rc, data, error) = maint.create_maintenance(
group_ids, host_ids, start_time, maintenance_type, period,
name, desc, tags)
if rc == 0:
changed = True
else:
module.fail_json(msg="Failed to create maintenance: %s" %
error)
if state == "absent":
(rc, maintenance, error) = maint.get_maintenance(name)
if rc != 0:
module.fail_json(
msg="Failed to check maintenance %s existence: %s" %
(name, error))
if maintenance:
if module.check_mode:
changed = True
else:
(rc, data, error) = maint.delete_maintenance(
maintenance["maintenanceid"])
if rc == 0:
changed = True
else:
module.fail_json(msg="Failed to remove maintenance: %s" %
error)
module.exit_json(changed=changed)
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(dict(
proxy_name=dict(type='str', required=True),
proxy_address=dict(type='str', required=False),
status=dict(type='str', default="active", choices=['active', 'passive']),
state=dict(type='str', default="present", choices=['present', 'absent']),
description=dict(type='str', required=False),
tls_connect=dict(type='str', default='no_encryption', choices=['no_encryption', 'PSK', 'certificate']),
tls_accept=dict(type='str', default='no_encryption', choices=['no_encryption', 'PSK', 'certificate']),
ca_cert=dict(type='str', required=False, default=None, aliases=['tls_issuer']),
tls_subject=dict(type='str', required=False, default=None),
tls_psk_identity=dict(type='str', required=False, default=None),
tls_psk=dict(type='str', required=False, default=None),
interface=dict(
type='dict',
required=False,
default={},
options=dict(
useip=dict(type='int', choices=[0, 1], default=0),
ip=dict(type='str', default=''),
dns=dict(type='str', default=''),
port=dict(type='str', default='10051'),
type=dict(type='int', default=0, removed_in_version="3.0.0", removed_from_collection='community.zabbix'), # was Ansible 2.14
main=dict(type='int', default=0, removed_in_version="3.0.0", removed_from_collection='community.zabbix'), # was Ansible 2.14
),
)
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
proxy_name = module.params['proxy_name']
proxy_address = module.params['proxy_address']
description = module.params['description']
status = module.params['status']
tls_connect = module.params['tls_connect']
tls_accept = module.params['tls_accept']
tls_issuer = module.params['ca_cert']
tls_subject = module.params['tls_subject']
tls_psk_identity = module.params['tls_psk_identity']
tls_psk = module.params['tls_psk']
state = module.params['state']
interface = module.params['interface']
# convert enabled to 0; disabled to 1
status = 6 if status == "passive" else 5
if tls_connect == 'certificate':
tls_connect = 4
elif tls_connect == 'PSK':
tls_connect = 2
else:
tls_connect = 1
if tls_accept == 'certificate':
tls_accept = 4
elif tls_accept == 'PSK':
tls_accept = 2
else:
tls_accept = 1
proxy = Proxy(module)
# check if proxy already exists
proxy_id = proxy.proxy_exists(proxy_name)
if proxy_id:
if state == "absent":
# remove proxy
proxy.delete_proxy(proxy_id, proxy_name)
else:
proxy.update_proxy(proxy_id, {
'host': proxy_name,
'description': description,
'status': str(status),
'tls_connect': str(tls_connect),
'tls_accept': str(tls_accept),
'tls_issuer': tls_issuer,
'tls_subject': tls_subject,
'tls_psk_identity': tls_psk_identity,
'tls_psk': tls_psk,
'interface': interface,
'proxy_address': proxy_address
})
else:
if state == "absent":
# the proxy is already deleted.
module.exit_json(changed=False)
proxy_id = proxy.add_proxy(data={
'host': proxy_name,
'description': description,
'status': str(status),
'tls_connect': str(tls_connect),
'tls_accept': str(tls_accept),
'tls_issuer': tls_issuer,
'tls_subject': tls_subject,
'tls_psk_identity': tls_psk_identity,
'tls_psk': tls_psk,
'interface': interface,
'proxy_address': proxy_address
})
def main():
argument_spec = zabbix_utils.zabbix_common_argument_spec()
argument_spec.update(dict(
alias=dict(type='str', required=True),
name=dict(type='str'),
surname=dict(type='str'),
usrgrps=dict(type='list'),
passwd=dict(type='str', required=False, no_log=True),
override_passwd=dict(type='bool', required=False, default=False, no_log=False),
lang=dict(type='str', choices=['en_GB', 'en_US', 'zh_CN', 'cs_CZ', 'fr_FR',
'he_IL', 'it_IT', 'ko_KR', 'ja_JP', 'nb_NO',
'pl_PL', 'pt_BR', 'pt_PT', 'ru_RU', 'sk_SK',
'tr_TR', 'uk_UA', 'default']),
theme=dict(type='str', choices=['default', 'blue-theme', 'dark-theme']),
autologin=dict(type='bool'),
autologout=dict(type='str'),
refresh=dict(type='str'),
rows_per_page=dict(type='str'),
after_login_url=dict(type='str'),
user_medias=dict(type='list', elements='dict',
options=dict(mediatype=dict(type='str', default='Email'),
sendto=dict(type='str', required=True),
period=dict(type='str', default='1-7,00:00-24:00'),
severity=dict(type='dict',
options=dict(
not_classified=dict(type='bool', default=True),
information=dict(type='bool', default=True),
warning=dict(type='bool', default=True),
average=dict(type='bool', default=True),
high=dict(type='bool', default=True),
disaster=dict(type='bool', default=True)),
default=dict(
not_classified=True,
information=True,
warning=True,
average=True,
high=True,
disaster=True)),
active=dict(type='bool', default=True))),
timezone=dict(type='str'),
role_name=dict(type='str'),
type=dict(type='str', choices=['Zabbix user', 'Zabbix admin', 'Zabbix super admin']),
state=dict(type='str', default="present", choices=['present', 'absent'])
))
module = AnsibleModule(
argument_spec=argument_spec,
required_if=[
['state', 'present', ['usrgrps']]
],
supports_check_mode=True
)
alias = module.params['alias']
name = module.params['name']
surname = module.params['surname']
usrgrps = module.params['usrgrps']
passwd = module.params['passwd']
override_passwd = module.params['override_passwd']
lang = module.params['lang']
theme = module.params['theme']
autologin = module.params['autologin']
autologout = module.params['autologout']
refresh = module.params['refresh']
rows_per_page = module.params['rows_per_page']
after_login_url = module.params['after_login_url']
user_medias = module.params['user_medias']
user_type = module.params['type']
timezone = module.params['timezone']
role_name = module.params['role_name']
state = module.params['state']
if autologin is not None:
if autologin:
autologin = '******'
else:
autologin = '******'
user_type_dict = {
'Zabbix user': '******',
'Zabbix admin': '2',
'Zabbix super admin': '3'
}
user_type = user_type_dict[user_type] if user_type else None
user = User(module)
user_ids = {}
zbx_user = user.check_user_exist(alias)
if state == 'present':
user_group_ids, not_ldap = user.get_usergroups_by_name(usrgrps)
if LooseVersion(user._zbx_api_version) < LooseVersion('4.0') or not_ldap:
if passwd is None:
module.fail_json(msg='User password is required. One or more groups are not LDAP based.')
if zbx_user:
diff_check_result, diff_params = user.user_parameter_difference_check(zbx_user, alias, name, surname,
user_group_ids, passwd, lang, theme,
autologin, autologout, refresh,
rows_per_page, after_login_url,
user_medias, user_type, timezone,
role_name, override_passwd)
if not module.check_mode and diff_check_result:
user_ids = user.update_user(zbx_user, alias, name, surname, user_group_ids, passwd, lang,
theme, autologin, autologout, refresh, rows_per_page, after_login_url,
user_medias, user_type, timezone, role_name, override_passwd)
else:
diff_check_result = True
user_ids, diff_params = user.add_user(alias, name, surname, user_group_ids, passwd, lang, theme, autologin,
autologout, refresh, rows_per_page, after_login_url, user_medias,
user_type, not_ldap, timezone, role_name)
if state == 'absent':
if zbx_user:
diff_check_result = True
user_ids, diff_params = user.delete_user(zbx_user, alias)
else:
diff_check_result = False
diff_params = {}
if not module.check_mode:
if user_ids:
module.exit_json(changed=True, user_ids=user_ids)
else:
module.exit_json(changed=False)
else:
if diff_check_result:
module.exit_json(changed=True, diff=diff_params)
else:
module.exit_json(changed=False, diff=diff_params)
