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)