ZABBIX批量画图_PYTHON脚本

  1. #!/usr/bin/env python2.7  
  2.   
  3. from pyzabbix import ZabbixAPI  
  4. from datetime import datetime  
  5. import time  
  6. import sys  
  7.   
  8. class zabbix(object):  
  9.     def __init__(self, hostname,columns,name):  

  10.         self.hostname = hostname  
  11.         self.columns = columns  
  12.         self.dynamic = 0  
  13.         self.name = name  
  14.         self.server = ‘http://10.0.16.10/zabbix’  
  15.         self.user = ‘admin’  
  16.         self.passwd = ‘zabbix’  
  17.     def __login(self):  
  18.         zapi = ZabbixAPI(self.server)  
  19.         zapi.login(self.user,self.passwd)  
  20.         return zapi  
  21.   
  22.     def __get_host(self):  
  23.         list_host=self.__login().host.get(output=’extend‘,filter={‘host’:self.hostname,})  
  24. #       print list_host  
  25.         return list_host[0][‘hostid’]  
  26.   
  27.     def __get_item(self):  
  28.         list_item=self.__login().item.get(output=’extend‘,hostids=self.__get_host())  
  29.         itemids=[]  
  30.         for x in list_item:  
  31. #           print x[‘name’],x[‘itemid’]  
  32.             itemids.append(x[‘itemid’])  
  33. #       print itemids  
  34.         return itemids  
  35.   
  36.     def __get_history(self):  
  37.         self.values={}  
  38.         for history  in  self.__get_item():  
  39.             list_history=self.__login().history.get(output=’extend‘,itemids=history,limit=1)  
  40. #           print history  
  41. #           print list_history  
  42.             for point in list_history:            
  43. #               print(“{0}: {1}”.format(datetime.fromtimestamp(int(point[‘clock’])).strftime(“%x %X”), point[‘value’]))  
  44.                 if self.values.has_key(history):  
  45.                     self.values[history]=self.values[history]+int(point[‘value’])  
  46.                 else:  
  47.                     self.values[history]=int(point[‘value’])  
  48. #           break  
  49. #       print self.values     
  50.   
  51.     def __get_graph(self):  
  52.         graphids=[]  
  53.         list_graph=self.__login().graph.get(output=’extend‘,filter={“host”:self.hostname})  
  54.         for x in list_graph:  
  55.             #print x[‘graphid’]  
  56.             graphids.append(x[‘graphid’])  
  57.         print graphids    
  58.         return graphids  
  59.   
  60.   
  61.     def __get_graphitem(self):  
  62.         have_value_graph=[]  
  63.         for x in self.__get_graph():  
  64. #           print x  
  65.             list_graphitem=self.__login().graphitem.get(output=’extend‘,graphids=x)  
  66.               
  67.             have_value=[]  
  68.             for b in list_graphitem:  
  69.                 number=len(list_graphitem)  
  70.                 if b[‘itemid’] in self.values.keys():  
  71.                     if self.values[b[‘itemid’]] != 0:  
  72.             #           print self.values[b[‘itemid’]]  
  73.                         have_value.append(self.values[b[‘itemid’]])  
  74.             if len(have_value) > 0:  
  75.                 have_value_graph.append(x)  
  76. #       print have_value_graph  
  77.         x = 0  
  78.         y = 0  
  79.         graph_list=[]  
  80.         for graph in have_value_graph:  
  81. #           print “x is ” + str(x)  
  82. #           print “y is ” + str(y)  
  83.             graph_list.append({  
  84.                     “resourcetype”:’0′,  
  85.                     “resourceid”: graph,  
  86.                     “width”: “500”,  
  87.                     “height”: “100”,  
  88.                     “x”: str(x),  
  89.                     “y”: str(y),  
  90.                     “colspan”: “0”,  
  91.                     “rowspan”: “0”,  
  92.                     “elements”: “0”,  
  93.                     “valign”: “0”,  
  94.                     “halign”: “0”,  
  95.                     “style”: “0”,  
  96.                     “url”: “”,  
  97.                     “dynamic”: str(self.dynamic)  
  98.                     })    
  99.             x += 1  
  100. #           print type(x)  
  101. #           print type(self.columns)  
  102.             if x == int(self.columns):  
  103.                 x = 0  
  104.                 y += 1  
  105.         return graph_list  
  106.   
  107.     def __create_screen(self):        
  108.         graphids=self.__get_graphitem()  
  109.         columns = int(self.columns)  
  110.         if len(graphids) % self.columns == 0:  
  111.             vsize = len(graphids) / self.columns  
  112.         else:  
  113.             vsize = (len(graphids) / self.columns) + 1  
  114. #       print graphids  
  115.         self.__login().screen.create(name=self.name,hsize=self.columns,vsize=vsize,screenitems=graphids)  
  116.   
  117.     def __exists_screen(self):  
  118.         list_exists=self.__login().screen.exists(name=self.name)  
  119.         if list_exists:  
  120.             print ‘%s is exists’ % self.name  
  121.             sys.exit(1)   
  122.   
  123.     def __exists_host(self):  
  124.         list_exists=self.__login().host.exists(host=self.hostname)  
  125.         if not list_exists:  
  126.             print “%s is not exists” % self.hostname  
  127.   
  128.     def main(self):  
  129.         self.__exists_host()  
  130.         self.__exists_screen()  
  131. #       self.__get_host()  
  132. #       self.__get_item()         
  133.         self.__get_history()  
  134. #       self.__get_graph()  
  135. #       self.__get_graphitem()  
  136.         self.__create_screen()  
  137.   
  138. if __name__ == ‘__main__‘:  
  139.     from  optparse import OptionParser  
  140.     parser = OptionParser()  
  141.     parser.add_option(‘-G’, dest=’graphname’,  
  142.                         help=’Zabbix Host Graph to create screen from‘)  
  143.     parser.add_option(‘-H’, dest=’hostname’,  
  144.                         help=’Zabbix Host to create screen from‘)  
  145.     parser.add_option(‘-c’, dest=’columns’, type=int,  
  146.                         help=’number of columns in the screen’)  
  147.     options,args=parser.parse_args()  
  148. #   print options.columns  
  149. #   print options.hostname,options.columns,options.graphname  
  150.   
  151.   
  152.     a=zabbix(hostname=options.hostname,columns=options.columns,name=options.graphname)  
  153.     a.main()