def main(): """The main function""" login = "******"#raw_input("Login: "******"1kassiope@"#raw_input("Password: "******"Connected to Zabbix API Version %s" % zapi.api_version() template_id = zapi.template.get({"output": "extend", "search": {"name": 'App RabbitMQ'}})[0]["templateid"] print "Template ID", template_id hosts = [] items = {} gitems = {} print "Host IDs:" for rig in zapi.host.get({"templateids":template_id}): hosts.append(rig["hostid"]) print rig["hostid"], rig["name"] print "Collecting items and assigning colors to them..." for i in hosts: items[i] = zapi.item.get({"hostids": i, "search": {"key_": 'queue_message_stats'}}) gitems[i] = [] for j in items[i]: gitems[i].append({"itemid": j["itemid"], "color": '%02X%02X%02X' % (rand(), rand(), rand())}) print "Creating graph for", i try: zapi.graph.create({"name": "Aggregated queue stats", "width": 900, "height": 300, "gitems": gitems[i]}) except: print "Graph already exists or cannot be created" continue print "All done"
def main(): module = AnsibleModule(argument_spec=dict( server_url=dict(type='str', required=True, aliases=['url']), login_user=dict(type='str', required=True), login_password=dict(type='str', required=True, no_log=True), http_login_user=dict(type='str', required=False, default=None), http_login_password=dict(type='str', required=False, default=None, no_log=True), validate_certs=dict(type='bool', required=False, default=True), alias=dict(type='str', required=True), passwd=dict(type='str', required=True, no_log=True), timeout=dict(type='int', default=10)), 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) server_url = module.params['server_url'] login_user = module.params['login_user'] login_password = module.params['login_password'] http_login_user = module.params['http_login_user'] http_login_password = module.params['http_login_password'] validate_certs = module.params['validate_certs'] alias = module.params['alias'] passwd = module.params['passwd'] timeout = module.params['timeout'] zbx = None # login to zabbix try: zbx = ZabbixAPI(server_url, timeout=timeout, user=http_login_user, passwd=http_login_password, validate_certs=validate_certs) zbx.login(login_user, login_password) atexit.register(zbx.logout) except Exception as e: module.fail_json(msg="Failed to connect to Zabbix server: %s" % e) user = User(module, zbx) user_ids = {} zbx_api_version = zbx.api_version()[:3] zbx_user = user.check_user_exist(alias) if zbx_user: user_ids = user.passwd(zbx_user, alias, passwd, zbx_api_version) module.exit_json(changed=True, user_ids=user_ids)
def map_create(args): #Function creates value maps in Zabbix server via API result = False value_map = parse_mib(args.mib_file, args.value) if args.map_name: name = args.map_name else: name = args.value value_map_rq = {"name": name, "mappings": value_map} zbx_srv = ZabbixAPI(server=args.server) try: zbx_srv.login(user=args.user, password=args.password) print "Zabbix API Version: %s" % zbx_srv.api_version() print "Logged in: %s" % str(zbx_srv.test_login()) except ZabbixAPIException, e: sys.exit(error_parse(e))
class BaseCreator(object): """ Base class for Zabbix creator """ def __init__(self,options): self.options = options self.server = 'http://%s/api_jsonrpc.php ' % self.options.server self.username = self.options.username self.password = self.options.password self.zbxLogin() def zbxLogin(self): self.zapi = ZabbixAPI(server=self.server,log_level=0) try: self.zapi.login(self.username, self.password) print "Zabbix API Version: %s" % self.zapi.api_version() print "Logged in: %s" % str(self.zapi.test_login()) except ZabbixAPIException, e: sys.stderr.write(str(e) + '\n')
class BaseCreator(object): """ Base class for Zabbix creator """ def __init__(self, options): self.options = options self.server = "http://%s/api_jsonrpc.php " % self.options.server self.username = self.options.username self.password = self.options.password self.zbxLogin() def zbxLogin(self): self.zapi = ZabbixAPI(server=self.server, log_level=0) try: self.zapi.login(self.username, self.password) print "Zabbix API Version: %s" % self.zapi.api_version() print "Logged in: %s" % str(self.zapi.test_login()) except ZabbixAPIException, e: sys.stderr.write(str(e) + "\n")
def map_create(args): #Function creates value maps in Zabbix server via API result = False value_map = parse_mib(args.mib_file, args.value) if args.map_name: name = args.map_name else: name = args.value value_map_rq = { "name": name, "mappings": value_map } zbx_srv = ZabbixAPI(server = args.server) try: zbx_srv.login(user = args.user, password = args.password) print "Zabbix API Version: %s" % zbx_srv.api_version() print "Logged in: %s" % str(zbx_srv.test_login()) except ZabbixAPIException, e: sys.exit(error_parse(e))
class ZapiWrapper(object): """ A simple wrapper over the Zabbix API """ def __init__(self, module, zbx=None): self._module = module 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) # check if zbx is already instantiated or not if zbx is not None and isinstance(zbx, ZabbixAPI): self._zapi = zbx else: server_url = module.params['server_url'] http_login_user = module.params['http_login_user'] http_login_password = module.params['http_login_password'] validate_certs = module.params['validate_certs'] timeout = module.params['timeout'] self._zapi = ZabbixAPI(server_url, timeout=timeout, user=http_login_user, passwd=http_login_password, validate_certs=validate_certs) self.login() self._zbx_api_version = self._zapi.api_version()[:5] def login(self): # check if api already logged in if not self._zapi.auth != '': try: login_user = self._module.params['login_user'] login_password = self._module.params['login_password'] self._zapi.login(login_user, login_password) atexit.register(self._zapi.logout) except Exception as e: self._module.fail_json( msg="Failed to connect to Zabbix server: %s" % e)
#!/usr/bin/env python #-*-coding: utf-8-*- from zabbix_api import ZabbixAPI zapi=ZabbixAPI(server="SITE") #Conexão com Zabbix Server zapi.login("Login","Senha") #Versao do Zabbix print "Version Zabbix:", zapi.api_version() #Printa os hosts hosts = zapi.host.get({"output": "extend", "sortfield": "name"}) for x in hosts: print x['available'], "-", x['hostid'], "-", x['name'] #Printa os Triggers trigger = zapi.trigger.get(only_true=1, skipDependent=1, monitored=1, active=1, output='extend', expandDescription=1, selectHosts=['host'], ) for y in trigger: print y['description'], "--", y['host'] #Print UPTIME uptime = zapi.item.get({'output': "extend", 'hostids': 10084, 'search': {'key_':'system.uptime'}}) print "Tempo",uptime[0]['lastvalue'] trigger = zapi.trigger.get[{'output': "extend", 'group': "HSM"}] print "Triggers",trigger
import time import json import math #zsvr = str(input('Insira o server: ')) zsvr = "https://www.tjms.jus.br/zabbix" username = str(input('Insira o usuario: ')) password = str(getpass.getpass('Insira a senha: ')) #instanciando a API conexao = ZabbixAPI(server = zsvr) conexao.login(username, password) #lendo versao versao = conexao.api_version() print ("Versão do Zabbix Server: ", versao) hostgroup = conexao.hostgroup.get({"output": "extend", "sortfield": "name"}) for x in hostgroup: #vendo os grupos de host print (x['groupid'], "-", x['name']) y = int(input('Insira o GroupID: '))
########################################## # Busca informação da versão do Zabbix ########################################## #importando o zabbixapi from zabbix_api import ZabbixAPI import config #logon zapi = ZabbixAPI(server=config.url) zapi.login(config.login, config.passwd) print("Versão da API: ", zapi.api_version())
def main(): module = AnsibleModule(argument_spec=dict( server_url=dict(type='str', required=True, aliases=['url']), login_user=dict(type='str', required=True), login_password=dict(type='str', required=True, no_log=True), http_login_user=dict(type='str', required=False, default=None), http_login_password=dict(type='str', required=False, default=None, no_log=True), validate_certs=dict(type='bool', required=False, default=True), alias=dict(type='str', required=True), name=dict(type='str', default=''), surname=dict(type='str', default=''), usrgrps=dict(type='list', required=True), passwd=dict(type='str', required=True, no_log=True), override_passwd=dict(type='bool', required=False, default=False), lang=dict(type='str', default='en_GB', 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' ]), theme=dict(type='str', default='default', choices=['default', 'blue-theme', 'dark-theme']), autologin=dict(type='bool', default=False), autologout=dict(type='str', default='0'), refresh=dict(type='str', default='30'), rows_per_page=dict(type='str', default='50'), after_login_url=dict(type='str', default=''), user_medias=dict( type='list', default=[], 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))), type=dict( type='str', default='Zabbix user', choices=['Zabbix user', 'Zabbix admin', 'Zabbix super admin']), state=dict(type='str', default="present", choices=['present', 'absent']), timeout=dict(type='int', default=10)), 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) server_url = module.params['server_url'] login_user = module.params['login_user'] login_password = module.params['login_password'] http_login_user = module.params['http_login_user'] http_login_password = module.params['http_login_password'] validate_certs = module.params['validate_certs'] 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'] state = module.params['state'] timeout = module.params['timeout'] if autologin: autologin = '******' else: autologin = '******' user_type_dict = { 'Zabbix user': '******', 'Zabbix admin': '2', 'Zabbix super admin': '3' } user_type = user_type_dict[user_type] zbx = None # login to zabbix try: zbx = ZabbixAPI(server_url, timeout=timeout, user=http_login_user, passwd=http_login_password, validate_certs=validate_certs) zbx.login(login_user, login_password) atexit.register(zbx.logout) except Exception as e: module.fail_json(msg="Failed to connect to Zabbix server: %s" % e) user = User(module, zbx) user_ids = {} zbx_api_version = zbx.api_version()[:3] zbx_user = user.check_user_exist(alias) if state == 'present': user_group_ids = user.get_usergroupid_by_user_group_name(usrgrps) 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, zbx_api_version, 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, zbx_api_version, 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) 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)
@author: Janssen dos Reis Lima """ from zabbix_api import ZabbixAPI zabbix_server = "http://127.0.0.1:1080" #Endereço ou IP ou FQDN do servidor do Zabbix. username = "******" #Informe usuario para acessar. Usuario com perfil de administrador do Zabbix, não necessariamente o 'admin' padrao. password = "******" #Senha #Instanciando a API #conexao = ZabbixAPI(server = zabbix_server, log_level=6) conexao = ZabbixAPI(server=zabbix_server) conexao.login(username, password) # verificar versao zabbix versao = conexao.api_version() print "Versão do Zabbix Server: ", versao # Exibir hosts cadastrados hosts = conexao.host.get({"output": "extend", "sortfield": "name"}) for x in hosts: print x['available'], "-", x['hostid'], "-", x['name'] #Cadastrar hosts #conexao.host.create({"host": "Centos", # "interfaces": [ {"type": "1", # "main": "1", # "useip": "1", # "ip": "19.168.0.1", # "dns": "", # "port": "10052"}],
data = zg.get("vm.discovery[*]") try: result = json.loads(data) # result = json.dumps(result, indent=4) except: print "Cannot decode VMBIX response" logging.error("Cannot decode VMBIX response") exit(1) result = result["data"] # Connection to Zabbix API zapi = ZabbixAPI(server = ZBXURL, path = "") zapi.login(ZBXUSER, ZBXPASSWORD) # Get Zabbix data if zapi.api_version() <= 1.4: logging.error('Example script works only with API 1.4 or higher.') exit(1) hosts = zapi.host.get({"output": "extend", "selectGroups": ["name"], "selectParentTemplates": ["name"]}) try: get = zapi.hostgroup.get({ "output": "extend", "filter": { "name": VMGROUP } }) groupids = [{"groupid": x['groupid']} for x in get] logging.info("Groups : %s" %(groupids)) #groupid = get[0]['groupid'] except:
p.print_help() print "NOTE: Zabbix 1.8.0 doesn't check LDAP when authenticating." sys.exit(-1) def errmsg(msg): sys.stderr.write(msg + "\n") sys.exit(-1) if __name__ == "__main__": options, args = get_options() zapi = ZabbixAPI(server=options.server,log_level=3) try: zapi.login(options.username, options.password) print "Zabbix API Version: %s" % zapi.api_version() print "Logged in: %s" % str(zapi.test_login()) except ZabbixAPIException, e: sys.stderr.write(str(e) + '\n') try: for host in zapi.host.get({ 'monitored_hosts' : True,'extendoutput' : True}): if host['dns'] == "": print "%s - %s - %s" % (host['host'], host['ip'], host['useip']) else: print "%s - %s - %s" % (host['dns'], host['ip'], host['useip']) if host['useip'] == "1" and host['dns'] != "": print "Updating %s to monitor by FQDN." % host['dns'] newhost = host newhost['useip'] = 0
sys.exit(-1) def errmsg(msg): sys.stderr.write(msg + "\n") sys.exit(-1) if __name__ == "__main__": options, args = get_options() zapi = ZabbixAPI(server=options.server, log_level=3) try: zapi.login(options.username, options.password) print "Zabbix API Version: %s" % zapi.api_version() print "Logged in: %s" % str(zapi.test_login()) except ZabbixAPIException, e: sys.stderr.write(str(e) + '\n') try: for host in zapi.host.get({ 'monitored_hosts': True, 'extendoutput': True }): if host['dns'] == "": print "%s - %s - %s" % (host['host'], host['ip'], host['useip']) else: print "%s - %s - %s" % (host['dns'], host['ip'], host['useip'])
def main(): argument_spec = dict( server_url=dict(type='str', required=True, aliases=['url']), login_user=dict(type='str', required=True), login_password=dict(type='str', required=True, no_log=True), http_login_user=dict(type='str', required=False, default=None), http_login_password=dict(type='str', required=False, default=None, no_log=True), validate_certs=dict(type='bool', required=False, default=True), timeout=dict(type='int', default=10), 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 ) if module.params['state'] == 'present': validate_params(module, required_params) 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) server_url = module.params['server_url'] login_user = module.params['login_user'] login_password = module.params['login_password'] http_login_user = module.params['http_login_user'] http_login_password = module.params['http_login_password'] validate_certs = module.params['validate_certs'] state = module.params['state'] timeout = module.params['timeout'] name = module.params['name'] description = module.params['description'] transport_type = module.params['type'] status = module.params['status'] max_sessions = module.params['max_sessions'] max_attempts = module.params['max_attempts'] attempt_interval = module.params['attempt_interval'] # Script script_name = module.params['script_name'] script_params = module.params['script_params'] # SMS gsm_modem = module.params['gsm_modem'] # Jabber username = module.params['username'] password = module.params['password'] # Email smtp_server = module.params['smtp_server'] smtp_server_port = module.params['smtp_server_port'] smtp_helo = module.params['smtp_helo'] smtp_email = module.params['smtp_email'] smtp_security = module.params['smtp_security'] smtp_authentication = module.params['smtp_authentication'] smtp_verify_host = module.params['smtp_verify_host'] smtp_verify_peer = module.params['smtp_verify_peer'] # EZ Text message_text_limit = module.params['message_text_limit'] # Webhook webhook_script = module.params['webhook_script'] webhook_timeout = module.params['webhook_timeout'] process_tags = module.params['process_tags'] event_menu = module.params['event_menu'] event_menu_url = module.params['event_menu_url'] event_menu_name = module.params['event_menu_name'] webhook_params = module.params['webhook_params'] # Message template message_templates = module.params['message_templates'] zbx = None # login to zabbix try: zbx = ZabbixAPI(server_url, timeout=timeout, user=http_login_user, passwd=http_login_password, validate_certs=validate_certs) zbx.login(login_user, login_password) atexit.register(zbx.logout) except Exception as e: module.fail_json(msg="Failed to connect to Zabbix server: %s" % e) zbx_api_version = zbx.api_version()[:3] mediatype_exists, mediatype_id = check_if_mediatype_exists(module, zbx, name, zbx_api_version) parameters = construct_parameters( name=name, description=description, transport_type=transport_type, status=status, max_sessions=max_sessions, max_attempts=max_attempts, attempt_interval=attempt_interval, script_name=script_name, script_params=script_params, gsm_modem=gsm_modem, username=username, password=password, smtp_server=smtp_server, smtp_server_port=smtp_server_port, smtp_helo=smtp_helo, smtp_email=smtp_email, smtp_security=smtp_security, smtp_authentication=smtp_authentication, smtp_verify_host=smtp_verify_host, smtp_verify_peer=smtp_verify_peer, message_text_limit=message_text_limit, webhook_script=webhook_script, webhook_timeout=webhook_timeout, process_tags=process_tags, event_menu=event_menu, event_menu_url=event_menu_url, event_menu_name=event_menu_name, webhook_params=webhook_params, message_templates=message_templates, zbx_api_version=zbx_api_version ) if 'unsupported_parameter' in parameters: module.fail_json(msg="%s is unsupported for Zabbix version %s" % (parameters['unsupported_parameter'], parameters['zbx_api_version'])) 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 = delete_mediatype(module, zbx, 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 = get_update_params(module, zbx, 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 = update_mediatype( module, zbx, 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 = create_mediatype(module, zbx, **parameters) module.exit_json( changed=True, msg="Mediatype created: {name}, ID: {_id}".format( name=name, _id=mediatype_id ) )
logger.error('Configuration file {} not found'.format(server_config)) sys.exit() try: zabbix_server = configuration['zabbix_server'] zabbix_login = configuration['zabbix_login'] zabbix_password = configuration['zabbix_password'] redis_host = configuration['redis_host'] redis_port = configuration['redis_port'] except KeyError as e: logger.error('Not found in config: {}'.format(e)) sys.exit() zapi = ZabbixAPI(zabbix_server) zapi.login(zabbix_login, zabbix_password) logger.info('Connected to Zabbix API Version {}'.format(zapi.api_version())) killer = GracefulKiller() r = redis.Redis(host=redis_host, port=redis_port, db=0) p = r.pubsub(ignore_subscribe_messages=True) p.subscribe(**{'notify-channel': Redis_handler}) logger.info(p.get_message()) while True: if killer.receivedSignal: if killer.receivedTermSignal: logging.warning("Gracefully exiting due to receipt of signal {}".format(killer.lastSignal)) sys.exit() else: logging.warning("Ignoring signal {}".format(killer.lastSignal))
def main(): module = AnsibleModule( argument_spec=dict( server_url=dict(type='str', required=True, aliases=['url']), login_user=dict(type='str', required=True), login_password=dict(type='str', required=True, no_log=True), host_name=dict(type='str', required=True), http_login_user=dict(type='str', required=False, default=None), http_login_password=dict(type='str', required=False, default=None, no_log=True), validate_certs=dict(type='bool', required=False, default=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), timeout=dict(type='int', default=10), interfaces=dict(type='list', required=False), 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', required=False, default='') ) ), tags=dict( type='list', elements='dict', aliases=['host_tags'], options=dict( tag=dict(type='str', required=True), value=dict(type='str', default='') ) ) ), 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) server_url = module.params['server_url'] login_user = module.params['login_user'] login_password = module.params['login_password'] http_login_user = module.params['http_login_user'] http_login_password = module.params['http_login_password'] validate_certs = module.params['validate_certs'] 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'] timeout = module.params['timeout'] 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 zbx = None # login to zabbix try: zbx = ZabbixAPI(server_url, timeout=timeout, user=http_login_user, passwd=http_login_password, validate_certs=validate_certs) zbx.login(login_user, login_password) atexit.register(zbx.logout) except Exception as e: module.fail_json(msg="Failed to connect to Zabbix server: %s" % e) host = Host(module, zbx) 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) ip = "" if interfaces: # ensure interfaces are well-formed for interface in interfaces: if 'type' not in interface: module.fail_json(msg="(interface) type needs to be specified for interface '%s'." % interface) interfacetypes = {'agent': 1, 'snmp': 2, 'ipmi': 3, 'jmx': 4} if interface['type'] in interfacetypes.keys(): interface['type'] = interfacetypes[interface['type']] if interface['type'] < 1 or interface['type'] > 4: module.fail_json(msg="Interface type can only be 1-4 for interface '%s'." % interface) if 'useip' not in interface: interface['useip'] = 0 if 'dns' not in interface: if interface['useip'] == 0: module.fail_json(msg="dns needs to be set if useip is 0 on interface '%s'." % interface) interface['dns'] = '' if 'ip' not in interface: if interface['useip'] == 1: module.fail_json(msg="ip needs to be set if useip is 1 on interface '%s'." % interface) interface['ip'] = '' if 'main' not in interface: interface['main'] = 0 if 'port' in interface and not isinstance(interface['port'], str): try: interface['port'] = str(interface['port']) except ValueError: module.fail_json(msg="port should be convertable to string on interface '%s'." % interface) if 'port' not in interface: if interface['type'] == 1: interface['port'] = "10050" elif interface['type'] == 2: interface['port'] = "161" elif interface['type'] == 3: interface['port'] = "623" elif interface['type'] == 4: interface['port'] = "12345" if interface['type'] == 1: ip = interface['ip'] if macros: # convert macros to zabbix native format - {$MACRO} for macro in macros: macro['macro'] = macro['macro'].upper() if not macro['macro'].startswith('{$'): macro['macro'] = '{$' + macro['macro'] if not macro['macro'].endswith('}'): macro['macro'] = macro['macro'] + '}' if LooseVersion(zbx.api_version()[:5]) <= LooseVersion('4.4.0'): if 'description' in macro: macro.pop('description', False) # 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}) # if no interfaces were specified with the module, start with an empty list if not interfaces: interfaces = [] # 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', 'bulk']: interface.pop(key, None) for index in interface.keys(): if index in ['useip', 'main', 'type']: interface[index] = int(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): 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))
import atexit atexit.register(cleanup) #get screens for screen in zapi.screen.get({ "output": "extend", "selectScreenItems": "extend" }): print json.dumps(screen, indent=4) sys.exit(1) if __name__ == "__main__": global config config_file = './screenbuilder.conf' config = Config(config_file) config.parse() zapi = ZabbixAPI(server=config.zabbix_frontend) try: print("Connecting to Zabbix API") zapi.login(config.zabbix_user, config.zabbix_password) print("Connected to Zabbix API Version: %s" % zapi.api_version()) except ZabbixAPIException, e: print("Zabbix API connection failed") print("Additional info: %s" % e) sys.exit(1) main()
from zabbix_api import ZabbixAPI URL = 'http://zabbix.fortalnet.net.br/zabbix/api_jsonrpc.php' USERNAME = '******' PASSWORD = '' try: zapi = ZabbixAPI(URL, timeout=180) zapi.login(USERNAME, PASSWORD) print('Conectado na API do Zabbix, versao: {}'.format(zapi.api_version())) except Exception as err: print('Falha ao Conectar na API no Zabbix') print('Erro: {}'.format(err)) hostgroups = zapi.hostgroup.get({"output": ['name'], "monitored_hotst": 1}) for hostgroup in hostgroups: hostgroup_id = hostgroup['groupid'] hostgroup_name = hostgroup['name'] print('{} - {} '.format(hostgroup_id, hostgroup_name))
class InventoryModule(BaseInventoryPlugin, Constructable, Cacheable): NAME = 'community.zabbix.zabbix_inventory' def login_zabbix(self): # set proxy information if required proxy = self.get_option('proxy') os.environ['http_proxy'] = proxy os.environ['HTTP_PROXY'] = proxy os.environ['https_proxy'] = proxy os.environ['HTTPS_PROXY'] = proxy server_url = self.get_option('server_url') http_login_user = self.get_option('login_user') http_login_password = self.get_option('login_password') validate_certs = self.get_option('validate_certs') timeout = self.get_option('timeout') self._zapi = ZabbixAPI(server_url, timeout=timeout, user=http_login_user, passwd=http_login_password, validate_certs=validate_certs) self.login() self._zbx_api_version = self._zapi.api_version()[:5] def login(self): # check if api already logged in if not self._zapi.auth != '': try: login_user = self.get_option('login_user') login_password = self.get_option('login_password') self._zapi.login(login_user, login_password) atexit.register(self._zapi.logout) except Exception as e: self.display.vvv(msg="Failed to connect to Zabbix server: %s" % e) def verify_file(self, path): valid = False if super(InventoryModule, self).verify_file(path): if path.endswith( ('zabbix_inventory.yaml', 'zabbix_inventory.yml')): valid = True else: self.display.vvv( 'Skipping due to inventory source not ending in "zabbix_inventory.yaml" nor "zabbix_inventory.yml"' ) return valid def parse(self, inventory, loader, path, cache=True): # Plugin interface (2) super(InventoryModule, self).parse(inventory, loader, path) self._read_config_data(path) self.cache_key = self.get_cache_key(path) self.use_cache = self.get_option('cache') and cache self.update_cache = self.get_option('cache') and not cache self.login_zabbix() zapi_query = self.get_option('host_zapi_query') content = self._zapi.host.get(zapi_query) strict = self.get_option('strict') for record in content: # add host to inventory host_name = self.inventory.add_host(record['host']) # set variables for host for k in record.keys(): self.inventory.set_variable(host_name, 'zbx_%s' % k, record[k]) # added for compose vars and keyed groups self._set_composite_vars( self.get_option('compose'), self.inventory.get_host(host_name).get_vars(), host_name, strict) self._add_host_to_composed_groups(self.get_option('groups'), dict(), host_name, strict) self._add_host_to_keyed_groups(self.get_option('keyed_groups'), dict(), host_name, strict) # organize inventory by zabbix groups if self.get_option('add_zabbix_groups'): content = self._zapi.host.get({'selectGroups': ['name']}) for record in content: host_name = record['host'] if len(record['groups']) >= 1: for group in record['groups']: group_name = to_safe_group_name(group['name']) self.inventory.add_group(group_name) self.inventory.add_child(group_name, host_name)
menu_graphs['type'] = 'GRAPHID' menu_graphs['graphid'] = graphs[graph][0] menu_graphs['selected'] = graphs[graph][1] host_options.append(menu_graphs) menu_hosts['options'] = host_options menu_options.append(menu_hosts) menu['options'] = menu_options doMenu(menu) os.system('clear') checkScreenGraphs(hostgroupid, hostgroupname, menu) if __name__ == "__main__": global config config_file = './screenbuilder.conf' config = Config(config_file) config.parse() zapi = ZabbixAPI(server=config.zabbix_frontend) try: print("Connecting to Zabbix API") zapi.login(config.zabbix_user, config.zabbix_password) print("Connected to Zabbix API Version: %s" % zapi.api_version()) except ZabbixAPIException, e: print("Zabbix API connection failed") print("Additional info: %s" % e) sys.exit(1) main()
def main(): argument_spec = dict( server_url=dict(type='str', required=True, aliases=['url']), login_user=dict(type='str', required=True), login_password=dict(type='str', required=True, no_log=True), http_login_user=dict(type='str', required=False, default=None), http_login_password=dict(type='str', required=False, default=None, no_log=True), validate_certs=dict(type='bool', required=False, default=True), timeout=dict(type='int', default=10), name=dict(type='str', required=True), state=dict(type='str', default='present', choices=['present', 'absent']), type=dict(type='str', choices=['email', 'script', 'sms', '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'])) 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'] ], ['smtp_authentication', True, ['username', 'password']]] module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) if module.params['state'] == 'present': validate_params(module, required_params) 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) server_url = module.params['server_url'] login_user = module.params['login_user'] login_password = module.params['login_password'] http_login_user = module.params['http_login_user'] http_login_password = module.params['http_login_password'] validate_certs = module.params['validate_certs'] state = module.params['state'] timeout = module.params['timeout'] name = module.params['name'] transport_type = module.params['type'] status = module.params['status'] max_sessions = module.params['max_sessions'] max_attempts = module.params['max_attempts'] attempt_interval = module.params['attempt_interval'] # Script script_name = module.params['script_name'] script_params = module.params['script_params'] # SMS gsm_modem = module.params['gsm_modem'] # Jabber username = module.params['username'] password = module.params['password'] # Email smtp_server = module.params['smtp_server'] smtp_server_port = module.params['smtp_server_port'] smtp_helo = module.params['smtp_helo'] smtp_email = module.params['smtp_email'] smtp_security = module.params['smtp_security'] smtp_authentication = module.params['smtp_authentication'] smtp_verify_host = module.params['smtp_verify_host'] smtp_verify_peer = module.params['smtp_verify_peer'] # EZ Text message_text_limit = module.params['message_text_limit'] zbx = None # login to zabbix try: zbx = ZabbixAPI(server_url, timeout=timeout, user=http_login_user, passwd=http_login_password, validate_certs=validate_certs) zbx.login(login_user, login_password) atexit.register(zbx.logout) except Exception as e: module.fail_json(msg="Failed to connect to Zabbix server: %s" % e) zbx_api_version = zbx.api_version()[:3] mediatype_exists, mediatype_id = check_if_mediatype_exists( module, zbx, name, zbx_api_version) parameters = construct_parameters(name=name, transport_type=transport_type, status=status, max_sessions=max_sessions, max_attempts=max_attempts, attempt_interval=attempt_interval, script_name=script_name, script_params=script_params, gsm_modem=gsm_modem, username=username, password=password, smtp_server=smtp_server, smtp_server_port=smtp_server_port, smtp_helo=smtp_helo, smtp_email=smtp_email, smtp_security=smtp_security, smtp_authentication=smtp_authentication, smtp_verify_host=smtp_verify_host, smtp_verify_peer=smtp_verify_peer, message_text_limit=message_text_limit, zbx_api_version=zbx_api_version) if 'unsupported_parameter' in parameters: module.fail_json(msg="%s is unsupported for Zabbix version %s" % (parameters['unsupported_parameter'], parameters['zbx_api_version'])) if LooseVersion(zbx_api_version) >= LooseVersion('4.4'): # description key changed to name key from zabbix 4.4 parameters['name'] = parameters.pop('description') if LooseVersion(zbx_api_version) <= LooseVersion('3.2'): # remove settings not supported till 3.4 for key in ['maxsessions', 'maxattempts', 'attempt_interval']: del parameters[key] 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 = delete_mediatype(module, zbx, 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 = get_update_params(module, zbx, 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 = update_mediatype(module, zbx, 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 = create_mediatype(module, zbx, **parameters) module.exit_json(changed=True, msg="Mediatype created: {name}, ID: {_id}".format( name=name, _id=mediatype_id))