def test_login(self): httpretty.register_uri( httpretty.POST, "http://example.com/api_jsonrpc.php", body=json.dumps({ "jsonrpc": "2.0", "result": "0424bd59b807674191e7d77572075f33", "id": 0 }), ) zapi = ZabbixAPI('http://example.com') zapi.login('mylogin', 'mypass') # Check request self.assertEqual( httpretty.last_request().body, json.dumps({ 'jsonrpc': '2.0', 'method': 'user.login', 'params': {'user': '******', 'password': '******'}, 'id': 0, }) ) self.assertEqual( httpretty.last_request().headers['content-type'], 'application/json-rpc' ) self.assertEqual( httpretty.last_request().headers['user-agent'], 'python/pyzabbix' ) # Check response self.assertEqual(zapi.auth, "0424bd59b807674191e7d77572075f33")
def test_host_get(self): httpretty.register_uri( httpretty.POST, "http://example.com/api_jsonrpc.php", body=json.dumps({ "jsonrpc": "2.0", "result": [{"hostid": 1234}], "id": 0 }), ) zapi = ZabbixAPI('http://example.com') zapi.auth = "123" result = zapi.host.get() # Check request self.assertEqual( httpretty.last_request().body, json.dumps({ 'jsonrpc': '2.0', 'method': 'host.get', 'params': {}, 'auth': '123', 'id': 0, }) ) # Check response self.assertEqual(result, [{"hostid": 1234}])
def test_host_delete(self): httpretty.register_uri( httpretty.POST, "http://example.com/api_jsonrpc.php", body=json.dumps({ "jsonrpc": "2.0", "result": { "itemids": [ "22982", "22986" ] }, "id": 0 }), ) zapi = ZabbixAPI('http://example.com') zapi.auth = "123" result = zapi.host.delete("22982", "22986") # Check request self.assertEqual( httpretty.last_request().body, json.dumps({ 'jsonrpc': '2.0', 'method': 'host.delete', 'params': ["22982", "22986"], 'auth': '123', 'id': 0, }) ) # Check response self.assertEqual(set(result["itemids"]), set(["22982", "22986"]))
def main(): # Enter administrator credentials for the Zabbix Web Frontend username = raw_input('Username: '******'dns'] != h['host']: print '%s is actually connecting to %s.' % (h['host'],h['dns']) # Make sure they are using hostnames to connect rather than IPs if h['useip'] == '1': print '%s is using IP instead of hostname. Skipping.' % h['host'] continue # Set their IP record to match what the DNS system says it should be try: lookup = socket.gethostbyaddr(h['dns']) except socket.gaierror, e: print h['dns'], e continue actual_ip = lookup[2][0] if actual_ip != h['ip']: print "%s has the wrong IP: %s. Changing it to: %s" % (h['host'], h['ip'], actual_ip) update_host_ip(zapi,h['hostid'],actual_ip)
def client(**kwargs): global zapi if not zapi: zapi = ZabbixAPI(kwargs['url']) zapi.login(kwargs['username'], kwargs['password']) print zapi.api_version() return zapi
class process_base(object): def __init__(self): ZABBIX_SERVER = 'http://192.168.1.203:82' #ZABBIX_SERVER = 'http://119.79.232.99:82' self.zapi = ZabbixAPI(ZABBIX_SERVER) # Login to the Zabbix API self.zapi.login('Admin', 'zabbix') self.zabbix_url = ZABBIX_SERVER def gid_2_group_list(self): ''' ''' return self.zapi.hostgroup.get(output='extend') def zabbix_url(self): # just for view.py intial the zabbix_url return self.zabbix_url def clock_2_time(self, clock_time): ''' ''' return datetime.fromtimestamp(int(clock_time)).strftime('%Y-%m-%d %X') def clock_2_timedelta(self, clock_time): ''' ''' time_delta = datetime.fromtimestamp( int(clock_time)) - datetime.fromtimestamp(0) delta_day = time_delta.days delta_hour = time_delta.seconds / 3600 delta_min = time_delta.seconds % 3600 / 60 return '%s days, %s hours, %s minutes' % (delta_day, delta_hour, delta_min)
def main(argv): cfgfile = "/etc/zabbix_stats.cfg" try: opts, args = getopt.getopt(argv, "hc:", ["configfile="]) except getopt.GetoptError: print 'zabbix_stats.py -c <configfile>' sys.exit(2) for opt, arg in opts: if opt == '-h': print 'zabbix_stats.py -c <configfile>' sys.exit(2) elif opt in ("-c", "--configfile"): cfgfile = arg global pp pp = pprint.PrettyPrinter(indent=4) config = ConfigParser.ConfigParser() config.read(cfgfile) global zapi zapi = ZabbixAPI(config.get('Server', 'zabbixurl')) zapi.session.verify = False # Login to the Zabbix API zapi.login(config.get('Server', 'username'), config.get('Server', 'password')) while(1): Alerts()
class ZabbixUtils(object): def __init__(self): s = requests.Session() s.auth = (CONF.zabbix.username, CONF.zabbix.password) s.verify = False self.zapi = ZabbixAPI(CONF.zabbix.url, s) self.zapi.login(CONF.zabbix.username, CONF.zabbix.password) def set_graphite_format(self, s): """ Removes whitespaces and lowercases the string """ return ''.join(s.split()).lower() def get_hosts_per_hostgroup(self): """Returns a dictionary with Zabbix's hostgroup->hosts mapping.""" d = {} for hostgroup in self.zapi.hostgroup.get(real_hosts=1, output="extend", selectHosts="extend"): name = hostgroup["name"] hosts = [host["name"] for host in hostgroup["hosts"]] d[name] = hosts return d def get_items_by_host(self, h, filters=[]): """Returns a formated list of (metric, value) pairs. h: Zabbix's name for the host. filters: a list of keys to search for. """ d = {} for f in filters: for item in self.zapi.item.get(search={"key_": f}, host=h, output=["itemid", "name", "lastvalue", "key_"]): itemid = item.pop("itemid") d[itemid] = item l = [] for m in d.values(): l.append([m["key_"], m["lastvalue"]]) l_metric = [] hostgroups = [group["name"] for group in self.zapi.host.get( search={"name": h}, output="groups", selectGroups="extend")[0]["groups"]] h = self.set_graphite_format(h) for hgroup in hostgroups: hgroup = self.set_graphite_format(hgroup) for m in l: k = self.set_graphite_format(m[0]) l_metric.append([".".join([hgroup, h, k]), m[1]]) return l_metric
def initiate_connection(): global connection logger.error('Initiating connection') login = settings.ZABBIX_USER passwd = settings.ZABBIX_PASSWORD connection = ZabbixAPI(server=settings.ZABBIX_URL) connection.login(login, passwd)
def check_cluster(trigger): zapi = ZabbixAPI(zabbix_site) zapi.login(zabbix_user,zabbix_pass) trigger_notok = zapi.trigger.get(monitored=1,selectHosts=1, output=['hosts'],withLastEventUnacknowledged=1, search={'description':trigger},filter={"value":1}) trigger_host_list = [] for trigger_item in trigger_notok: trigger_host = trigger_item['hosts'][0]['hostid'] trigger_host_list.append(int(trigger_host)) trigger_host_msglist = [] trigger_host_list_nondup = list(set(trigger_host_list)) for trigger_host_nondup in trigger_host_list_nondup: trigger_host_dict = zapi.host.get(hostids=trigger_host_nondup) trigger_host_name = trigger_host_dict[0]['host'] trigger_host_count = trigger_host_list.count(trigger_host_nondup) trigger_host_msg = "{0} trigger(s) on {1}".format(trigger_host_count,trigger_host_name) trigger_host_msglist.append(trigger_host_msg) if not trigger_host_msglist: print "OK" else: print '; '.join(trigger_host_msglist) return True
def _connect(self): s = requests.Session() s.auth = (CONF.zabbix.username, CONF.zabbix.password) s.verify = False conn = ZabbixAPI(CONF.zabbix.url, s) conn.login(CONF.zabbix.username, CONF.zabbix.password) return conn
def auth_zabbix(server_ip, username="******", password="******"): logging.debug("Authentication - Zabbix Server") zapi = ZabbixAPI("http://" + server_ip + "/zabbix") zapi.login(username, password) logging.debug("Connected to Zabbix API Version %s" % zapi.api_version()) return zapi
def test_get_api_version(self): zapi = ZabbixAPI(url='http://127.0.0.1', user='******', password='******') if os.environ['ZABBIX_VERSION'] == '3': self.assertEqual(zapi.api_version(), '3.0.1') elif os.environ['ZABBIX_VERSION'] == '2': self.assertEqual(zapi.api_version(), '2.4.7') else: self.fail('api_version() not tested!')
def get_zabbix_api(): zapi = None if zabbix_comment_update: zapi = ZabbixAPI(zabbix_url) try: zapi.login(zabbix_user, zabbix_password) except Exception as e: print 'some errors occurs' print e return zapi
class ZabbixClinet(object): def __init__(self, idc, address, username, password): self.idc = idc self.address = address try: self.zbx_api = ZabbixAPI(address) self.zbx_api.login(username, password) except Exception, error: # logging.warning(error) raise Exception
def _get_zabbix(server = None, password = None, user = None): from pyzabbix import ZabbixAPI import thoth.zabbix as zabbix zabbix_server = server if server else os.environ.get('ZABBIX_SERVER', 'http://127.0.0.1') zabbix_user = user if user else os.environ.get('ZABBIX_USER', 'Admin') zabbix_password = password if password else os.environ.get('ZABBIX_PASSWORD', 'zabbix') if zabbix_server and not match('^http[s]*://', zabbix_server): zabbix_server = 'http://' + zabbix_server zbx = ZabbixAPI(zabbix_server) zbx.login(zabbix_user, zabbix_password) return zabbix.MonitorZabbix(zbx)
def disable_on_zabbix(instance_name): zapi = ZabbixAPI(zabbix_api) zapi.login(zabbix_user, zabbix_pass) hosts = zapi.host.get(filter={ "name": instance_name }) if len(hosts) > 0 and 'hostid' in hosts[0]: hostid = hosts[0]['hostid'] print("Disabling on Zabbix: %s %s" % (instance_name, hostid)) zapi.host.update(hostid=hostid, status=1)
def create_web_scenario(self,name,url,group,hostid,applicationid, url_name='Homepage',status='200'): request = ZabbixAPI.do_request(self, 'webcheck.get', params={ "filter": {"name": name}}) if request['result']: print('Host "%s" already registered' % name) sys.exit(1) else: try: ZabbixAPI.do_request(self, 'webcheck.create',params={"name": name,"hostid": hostid,"applicationid": applicationid, "delay": '60',"retries": '3', "steps": [ { 'name': url_name, 'url': url,'status_codes': status, 'no': '1'} ] } ) triggers = create_trigger(auth,name,url,group) except Exception, e: print(e) sys.exit(1)
def wshtest(): # The hostname at which the Zabbix web interface is available ZABBIX_SERVER = 'http://192.168.100.252:8001/zabbix/' zapi = ZabbixAPI(ZABBIX_SERVER) zapi.login('Admin', 'zabbix') host_name = '192.168.100.240' itemlist = zapi.item.get(output=["name","key_"], hostids=["10109"],filter={}, applicationids="566" ) historylist = zapi.history.get(output="extend",history="3",itemids=["24670"],limit="100") data_timeline = ",".join([ x['clock'] for x in historylist ]) value_line = ",".join([x['value'] for x in historylist]) return data_timeline,value_line
def sample(self): zapi = ZabbixAPI("http://zabbix.tonyrogers.me/zabbix/") zapi.session.verify = False zapi.login("Admin", "zabbix") ret = zapi.item.get(output=['lastvalue'],filter={'host':'zabbix.tonyrogers.me'},search={'key_':'zabbix[wcache,values]'}) self.items.append({'x': self.seedX, 'y': ret[0]['lastvalue']}) self.seedX += 1 if len(self.items) > 10: self.items.popleft() return {'points': list(self.items)}
def authentication(server_url,user,password): if server_url and user and password: ZABBIX_SERVER = server_url zapi = ZabbixAPI(ZABBIX_SERVER) try: # Login to the Zabbix API zapi.login(user,password) return zapi except Exception, e: print(e) sys.exit(1)
def set_zabbix_handle(self, name, host, user, password, ssl_verify): if not self.zabbix_handles.get(name, False): zapi = ZabbixAPI(host) zapi.session.verify = ssl_verify zapi.login(user, password) self.Server.create(host=host, token=zapi.auth) self.zabbix_handles[name] = zapi ret = zapi else: ret = self.zabbix_handles[host] return ret
def get_zabbix_client(url, user, passwd, verify): """ :param url: Zabbix API url :param user: Zabbix API user :param passwd: Zabbix API password :param verify: Whether or not to verify the SSL certificate :return: ZABBIX API Client """ z_client = ZabbixAPI(url) z_client.session.verify = verify z_client.login(user, passwd) return z_client
def loginzabbix(): try: config = ConfigParser.ConfigParser() config.read("zabbixmagic.ini") ZABBIX_SERVER = config.get("zabbixserver", "server") ZABBIX_USER = config.get("zabbixserver", "user") ZABBIX_PASS = config.get("zabbixserver", "password") global zapi zapi = ZabbixAPI(ZABBIX_SERVER) zapi.login(ZABBIX_USER, ZABBIX_PASS) except: print "Could'n connect to zabbix. Please check if URL " + ZABBIX_SERVER + " is available" exit(1)
def _connect_to_zabbix_server_api(self): """This function will connect to the zabbix server API""" logging.info('Connecting to Zabbix server "%s" API...' % (self.zabbix_server)) try: zapi = ZabbixAPI("http://%s/zabbix" % (self.zabbix_server)) zapi.login(self.zabbix_user, self.zabbix_password) except: logging.critical('There was a problem connecting to the Zabbix server "%s" API \n' % (self.zabbix_server) + str(traceback.format_exc())) logging.critical('Will update Zabbix server and exit...') self._send_to_zabbix(self.zabbix_host_name, "Error:Web Server: failed connecting to Zabbix server API", "Web_Server_Error") logging.critical('Script will be terminated....') sys.exit(1) logging.info("Connected to Zabbix API Version %s" % zapi.api_version()) return zapi
def get_zapi(host, user, password, verify): """ :param host: :param user: :param password: :param verify: :return: """ zapi = ZabbixAPI(host) # Whether or not to verify the SSL certificate zapi.session.verify = verify zapi.login(user, password) return zapi
def check_cluster(host,group,trigger,display,debug): zapi = ZabbixAPI(zabbix_site) zapi.login(zabbix_user,zabbix_pass) if debug: print("Connected to Zabbix API Version {0}".format(zapi.api_version())) notok_num = 0 total_num = 0 if group: trigger_obj_notok = zapi.trigger.get(group=group,monitored=1,withLastEventUnacknowledged=1,search={'description':trigger},filter={'value':1}) trigger_obj_total = zapi.trigger.get(group=group,monitored=1,search={'description':trigger}) notok_num = len(trigger_obj_notok) total_num = len(trigger_obj_total) if host: host_name_rex = host hosts = zapi.host.get(monitored_hosts=1,output="extend") for i in range(0,len(hosts)): host_name = hosts[i]["name"] if re.match(host_name_rex,host_name): total_num += 1 trigger_obj = zapi.trigger.get(host=host_name,search={'description':trigger}) if not trigger_obj: if debug: print("No such trigger: '{0}' on host: {1}".format(trigger,host_name)) else: return False else: trigger_id = trigger_obj[0]["triggerid"] trigger_retval = trigger_obj[0]["value"] trigger_item = zapi.trigger.get(triggerids=trigger_id,withLastEventUnacknowledged=1) if trigger_item and trigger_retval == '1': if debug: print("Found host:'{0}' with trigger return value:'{1}'".format(host_name,trigger_retval)) notok_num += 1 elif trigger_retval == '1': if debug: print("Found host:'{0}' with acknowledged trigger return value:'{1}'".format(host_name,trigger_retval)) elif trigger_retval == '0': if debug: print("Found host:'{0}' with trigger return value:'{1}'".format(host_name,trigger_retval)) dicimal_number = float(notok_num) / float(total_num) if display == 'ratio': print("{0} of {1} servers not ok".format(notok_num,total_num)) if display == 'decimal': print dicimal_number return True
def main(): global z #try: # opts, args = getopt.getopt(argv,"hp:s:u:",["password="******"server=", "user="******"cli-inventory.py -s -server= <server> -u -username= <username> -p -password= <password>") # sys.exit(2) #for opt, arg in opts: # if opt == '-h': # print("cli-inventory.py -s -server= <server> -u -username= <username> -p -password= <password>") # sys.exit() # elif opt in ("-s", "-server="): # serverip = arg # elif opt in ("-u", "-username="******"-p", "-password="******"Logged into ZabbixAPI version " + z.api_version()) except ZabbixAPIException as e: print(e, "\nProgram will now close.") sys.exit(2) except requests.Timeout as f: print(f, "\nProgram will now close.") sys.exit(2) else: print("Must enter a correct URL for the Zabbix server (eg. http://192.168.0.4/zabbix).") sys.exit(2) else: print("Required parameter missing.") sys.exit(2) if filepath is not None: return filepath else: return 'arbitrary'
def __init__(self, url, user, password): self.url = url self.user = user self.password = password self.client = ZabbixAPI(url=url, user=user, password=password)
class ZabbixConn(object): """ Zabbix connector class Defines methods for managing Zabbix users and groups """ def __init__(self, config, ldap_conn): self.ldap_conn = ldap_conn self.server = config.zbx_server self.username = config.zbx_username self.password = config.zbx_password self.auth = config.zbx_auth self.dryrun = config.dryrun self.nocheckcertificate = config.zbx_nocheckcertificate self.ldap_groups = config.ldap_groups self.ldap_media = config.ldap_media self.media_opt = config.media_opt self.deleteorphans = config.zbx_deleteorphans self.media_name = config.media_name self.user_opt = config.user_opt if self.nocheckcertificate: from requests.packages.urllib3 import disable_warnings disable_warnings() if config.ldap_wildcard_search: self.ldap_groups = ldap_conn.get_groups_with_wildcard() # Use logger to log information self.logger = logging.getLogger(self.__class__.__name__) def connect(self): """ Establishes a connection to the Zabbix server Raises: SystemExit """ if self.auth == "webform": self.conn = ZabbixAPI(self.server) elif self.auth == "http": self.conn = ZabbixAPI(self.server, use_authenticate=False) self.conn.session.auth = (self.username, self.password) else: raise SystemExit('api auth method not implemented: %s' % self.conn.auth) if self.nocheckcertificate: self.conn.session.verify = False try: self.conn.login(self.username, self.password) except ZabbixAPIException as e: raise SystemExit('Cannot login to Zabbix server: %s' % e) self.logger.info("Connected to Zabbix API Version %s" % self.conn.api_version()) def get_users(self): """ Retrieves the existing Zabbix users Returns: A list of the existing Zabbix users """ result = self.conn.user.get(output='extend') users = [user['alias'] for user in result] return users def get_mediatype_id(self, name): """ Retrieves the mediatypeid by name Args: name (str): Zabbix media type name Returns: The mediatypeid for specified media type name """ result = self.conn.mediatype.get(filter={'name': name.strip()}) if len(result) != 1: raise Exception( f"Ambiguous media found, {len(result)} different medias") if result: mediatypeid = result[0]['mediatypeid'] else: mediatypeid = None return mediatypeid def get_user_id(self, user): """ Retrieves the userid of a specified user Args: user (str): The Zabbix username to lookup Returns: The userid of the specified user """ result = self.conn.user.get(output='extend') userid = [u['userid'] for u in result if u['alias'].lower() == user].pop() return userid def get_groups(self): """ Retrieves the existing Zabbix groups Returns: A dict of the existing Zabbix groups and their group ids """ result = self.conn.usergroup.get(status=0, output='extend') groups = [{ 'name': group['name'], 'usrgrpid': group['usrgrpid'] } for group in result] return groups def get_group_members(self, groupid): """ Retrieves group members for a Zabbix group Args: groupid (int): The group id Returns: A list of the Zabbix users for the specified group id """ result = self.conn.user.get(output='extend', usrgrpids=groupid) users = [user['alias'] for user in result] return users def create_group(self, group): """ Creates a new Zabbix group Args: group (str): The Zabbix group name to create Returns: The groupid of the newly created group """ result = self.conn.usergroup.create(name=group) groupid = result['usrgrpids'].pop() return groupid def create_user(self, user, groupid, user_opt): """ Creates a new Zabbix user Args: user (dict): A dict containing the user details groupid (int): The groupid for the new user user_opt (dict): User options """ random_passwd = ''.join( random.sample(string.ascii_letters + string.digits, 32)) user_defaults = { 'autologin': 0, 'usrgrps': [{ 'usrgrpid': str(groupid) }], 'passwd': random_passwd } if self.conn.api_version() >= "5.2": user_defaults['roleid'] = 1 else: user_defaults['type'] = 1 user_defaults.update(user_opt) user.update(user_defaults) result = self.conn.user.create(user) return result def delete_user(self, user): """ Deletes Zabbix user Args: user (string): Zabbix username """ userid = self.get_user_id(user) result = self.conn.user.delete(userid) return result def update_user(self, user, groupid): """ Adds an existing Zabbix user to a group Args: user (dict): A dict containing the user details groupid (int): The groupid to add the user to """ userid = self.get_user_id(user) if self.conn.api_version() >= "3.4": members = self.conn.usergroup.get(usrgrpids=[str(groupid)], selectUsers='extended') grpusers = members[0]['users'] userids = set() for u in grpusers: userids.add(u['userid']) userids.add(str(userid)) if not self.dryrun: result = self.conn.usergroup.update(usrgrpid=str(groupid), userids=list(userids)) else: if not self.dryrun: result = self.conn.usergroup.massadd(usrgrpids=[str(groupid)], userids=[str(userid)]) return result def update_media(self, user, description, sendto, media_opt): """ Adds media to an existing Zabbix user Args: user (dict): A dict containing the user details description (str): A string containing Zabbix media description sendto (str): A string containing address, phone number, etc... media_opt (dict): Media options """ userid = self.get_user_id(user) mediatypeid = self.get_mediatype_id(description) if mediatypeid: media_defaults = { 'mediatypeid': mediatypeid, 'sendto': sendto, 'active': '0', 'severity': '63', 'period': '1-7,00:00-24:00' } media_defaults.update(media_opt) for unwanted_attrib in ["description", "name", "onlycreate"]: if unwanted_attrib in media_defaults: del media_defaults[unwanted_attrib] if self.conn.api_version() >= "3.4": result = self.conn.user.update(userid=str(userid), user_medias=[media_defaults]) else: self.delete_media_by_description(user, description) result = self.conn.user.updatemedia(users=[{ "userid": str(userid) }], medias=media_defaults) else: result = None return result def delete_media_by_description(self, user, description): """ Remove all media from user (with specific mediatype) Args: user (dict): A dict containing the user details description (str): A string containing Zabbix media description """ userid = self.get_user_id(user) mediatypeid = self.get_mediatype_id(description) if mediatypeid: user_full = self.conn.user.get( output="extend", userids=userid, selectMedias=["mediatypeid", "mediaid"]) media_ids = [ int(u['mediaid']) for u in user_full[0]['medias'] if u['mediatypeid'] == mediatypeid ] if media_ids: self.logger.info( 'Remove other exist media from user %s (type=%s)' % (user, description)) for id in media_ids: self.conn.user.deletemedia(id) def create_missing_groups(self): """ Creates any missing LDAP groups in Zabbix """ missing_groups = set(self.ldap_groups) - set( [g['name'] for g in self.get_groups()]) for eachGroup in missing_groups: self.logger.info('Creating Zabbix group %s' % eachGroup) if not self.dryrun: grpid = self.create_group(eachGroup) self.logger.info('Group %s created with groupid %s' % (eachGroup, grpid)) def convert_severity(self, severity): converted_severity = severity.strip() if re.match("\d+", converted_severity): return converted_severity sev_entries = collections.OrderedDict({ "Disaster": "0", "High": "0", "Average": "0", "Warning": "0", "Information": "0", "Not Classified": "0", }) for sev in converted_severity.split(","): sev = sev.strip() if sev not in sev_entries: raise Exception("wrong argument: %s" % sev) sev_entries[sev] = "1" str_bitmask = "" for sev, digit in sev_entries.items(): str_bitmask += digit converted_severity = str(int(str_bitmask, 2)) self.logger.info('Converted severity "%s" to "%s"' % (severity, converted_severity)) return converted_severity def sync_users(self): """ Syncs Zabbix with LDAP users """ self.ldap_conn.connect() zabbix_all_users = self.get_users() # Lowercase list of user zabbix_all_users = [x.lower() for x in zabbix_all_users] for eachGroup in self.ldap_groups: ldap_users = self.ldap_conn.get_group_members(eachGroup) # Lowercase list of users ldap_users = {k.lower(): v for k, v in ldap_users.items()} # Do nothing if LDAP group contains no users and "--delete-orphans" is not specified if not ldap_users and not self.deleteorphans: continue zabbix_grpid = [ g['usrgrpid'] for g in self.get_groups() if g['name'] == eachGroup ].pop() zabbix_group_users = self.get_group_members(zabbix_grpid) missing_users = set(list( ldap_users.keys())) - set(zabbix_group_users) # Add missing users for eachUser in missing_users: # Create new user if it does not exists already if eachUser not in zabbix_all_users: self.logger.info( 'Creating user "%s", member of Zabbix group "%s"' % (eachUser, eachGroup)) user = {'alias': eachUser} if self.ldap_conn.get_user_givenName( ldap_users[eachUser]) is None: user['name'] = '' else: user['name'] = self.ldap_conn.get_user_givenName( ldap_users[eachUser]).decode('utf8') if self.ldap_conn.get_user_sn( ldap_users[eachUser]) is None: user['surname'] = '' else: user['surname'] = self.ldap_conn.get_user_sn( ldap_users[eachUser]).decode('utf8') if not self.dryrun: self.create_user(user, zabbix_grpid, self.user_opt) zabbix_all_users.append(eachUser) else: # Update existing user to be member of the group self.logger.info( 'Updating user "%s", adding to group "%s"' % (eachUser, eachGroup)) if not self.dryrun: self.update_user(eachUser, zabbix_grpid) # Handle any extra users in the groups extra_users = set(zabbix_group_users) - set(list( ldap_users.keys())) if extra_users: self.logger.info( 'Users in group %s which are not found in LDAP group:' % eachGroup) for eachUser in extra_users: if self.deleteorphans: self.logger.info('Deleting user: "******"' % eachUser) if not self.dryrun: self.delete_user(eachUser) else: self.logger.info('User not in ldap group "%s"' % eachUser) # update users media onlycreate = False media_opt_filtered = [] for elem in self.media_opt: if elem[0] == "onlycreate" and elem[1].lower() == "true": onlycreate = True if elem[0] == "severity": media_opt_filtered.append( (elem[0], self.convert_severity(elem[1]))) else: media_opt_filtered.append(elem) if onlycreate: self.logger.info( "Add media only on newly created users for group >>>%s<<<" % eachGroup) zabbix_group_users = missing_users else: self.logger.info( "Update media on all users for group >>>%s<<<" % eachGroup) zabbix_group_users = self.get_group_members(zabbix_grpid) for eachUser in set(zabbix_group_users): eachUser = eachUser.lower() ldap_user = ldap_users.get(eachUser, None) if not ldap_user: continue if self.ldap_media: self.logger.info( '>>> Updating/create user media for "%s", update "%s"' % (eachUser, self.media_name)) if self.ldap_conn.get_user_media(ldap_user, self.ldap_media): sendto = self.ldap_conn.get_user_media( ldap_user, self.ldap_media).decode("utf8") else: sendto = self.ldap_conn.get_user_media( ldap_user, self.ldap_media) if sendto and not self.dryrun: self.update_media(eachUser, self.media_name, sendto, media_opt_filtered) else: self.logger.info( '>>> Ignoring media for "%s" because of configuration' % (eachUser)) self.ldap_conn.disconnect()
"""zabbix:host be added groups ;host be removed groups ; get the relationship between user,usergroup,hostgroup """ from pyzabbix import ZabbixAPI import setting print(setting.zURL) """zapi is global variable""" zabbix_url = username, passwd = zapi = ZabbixAPI(zabbix_url) zapi.login(username, passwd) class Objzabbix(object): def __init__(self): pass def getHostID(self,hosts=[]): pass def getGroupID(self,group=''): pass def addGroup(self,hosts=[],group=''): pass def removeGroup(self): pass def getUserGroup(self): pass
#!/usr/bin/env python """ Looks up a host based on its name, and then adds an item to it """ from pyzabbix import ZabbixAPI, ZabbixAPIException import sys import os # The hostname at which the Zabbix web interface is available # Replace with url to interface. Keep the quotes. ZABBIX_SERVER = 'Zabbix Web Interface URL' zapi = ZabbixAPI(ZABBIX_SERVER) # Login to the Zabbix API #replace username and password with the appropriate data. Keep the quotes around the data. zapi.login('username', 'password') command = "./zhostfinder.py -e -A" os.system(command) hostID = raw_input("What host ID will we be using:") #Delete the host from the console hosts = zapi.host.delete((hostID))
def login(self): self.client = ZabbixAPI(self.zab_host) self.client.login(self.zab_user, self.zab_pwd) self.botoclient = boto3.client('ec2')
def dump_load(filename): with open(filename, 'rb') as file: obj = pickle.load(file) return obj logging.info('Start.') if len(vuln_api_key) != 64: logging.error('Error: not a valid Vulners API-key') exit(1) # создаем сессию в заббикс try: zapi = ZabbixAPI(zbx_url, timeout=10) zapi.session.verify = zbx_verify_ssl zapi.login(zbx_user, zbx_pass) logging.info('Connected to Zabbix API v.{}'.format(zapi.api_version())) except Exception as e: logging.error( 'Error: Can\'t connect to Zabbix API. Exception: {}'.format(e)) exit(1) # Если матрица хостов есть - загружаем дамп с диска if os.path.exists(h_matrix_dumpfile): logging.info('Found a dump of the h_matrix in {}. Loading'.format( h_matrix_dumpfile)) h_matrix = dump_load(h_matrix_dumpfile) total_hosts = len(h_matrix) else:
#!/usr/bin/env python #coding:utf-8 #create_time: 2017/3/29 #author:sailq import ast from pyzabbix import ZabbixAPI zapi = ZabbixAPI("http://domain") zapi.login("user","passwd") import MySQLdb #建立一个连接 conn=MySQLdb.connect(host='host',user='******',passwd='passwd',db='dbname',port=3306) #建立一个游标 cur =conn.cursor() #根据group_name创建分组 def create_new_group(group_name): try: new=zapi.hostgroup.create(name=group_name) return new except Exception as e: pass #return new #获取标准的host_name(ip) def get_host(): list = [] remove_host_list=['192.168.100.1-H3C-5500','192.168.100.10-H3C-5500','192.168.100.3-H3C-5500','192.168.100.4-H3C-5500','192.168.100.2-H3C-5500','192.168.100.250-H3C-5800-Cluster','192.168.100.5-H3C-5500','192.168.100.6-H3C-5500','192.168.100.8-H3C-5500','172.16.21.45-H3C-5500','windows-WIN-2DKKICHMD6H'] host = zapi.host.get() for i in host: list.append(i['name']) for d_host in remove_host_list: if d_host in list: list.remove(d_host)
#!/usr/bin/python from pyzabbix import ZabbixAPI import array URL_ZABBIX = "" USER_ZABBIX = "" PASSWORD_ZABBIX = "" # Fazendo login zapi = ZabbixAPI(URL_ZABBIX) zapi.login(USER_ZABBIX, PASSWORD_ZABBIX) # Coletando todos hosts e seus respectivos status hosts_dis = zapi.host.get(output=["name", "status"]) # For nos hosts e verifica o status (disable = 1) for host in hosts_dis: status = int(host['status']) if (status == 1): print host['name']
""" Import Zabbix XML templates """ from pyzabbix import ZabbixAPI, ZabbixAPIException import glob # The hostname at which the Zabbix web interface is available ZABBIX_SERVER = 'https://zabbix.example.com' zapi = ZabbixAPI(ZABBIX_SERVER) # Login to the Zabbix API zapi.login("admin", "zabbix") rules = { 'applications': { 'createMissing': 'true', 'updateExisting': 'true' }, 'discoveryRules': { 'createMissing': 'true', 'updateExisting': 'true' }, 'graphs': { 'createMissing': 'true', 'updateExisting': 'true' }, 'groups': { 'createMissing': 'true' },
nomehosttrigger = [] severidade = [] dicionario = { '1': 'Information', '2': 'Warning', '3': 'Average', '4': 'High', '5': 'Disaster' } url = str(raw_input("Digite a Url: ")) user = str(raw_input("Digite o User: "******"Digite a Senha: ")) zapi = ZabbixAPI(url=url, user=user, password=password) print(zapi.api_version()) for l in zapi.host.get(output='extend'): hostname.append(l['host']) triggers.append('Trigger') nomehosttrigger.append('Hostname') severidade.append('Severidade') for x in hostname: for item in zapi.trigger.get(output='extend', filter={'host': x}): nomehosttrigger.append(x) triggers.append(item['description']) severidade.append(dicionario[item['priority']])
import sys reload(sys) sys.setdefaultencoding('utf-8') hgname = [] hgid = [] hi = [] hh = [] group = [] host = [] user = str(raw_input("Digite o User: "******"Digite a senha: ")) zapi = ZabbixAPI('http://localhost/zabbix') zapi.login(user, password) print(zapi.api_version()) for x in zapi.host.get(output='extend'): hi.append(x['hostid']) hh.append(x['host']) for linha in zapi.hostgroup.get(output='extend'): hgid.append(linha['groupid']) #print linha['name'] for i in hh: #print i for y in zapi.host.get(selectGroups='extend', filter={'host': i}):
# -*- coding: utf-8 -*- from pyzabbix import ZabbixAPI from pprint import pprint from transliterate import translit,get_available_language_codes import MySQLdb #выполнить подключние к zabbix zabbix_connect= ZabbixAPI('http://172.20.103.201', user='******',password='******') sql_connect = MySQLdb.connect(host='192.168.0.5', user='******', password='******', charset='utf8', use_unicode=False, db='radio') #try: # with cursor=sql_connect.cursor() print (cursor) #cursor.execute("SET NAMES UTF8") #cursor.execute("SET CHARACTER SET 'utf8'") #cursor.execute("SET character_set_connection=utf8") sql='SELECT * FROM devices_bases' sql2='''SELECT DIP.id,CONCAT_WS(" ", CONCAT("AK-", DC.fio), CONCAT("BS", DB.base, " ", DB.address), CONCAT("RRL-Master ", DRL1.comments), CONCAT("RRL-Slave ", DRL2.comments)) FROM devices_ip_addresses DIP LEFT JOIN devices_bases DB ON DIP.id = DB.ip_id LEFT JOIN devices_complekts DC ON DIP.id = DC.ip_id LEFT JOIN devices_rrl DRL1 ON DIP.id = DRL1.ip_id_master LEFT JOIN devices_rrl DRL2 ON DIP.id = DRL2.ip_id_slave WHERE ip = "192.168.32.43"'''
class Zabbix: # use only as Static (u can use it as instance but it probably has error and unhandled exception) # only static methods and variables url = 'http://zabbix.sys.local' # url of zabbix api urlnet = 'http://zabbixnet.sys.local' # url of zabbix api zapi = ZabbixAPI(url) # pyzabbix class zapinet = ZabbixAPI(urlnet) # pyzabbix class login = '******' # login to access zabbix api loginnet = 'xxxxxx' # login to access zabbixnet api password = '******' # password to access zabbix api passwordnet = 'xxxxxxxxx' # password to access zabbixnet api ############################## NO NEEDED ################################################ def __init__(self): self.login = '******' self.password = '******' self.url = 'http://zabbix.sys.local' self.zapi = ZabbixAPI(self.url) self.zapi.login(self.login, self.password) ############################## NO NEEDED ################################################ #def __login_before(method): # # @functype - Decorator # # @rtype - None(if excpetion) or function result # # This decorator try log in zabbix api before send request # if not Zabbix.zapi.auth: # field auth is string '' # Zabbix.zapi.login(Zabbix.login, Zabbix.password) # login by ZabbixAPI lib if not loged in # def wrapper(*args, **kwargs): # try: # return method(*args, **kwargs) # original method return # except ZabbixAPIException: # try: # Zabbix.zapi.login(Zabbix.login, Zabbix.password) # try login again # return method(*args, **kwargs) # except: # return None # return wrapper ############################## NO NEEDED ################################################ @classmethod def log_in(cls, zabbix='all', anyway=False): if zabbix == 'all': if anyway: cls.zapi.login(cls.login, cls.password) cls.zapinet.login(cls.loginnet, cls.passwordnet) if not cls.zapi.auth: cls.zapi.login(cls.login, cls.password) if not cls.zapinet.auth: cls.zapinet.login(cls.loginnet, cls.passwordnet) elif zabbix == cls.url: if anyway: cls.zapi.login(cls.login, cls.password) if not cls.zapi.auth: cls.zapi.login(cls.login, cls.password) elif zabbix == cls.urlnet: if anyway: cls.zapinet.login(cls.loginnet, cls.passwordnet) if not cls.zapinet.auth: cls.zapinet.login(cls.loginnet, cls.passwordnet) @classmethod def _get_zapi_by_url(cls, zabbix): if zabbix == cls.url: return cls.zapi elif zabbix == cls.urlnet: return cls.zapinet @classmethod def _request_hosts(cls, zabbix): cls.log_in(zabbix) zapi = cls._get_zapi_by_url(zabbix) try: result = zapi.host.get(output="extend", selectGroups="extend") return result except: try: cls.log_in(zabbix, anyway=True) result = zapi.host.get(output="extend", selectGroups="extend") return result except: return None @classmethod def request_hg_with_h(cls, zabbix): def has_group(groupid, group_list): for group in group_list: if group.get('id') == groupid: return True return False current_zabbix = zabbix[7:] try: result = list() rec_hosts = cls._request_hosts(zabbix) for host in rec_hosts: hostid = host['hostid'] hostname = host['name'] groups = host['groups'] for group in groups: groupid = group['groupid'] groupname = group['name'] if has_group(groupid, result): for idx, hg in enumerate(result): if hg.get('id') == groupid: result[idx].get('hosts').append({ 'id': hostid, 'name': hostname, 'zabbix': current_zabbix }) else: result.append({ 'id': groupid, 'name': groupname, 'zabbix': current_zabbix, 'hosts': [{ 'id': hostid, 'name': hostname, 'zabbix': current_zabbix }] }) return result except: return None @classmethod def get_hg_with_h(cls): # @rtype - list of host_groups with attached hosts or None by decorator # @return - [ { 'id': '@host_group_id', 'name': '@host_group_name', 'zabbix': @zabbixurl, 'hosts': [{'id': '@host_id', 'name': '@host_name', 'zabbix': @zabbixurl}, ...] }, ...] # @return - or None result = cls.request_hg_with_h(cls.url) if result == None: result = cls.request_hg_with_h(cls.urlnet) else: resultnet = cls.request_hg_with_h(cls.urlnet) if resultnet != None: result.extend(resultnet) return result @classmethod def _request_create_mm(cls, zabbix, **kwargs): # kwargs must include 'desciption', 'name', 'start', 'end', 'hostids' # 'start' and 'end' - is timestamp timeperiods = [{ 'period': kwargs['end'] - kwargs['start'], # duration mm in seconds 'start_date': kwargs['start'], # timestamp of start mm 'timeperiod_type': 0 # type of mm (0-once, 2-daily, 3-weekly,4-monthly) }] zapi = cls._get_zapi_by_url(zabbix) cls.log_in(zabbix) # log in if not logged try: response = zapi.maintenance.create( name=kwargs['name'], active_since=kwargs['start'], active_till=kwargs['end'], description=kwargs['description'], hostids=kwargs['hostids'], timeperiods=timeperiods) if 'maintenanceids' in response: # if hasn't maintenanceids in response Fail return False return True else: # else then response has maintenanceids in response Success return True return False except: cls.log_in(zabbix, anyway=true) # log in again anyway response = zapi.maintenance.create( name=kwargs['name'], active_since=kwargs['start'], active_till=kwargs['end'], description=kwargs['description'], hostids=kwargs['hostids'], timeperiods=timeperiods) if 'maintenanceids' in response: # if hasn't maintenanceids in response Fail return False return True else: # else then response has maintenanceids in response Success return True return False @classmethod def create_mm(cls, **kwargs): # kwargs must include 'desciption', 'name', 'start', 'end', 'hostids' # 'hostids' - is [{'id': @id, 'zabbix': @zabbixurl}, ...] # 'start' and 'end' - is timestamp hostids = list() for host in kwargs.get('hostids'): if host['zabbix'] == cls.url[7:]: hostids.append(host['id']) hostidsnet = list() for host in kwargs.get('hostids'): if host['zabbix'] == cls.urlnet[7:]: hostidsnet.append(host['id']) zabbix = cls.url zabbixnet = cls.urlnet result = {'error': {'code': 0, 'message': 'Режим успешно создан'}} if len(hostids): if cls._request_create_mm(zabbix, name=kwargs['name'], start=kwargs['start'], end=kwargs['end'], description=kwargs['description'], hostids=hostids): if len(hostidsnet): if not cls._request_create_mm( zabbixnet, name=kwargs['name'], start=kwargs['start'], end=kwargs['end'], description=kwargs['description'], hostids=hostidsnet): result = { 'error': { 'code': 11, 'message': 'Режим обслуживания для ' + zabbixnet[7:] + ' не был создан, однако режим обслуживания для ' + zabbix[7:] + ' был создан' } } else: if len(hostidsnet): if not cls._request_create_mm( zabbixnet, name=kwargs['name'], start=kwargs['start'], end=kwargs['end'], description=kwargs['description'], hostids=hostidsnet): result = { 'error': { 'code': 12, 'message': 'Ошибка обращения к Zabbix API режим обслуживание не был создан' } } else: result = { 'error': { 'code': 13, 'message': 'Режим обслуживания для ' + zabbix[7:] + ' не был создан, однако режим обслуживания для ' + zabbixnet[7:] + ' был создан' } } else: result = { 'error': { 'code': 12, 'message': 'Ошибка обращения к Zabbix API режим обслуживание не был создан' } } elif len(hostidsnet): if not cls._request_create_mm(zabbixnet, name=kwargs['name'], start=kwargs['start'], end=kwargs['end'], description=kwargs['description'], hostids=hostidsnet): result = { 'error': { 'code': 12, 'message': 'Ошибка обращения к Zabbix API режим обслуживание не был создан' } } return result @classmethod def logout(cls): cls.zapi.user.logout() @staticmethod def validate_auth(login, password): try: zapi = ZabbixAPI('http://zabbix.sys.local') zapi.login(login, password) zapi.user.logout() return True except: return False
parser.add_argument('--verbose', dest = 'verbose', action = 'store_true') parser.set_defaults(verbose=True) parser.add_argument('--loglevel', dest = 'loglevel', default = 'ERROR', help = 'Debug level. DEBUG/INFO/WARNING/ERROR/CRITICAL') parser.add_argument('--max-age', dest = 'max_age', default = 31, help = 'Max age in days for host to be in there') parser.add_argument('--no-run', dest = 'run', action = 'store_false', help = 'Dont remove any host, just count') parser.add_argument('--run', dest = 'run', action = 'store_true', help = 'Remove all hosts that expired') parser.add_argument('--no-matches', dest = 'matches', action = 'store_false', help = 'Dont remove any host that has no prefix') parser.add_argument('--matches', dest = 'matches', action = 'store_true', help = 'Remove all hosts that has no prefix') args = parser.parse_args() TIMEOUT = 30.0 LOGFILE = "/tmp/%s.log" % path.basename(argv[0]) logger = LogPrint(echo=args.verbose, logfile=LOGFILE, loglevel=args.loglevel.upper()) try: zapi = ZabbixAPI(args.url,timeout=TIMEOUT) zapi.login(args.user,args.password) except Exception, e: logger.error("Unable to login: %s" % (e)) exit(1) call = { "output": [ "name", "hostid", ], "groupids": [ 72 ], } hosts = zapi.host.get(**call) hosts_exclude = [] hosts_no_match = [] date_curr = datetime.now() """
class Zabbix: def __init__(self, server, user, password, verify=True): """ Init zabbix class for further needs :param user: string :param password: string :return: pyzabbix object """ self.server = server self.user = user self.password = password # Enable HTTP auth s = requests.Session() s.auth = (user, password) self.zapi = ZabbixAPI(server, s) self.zapi.session.verify = False self.zapi.login(user, password) self.version = self.get_version() @pyzabbix_safe() def get_version(self): """ Get Zabbix API version :return: str """ version = self.zapi.apiinfo.version() return version @pyzabbix_safe({}) def get_trigger(self, triggerid): """ Get trigger information @param triggerid: string @return: dict of data """ trigger = self.zapi.trigger.get(expandComment='true', expandDescription='true', triggerids=triggerid) return trigger[0] @pyzabbix_safe({}) def get_event(self, triggerid): """ Get event information based on triggerid @param triggerid: string @return: dict of data """ zbx_event = self.zapi.event.get(select_acknowledges='extend', expandDescription='true', object=0, value=1, objectids=triggerid) if len(zbx_event) >= 1: return zbx_event[-1] return zbx_event @pyzabbix_safe([]) def get_itservices(self, root=None): """ Return tree of Zabbix IT Services root (hidden) - service1 (Cachet componentgroup) - child_service1 (Cachet component) - child_service2 (Cachet component) - service2 (Cachet componentgroup) - child_service3 (Cachet component) :param root: Name of service that will be root of tree. Actually it will not be present in return tree. It's using just as a start point , string :return: Tree of Zabbix IT Services :rtype: list """ if root: root_service = self.zapi.service.get(selectDependencies='extend', filter={'name': root}) try: root_service = root_service[0] except IndexError: logging.error( 'Can not find "{}" service in Zabbix'.format(root)) sys.exit(1) service_ids = [] for dependency in root_service['dependencies']: service_ids.append(dependency['serviceid']) services = self.zapi.service.get(selectDependencies='extend', serviceids=service_ids) else: services = self.zapi.service.get(selectDependencies='extend', output='extend') if not services: logging.error( 'Can not find any child service for "{}"'.format(root)) return [] # Create a tree of services known_ids = [] # At first proceed services with dependencies as groups service_tree = [i for i in services if i['dependencies']] for idx, service in enumerate(service_tree): child_services_ids = [] for dependency in service['dependencies']: child_services_ids.append(dependency['serviceid']) child_services = self.zapi.service.get( selectDependencies='extend', serviceids=child_services_ids) service_tree[idx]['dependencies'] = child_services # Save ids to filter them later known_ids = known_ids + child_services_ids known_ids.append(service['serviceid']) # At proceed services without dependencies as singers singers_services = [ i for i in services if i['serviceid'] not in known_ids ] if singers_services: service_tree = service_tree + singers_services return service_tree
def __init__(self, url, user, password): self.zb = ZabbixAPI(url) self.zb.login(user, password)
print "\n---------------------------" print "host_name: %s" % host_name print "host_invMode: %s" % host_invMode print "---------------------------\n" # GET LOCAL CONFIGURATION config = get_config("zdh.conf") server = {} server['url'] = config.get('server', 'url') server['user'] = config.get('server', 'user') server['password'] = config.get('server', 'password') logger.debug("server = '%s'" % server) # LOGIN TO ZABBIX zapi = ZabbixAPI(server['url']) zapi.login(server['user'], server['password']) logger.debug("connected to Zabbix API Version %s" % zapi.api_version()) #zapi.host.massupdate(hosts=hlookup,inventory_mode=invm) #11008 if host_invMode == "auto": host_invMode = int(1) elif host_invMode == "disabled": host_invMode = int(-1) elif host_invMode == "manual": host_invMode = int('0') else: msg = "Error: unknown inventory mode: %s" % host_invMode sys.exit(msg) #hlookup.append({unicode('hostid'): unicode(hid)})
if args.no_verify: noverify = args.no_verify # test for needed params if not username: sys.exit("Error: API User not set") if not password: sys.exit("Error: API Password not set") if not api: sys.exit("Error: API URL is not set") # Setup Zabbix API connection print api zapi = ZabbixAPI(api, user=username, password=password) print "OK" if noverify is True: zapi.session.verify = False # Login to the Zabbix API print username #zapi.login(username, password) ################################## # Start actual API logic ################################## # Base API call call={'sortfield': 'clock', 'sortorder': 'DESC', 'output': 'extend', 'source': 0}
bot.sendMessage( group_id, 'Nome: ' + w['name'] + '\nURL: ' + s['url'] + '\nStatus: ' + s['status_codes']) def main(): sched.start() daemon = daemon_server('/var/run/TeleZabbix.pid') if len(sys.argv) >= 2: if sys.argv[1] == 'start': api, group_id, username, password, server = get_conf() zapi = ZabbixAPI(server) zapi.login(username, password) bot = telepot.Bot(api) daemon.start() elif sys.argv[1] == 'stop': daemon.stop() elif sys.argv[1] == 'restart': daemon.stop() daemon.start() elif sys.argv[1] == 'status': daemon.is_running() else:
import argparse import sys from pprint import pprint from pyzabbix import ZabbixAPI, ZabbixAPIException SERVER_ZABBIX = 'http://192.168.33.65/zabbix' LOGIN_ZABBIX = 'kolas' PASSWORD_ZABBIX = '' z = ZabbixAPI(SERVER_ZABBIX) z.login(user=LOGIN_ZABBIX, password=PASSWORD_ZABBIX) def get_users(z): try: response = z.do_request(method="user.get", params={ "filter": "alias", "output": ["userid", "alias"] }) result = response['result'] except ZabbixAPIException as e: print(e) print(result) def get_user_info(z, user_name): try: response = z.do_request(method="user.get", params={ "search": {
from pyzabbix import ZabbixAPI, ZabbixAPIException import sys # The hostname at which the Zabbix web interface is available ZABBIX_SERVER = "https://zabbix.tacc.utexas.edu" zapi = ZabbixAPI(ZABBIX_SERVER) # Login to the Zabbix API username = '******' password = '' zapi.login(username, password) host_name = '' # Get the hosts with the name 'host_name' hosts = zapi.host.get(filter={"host": host_name}, selectInterfaces=["interfaceid"])
class ZAAS: def __init__(self, zab_host, zab_user, zab_pwd): """ Init class :param zab_host: Zabbix URL :param zab_user: Zabbix Username :param zab_pwd: Zabbix Pwd """ self.zab_host = zab_host self.zab_user = zab_user self.zab_pwd = zab_pwd def login(self): self.client = ZabbixAPI(self.zab_host) self.client.login(self.zab_user, self.zab_pwd) self.botoclient = boto3.client('ec2') def addhost(self, name, ip, hostgroupid, templates, port=10050): """ Add new EC2 host to zabbix :param name: Name used into hostname field :param ip: Public ip of the EC2 instance :param port: Zabbix agent port :param hostgroupid: Group Host ID to add :param templates: Template to link into instances host :return: None """ params = { "host": name, "groups": hostgroupid, "interfaces": [{ "type": 1, "main": 1, "useip": 1, "ip": ip, "dns": "", "port": 10050 }] } if templates: params["templates"] = templates log.info("Adding %s" % name) self.client.host.create(params) def get_ec2details(self, instanceid): """ Get ec2 instance details :params instanceid: Instance EC2 ID :return: {"name": "<private ip without ec2 part>", "ip": "<public ip>"} """ out = {} req = self.botoclient.describe_instances(InstanceIds=[instanceid]) if req: name = req["Reservations"][0]["Instances"][0][ "PrivateDnsName"].split(".")[0] ip = req["Reservations"][0]["Instances"][0]["PublicIpAddress"] return {"name": name, "ip": ip} def gethostid(self, name): """ Get HostID from Zabbix Server :params name: Name to check :return: HostID """ for hit in self.client.host.get(): if hit["host"] == name: return hit["hostid"] def delhost(self, name): """ Delete the host from Zabbix server :params name: Host name to delete :return: None """ log.info("Deleting %s" % name) hostid = self.gethostid(name) params = str(hostid) if hostid: self.client.host.delete(params)
#!/usr/bin/python from getpass import getpass from pyzabbix import ZabbixAPI ZABBIX_SERVER = 'http://192.168.1.102/zabbix' zapi = ZabbixAPI(ZABBIX_SERVER) zapi.login('apiuser', 'apipass') #Get a hostlist hostlist = zapi.host.get(output='extend') for host in hostlist: print "Clean not templated items from", host['name'] itemlist = zapi.item.get(output='extend', filter={"hostid": host['hostid']}) #Templateid is "0" for non-templated, something else for templated item for i in itemlist: if i['templateid'] == "0": zapi.item.delete(i['itemid']) print i['name'], " - deleted" else: print i['name'], " - preserved"
import re from pprint import pprint from pyzabbix import ZabbixAPI, ZabbixAPIException from jira.client import JIRA from consts import SERVER_ZABBIX, LOGIN_ZABBIX, PASSWORD_ZABBIX, SERVER_JIRA, LOGIN_JIRA, PASSWORD_JIRA # connect to the zabbix z = ZabbixAPI(SERVER_ZABBIX) z.login(user=LOGIN_ZABBIX, password=PASSWORD_ZABBIX) # connect to the jira jira_options = {'server': SERVER_JIRA} jira = JIRA(options=jira_options, basic_auth=(LOGIN_JIRA, PASSWORD_JIRA)) issues = jira.search_issues( 'project = ZNET AND NOT status = Canceled AND NOT status = Closed', maxResults=100) list_issue = [] # empty list for znet numbers for issue in issues: list_issue.append(issue.key) # add znet issue # pprint(list_issue) # find host in group ZNET (id=37) hosts = z.host.get(groupids=[37]) list_host_names = [] # empty list with hosts names for host in hosts: list_host_names.append(host['name'])
class ZabbixAgent(object): def __init__(self, url, login, password): self.url = url self.login = login self.password = password self.zbx_api = ZabbixAPI(url=url, use_authenticate=False, user=login, password=password) log.debug('Object ZabbixAgent created') log.debug('API ver. %s', self.api_ver()) def get_item_data(self, hostname, item): hostid = self.zbx_api.host.get(filter={'name': hostname}, output='shorten')[0]['hostid'] log.debug('hostID %s', hostid) if not hostid: raise ZbxException("hostname: {} not found".format(hostname)) item_data = self.zbx_api.item.get(filter={ 'hostid': hostid, 'key_': item }, output=['lastvalue']) log.debug('itemID %s', hostid) if not item_data: raise ZbxException('item: {} not found'.format(item)) if len(item_data) > 1: raise ZbxException('return items expected one item') return int(item_data[0]['lastvalue']) def get_item_data2(self, hostname, item_in, item_out): hostid = self.zbx_api.host.get(filter={'name': hostname}, output='shorten')[0]['hostid'] log.debug('hostID %s', hostid) if not hostid: raise ZbxException("hostname: {} not found".format(hostname)) item_in_data = self.zbx_api.item.get(filter={ 'hostid': hostid, 'key_': item_in }, output=['lastvalue']) log.debug('itemID %s', hostid) if not item_in_data: raise ZbxException('item: {} not found'.format(item_in)) item_out_data = self.zbx_api.item.get(filter={ 'hostid': hostid, 'key_': item_out }, output=['lastvalue']) log.debug('itemID %s', hostid) if not item_in_data: raise ZbxException('item: {} not found'.format(item_out)) if len(item_in_data) > 1: raise ZbxException( 'return items expected one item: {}'.format(item_in_data)) if len(item_out_data) > 1: raise ZbxException( 'return items expected one item: {}'.format(item_out_data)) return int(item_in_data[0]['lastvalue']), int( item_out_data[0]['lastvalue']) def api_ver(self): return self.zbx_api.api_version() def scan_map(self, map_name): map_data = self.zbx_api.map.get( filter={'name': map_name}, selectSelements=[ 'elementid', 'selementid', 'elementtype', 'iconid_off', 'x', 'y' ], selectLinks=['selementid1', 'selementid2', 'linkid']) if not map_data: raise ZbxException('map: {} not found'.format(map_name)) if len(map_data) > 1: raise ZbxException('return mapss expected one map') return map_data[0] def scan_map_all(self): maps_data = self.zbx_api.map.get( selectSelements=[ 'elementid', 'selementid', 'elementtype', 'iconid_off', 'x', 'y' ], selectLinks=['selementid1', 'selementid2', 'linkid']) if not maps_data: raise ZbxException('maps not found') if len(maps_data) > 1: raise ZbxException('return maps expected one map') return maps_data def get_hostname(self, hostid): hostname = self.zbx_api.host.get(hostids=hostid, output=['host']) if not hostname: raise ZbxException('hostname not found') if len(hostname) > 1: raise ZbxException('return hostnames expected one hostname') return hostname[0]['host'] def get_mapname(self, mapid): mapname = self.zbx_api.map.get(sysmapids=mapid, output=['name']) if not mapname: raise ZbxException('map name not found') if len(mapname) > 1: raise ZbxException('return map names expected one map name') return mapname[0]['name'] def get_triggername(self, triggerid): triggername = self.zbx_api.trigger.get(triggerid=triggerid, output=['description']) if not triggername: raise ZbxException('trigger name not found') if len(triggername) > 1: raise ZbxException( 'return trigger names expected one trigger name') return triggername[0]['description'] def get_hostgroupname(self, groupid): hostgroupname = self.zbx_api.hostgroup.get(groupids=groupid, output=['name']) if not hostgroupname: raise ZbxException('hostgroup name not found') if len(hostgroupname) > 1: raise ZbxException( 'return hostgroup names expected one hostgroup name') return hostgroupname[0]['name'] def get_imagename(self, imageid): imagename = self.zbx_api.image.get(imageids=imageid, output=['name']) if not imagename: raise ZbxException('image name not found') if len(imagename) > 1: raise ZbxException('return image names expected one image name') return imagename[0]['name'] def image_to_zabbix(self, pathfn, zbx_img_name): with open(pathfn, 'rb') as img: b64img = base64.b64encode(img.read()).decode() image_data = self.zbx_api.image.get(filter={'name': zbx_img_name}) if not image_data: self.zbx_api.image.create(name=zbx_img_name, imagetype=2, image=b64img) else: self.zbx_api.image.update(imageid=image_data[0]['imageid'], image=b64img) def image_get(self, imageid): image_data = self.zbx_api.image.get(imageids=imageid, select_image=True) return image_data[0]['image']
HOST = 'mail.server' #IMAP SERVER USERNAME = '******' #IMAP username PASSWORD = '******' #IMAP user password eventid = sys.argv[1] #EventID argument from zbx #Disable SSL check ssl_context = ssl.create_default_context() ssl_context.check_hostname = False ssl_context.verify_mode = ssl.CERT_NONE with IMAPClient(HOST, ssl_context=ssl_context) as server: server.login(USERNAME, PASSWORD) select_info = server.select_folder('INBOX') messages = server.search(['SUBJECT', eventid]) #Search zbx EventID in Subject for msgid, data in server.fetch(messages, 'RFC822').items(): email_message = email.message_from_bytes(data[b'RFC822']) subj = email_message.get('Subject') server.logout() os.environ['no_proxy'] = '*' #Avoid systemwide proxy if needed #Set ACK without closing problem zapi = ZabbixAPI('https://zabbix.server/zabbix') zapi.session.verify = False zapi.login('Login', 'Password') ack = zapi.event.acknowledge( eventids= eventid, message= subj[0:16], action=0 )
def __init__(self): self.login = '******' self.password = '******' self.url = 'http://zabbix.sys.local' self.zapi = ZabbixAPI(self.url) self.zapi.login(self.login, self.password)
""" import os import json import string from pyzabbix import ZabbixAPI #import credentials from external file import sys sys.path.insert(0,'/var/lib/zabbix') import config # The hostname at which the Zabbix web interface is available ZABBIX_SERVER = config.url zapi = ZabbixAPI(ZABBIX_SERVER) # Login to the Zabbix API zapi.login(config.username, config.password) # define the API call from # https://www.zabbix.com/documentation/3.4/manual/api/reference/maintenance/create maintenance = { "groupids": ["24"], "name": "test_maintenance", "maintenance_type": 0, "active_since": 1532260800, "active_till": 1532347200, "description": "I am trying to create a maintenance via API", "timeperiods": [{ "timeperiod_type": "0",
""" Zabbix stores the DNS name and the IP for each host that it monitors, and uses one or the other to connect to the host. It is good practice to make sure the IP and DNS name are both correct. This script checks the DNS and IP for all hosts in Zabbix, compares the IP against an actual DNS lookup, and fixes it if required. """ import socket from pyzabbix import ZabbixAPI, ZabbixAPIException from getpass import getpass # The hostname at which the Zabbix web interface is available ZABBIX_SERVER = 'https://console.schools.mtm.apps.det.nsw.edu.au/zabbix' zapi = ZabbixAPI(ZABBIX_SERVER) # Login to the Zabbix API zapi.login(input('Zabbix Username: '******'Zabbix Password: '******'dns'] != h['hosts'][0]['host']: print('Warning: %s has dns "%s"' % (h['hosts'][0]['host'], h['dns']))
if args.no_verify: noverify = args.no_verify # test for needed params if not username: sys.exit("Error: API User not set") if not password: sys.exit("Error: API Password not set") if not api: sys.exit("Error: API URL is not set") # Setup Zabbix API connection zapi = ZabbixAPI(api) if noverify is True: zapi.session.verify = False # Login to the Zabbix API zapi.login(username, password) ################################## # Start actual API logic ################################## # set the hostname we are looking for graphid = args.graphid # Find graph from API
def create_hosts(config): """ Take in a config and return a list of Host objects This is used in all areas of clustertop so its been seperated into its own function. :param config: The ConfigParser object holding the clustertop config :type config: ConfigParser """ zapi = ZabbixAPI(config.get('main', 'zabbix_host')) zapi.login(config.get('main', 'zabbix_user'), config.get('main', 'zabbix_pass')) return [Host(hn, zapi) for hn in config.get('main', 'hosts').split(',')]
def get_metrics(host, num_minutes): """ get monitoring statistics of hypervisors using zabbix; :param host: :param num_minutes: :return: """ mem_rs, cpu_rs, disk_rs, net_rs = {}, {}, {}, {} mem_rs['time'], mem_rs['value'] = [], [] cpu_rs['time'], cpu_rs['value'] = [], [] disk_rs['time'], disk_rs['value'] = [], [] net_rs['time'], net_rs['value'] = [], [] zapi = ZabbixAPI(config.ZABBIX_URL) zapi.login(config.ZABBIX_USER, config.ZABBIX_PASSWD) time_till = time.mktime(datetime.datetime.now().timetuple()) time_from = time_till - 60 * num_minutes cpu_idle_id = zapi.item.get(filter={'host': host, 'name': 'CPU idle time'})[0]['itemid'] disk_free_id = zapi.item.get(filter={'host': host, 'name': 'disk_usage'})[0]['itemid'] mem_avail_id = zapi.item.get(filter={'host': host, 'name': 'mem_avail_usage'})[0]['itemid'] # net_in_id = zapi.item.get(filter={'host':host, 'name':'net_total_in'})[0]['itemid'] # get statistics of memory usage mem_avail_datas = zapi.history.get(itemids=[mem_avail_id], time_from=time_from, time_till=time_till, output='extend', history=0) for item in mem_avail_datas: mem_rs['time'].append(item['clock']) mem_rs['value'].append(round(100 - float(item['value']), 2)) # get statistics of cpu util cpu_idle_datas = zapi.history.get(itemids=[cpu_idle_id], time_from=time_from, time_till=time_till, output='extend', history=0) for item in cpu_idle_datas: cpu_rs['time'].append(item['clock']) cpu_rs['value'].append(round(100 - float(item['value']), 2)) disk_free_datas = zapi.history.get(itemids=[disk_free_id], time_from=time_from, time_till=time_till, output='extend', history=0) for item in disk_free_datas: disk_rs['time'].append(item['clock']) disk_rs['value'].append(round(float(item['value']), 2)) ''' net_in_datas = zapi.history.get(itemids=[net_in_id], time_from=time_from, time_till=time_till, output='extend', history=0) for item in net_in_datas: net_rs['time'].append(item['clock']) net_rs['value'].append(round(float(item['value']), 2)) ''' return {'cpu': cpu_rs, 'mem': mem_rs, 'disk': disk_rs, 'net_in': net_rs}