def get(user, password, template, url):
zabbix = ZabbixAPI(url=url, user=user, password=password)
f = zabbix.do_request('template.get', {'filter': {'host': template},'output': 'templateid'})
templateid = f['result'][0]['templateid']
item = zabbix.do_request('item.get',{'templateids': templateid,'output': 'extend'})
for n in item['result']:
dict_item.update({ n['name']: n['key_']})
triggers = zabbix.do_request('trigger.get',{'templateids': templateid,'output': 'extend'})
for n in triggers['result']:
dict_trigger.update({ n['triggerid']: n['description']})
zabbix.user.logout()
def add_monitor(hostname, url=config.XG_URL, auth=config.XG_AUTH):
try:
zabbix_api = ZabbixAPI(url=url, use_auth=True, auth=auth)
hosts_id = zabbix_api.do_request('host.get', params={'output':'hostid', 'filter':{'host':[hostname]}})
if url==config.XG_URL:
zabbix_api.do_request('host.massadd', params={'hosts': hosts_id['result'],
'templates': config.XG_TEMPLATE_IDS})
else:
zabbix_api.do_request('host.massadd', params={'hosts': hosts_id['result'],
'templates': config.QC_TEMPLATE_IDS})
except Exception,e:
pass
def ack():
eventid = int(unquote(request.args['eventid']).replace("'", ''))
taskid = request.args['taskid']
action = app.config['ACTION']
#login to zabbix
zapi = ZabbixAPI(url=app.config['URL'],
user=app.config['USER'],
password=app.config['PWD'])
#acknowledge alert
zapi.do_request(
'event.acknowledge', {
'eventids': eventid,
'action': action,
'message':
'ServiceNow has created {} for this alert'.format(taskid)
})
#logut zabbix
zapi.do_request('user.logout')
return 'ok'
class Zabbix_Api:
def __init__(self, idc='qc'):
qc_url = ''
xg_url = ''
qc_auth = ''
xg_auth = ''
self.url = qc_url if idc == 'qc' else xg_url
self.auth = qc_auth if idc == 'qc' else xg_auth
self.z = ZabbixAPI(url=self.url, use_auth=True, auth=self.auth)
def Get_Token(self, user=None, password=None):
try:
token = self.z._login(user=user, password=password)
return token
except Exception as e:
print(e)
# 获取id,支持扩展获取所有id
def Get_ID(self,
HostName=None,
Template=None,
ScreenName=None,
Action='filter',
Macros_Flag=False,
Filter_Flag=False):
if HostName and len(HostName) <= 6:
exit('Warning: Hostname so short')
if HostName and '*' in HostName:
HostName = ''.join(HostName.split('*'))
Filter_Flag = True
Get_Input = HostName or Template or ScreenName
Host_List = []
Host_ID = []
Template_List = []
Template_ID = []
Screen_ID = []
Screen_List = []
try:
for l in Get_Input.split(','):
if HostName:
Host_List.append(l)
elif Template:
Template_List.append(l)
elif ScreenName:
Screen_List.append(l)
if Host_List:
# 模糊匹配与精确查询
Action = 'search' if Filter_Flag else Action
# Group_Flag = True if GroupName else Group_Flag
for h in Host_List:
host_id = self.z.do_request('host.get',
params={'output': ['host', 'hostid'], "%s" % Action: {'host': h}})
res = sorted(host_id['result'], key=lambda x: int(x['host'].split('-')[-1]))
for i in res:
del i['host']
Host_ID.append(i)
return Host_ID
elif Template_List:
for t in Template_List:
if Macros_Flag:
re = self.z.do_request('template.get',
params={'selectMacros': ['macro', 'value'], 'filter': {'host': t}})
macros = re['result'][0]['macros']
for i in macros:
i.pop('hosts')
data = re['result']
Template_ID.extend(data)
re = self.z.do_request('template.get', params={'output': 'templateid', 'filter': {'host': t}})
data = re['result']
Template_ID.extend(data)
return Template_ID
elif Screen_List:
for s in Screen_List:
re = self.z.do_request('screen.get', params={'output': 'screenid', 'filter': {'name': s}})
Screen_ID.append(re['result'][0]['screenid'])
return Screen_ID
except Exception as e:
print(e)
def Get_GroupID(self, GroupName=None):
try:
Group_ID = self.z.do_request('hostgroup.get', params={'output': 'extend', 'filter': {'name': GroupName}})
return Group_ID['result'][0]['groupid']
except Exception as e:
print(e)
def Get_GraphID(self, HostName=None, GraphName=None, Columns=3):
Graph_ID = []
Graph_List = []
x = 0
y = 0
try:
Host_ID = self.Get_ID(HostName=HostName)
Only_Host_ID = map(lambda x: x.values()[0], Host_ID)
for hostid in Only_Host_ID:
re_graphid = self.z.do_request('graph.get',
params={'output': ['graphid'],
'hostids': hostid,
'softfield': 'graphid', 'search': {'name': GraphName}})
if re_graphid['result']:
Graph_ID.append(re_graphid['result'][0]['graphid'])
else:
exit('Some host not have the graph: "%s" !' % GraphName)
for graph in Graph_ID:
Graph_List.append({
'resourcetype': '0',
'resourceid': graph,
'width': '500',
'height': '200',
'x': str(x),
'y': str(y),
'colspan': '0',
'rowspan': '0',
'elements': '0',
'valign': '0',
'halign': '0',
'style': '0',
'url': '',
'dynamic': '0'
})
x += 1
if x == int(Columns):
x = 0
y += 1
return Graph_ID, Graph_List
except Exception as e:
print(e)
def Screen_Create(self, HostName=None, GraphName=None, ScreenName=None, Columns=3):
try:
Graph_ID, Graph_List = self.Get_GraphID(HostName=HostName, GraphName=GraphName)
if len(Graph_ID) % Columns == 0:
vsize = len(Graph_ID) / Columns
else:
vsize = (len(Graph_ID) / Columns) + 1
Screen_ID = self.Get_ID(ScreenName=ScreenName)[0]
if Screen_ID:
re = self.z.do_request('screen.update', params={'screenid': Screen_ID,
'name': ScreenName,
'screenitems': Graph_List,
'hsize': Columns,
'vsize': vsize})
if re['result']['screenids']:
print('The screen : "%s" has been update!' % ScreenName)
else:
re = self.z.do_request('screen.create',
params={'name': ScreenName, 'hsize': Columns, 'vsize': vsize,
'screenitems': Graph_List})
if re['result']['screenids']:
print('The screen name: "%s" create succeed!' % ScreenName)
sys.exit(0)
exit('Screen create failed')
except Exception as e:
print(e)
def Create_Template(self, TemplateName=None, LinkTemplate=None, Template_ID=None, Macros=None):
try:
if LinkTemplate:
Template_Info = self.Get_ID(Template=LinkTemplate, Macros_Flag=True)[0]
Template_ID = Template_Info['templateid']
Macros = Template_Info['macros']
re = self.z.do_request('template.create',
params={'host': TemplateName, 'groups': {'groupid': 1},
'templates': Template_ID,
'macros': Macros})
if re['result']['templateids']:
print('Template "%s" create succeed!' % TemplateName)
except Exception as e:
print(e)
def Delete_Template(self, TemplateName=None):
Template_List = []
try:
Template_ID = self.Get_ID(Template=TemplateName)[0]['templateid']
Template_List.append(Template_ID)
re = self.z.do_request('template.delete', params=Template_List)
if re['result']['templateids']:
print('Template "%s" has been delete!' % TemplateName)
except Exception as e:
print(e)
def Mass_Remove_Templates(self, HostName=None, Templates=None):
data = []
try:
Host_ID = self.Get_ID(HostName=HostName)
Only_Host_ID = map(lambda x: x.values()[0], Host_ID)
for t in Templates.split(','):
Template_ID = self.Get_ID(Template=t)[0]['templateid']
re = self.z.do_request('host.massremove',
params={'hostids': Only_Host_ID, 'templateids_clear': Template_ID})
data.append(re['result'])
if data:
print('template has been unlink!')
sys.exit(0)
exit('template unlink failure!')
except Exception as e:
print(e)
def Mass_Add_Templates(self, HostName=None, Templates=None):
Templates_List = []
data = []
try:
Host_ID = self.Get_ID(HostName=HostName)
for t in Templates.split(','):
Templates_ID = self.Get_ID(Template=t)
Templates_List.extend(Templates_ID)
re = self.z.do_request('host.massadd', params={'hosts': Host_ID, 'templates': Templates_List})
data.append(re['result'])
if data:
print('Template has been link!')
sys.exit(0)
exit('Template link failure!')
except Exception as e:
print(e)
def Mass_Groups(self, HostName=None, GroupName=None, Method=None):
Group_ID = self.Get_GroupID(GroupName=GroupName)
Hosts_ID = self.Get_ID(HostName=HostName)
Only_Host_ID = map(lambda x: x.values()[0], Hosts_ID)
Mass = 'host.mass'
try:
if Method == 'replace':
Method = Mass + 'update'
elif Method == 'add':
Method = Mass + 'add'
re = self.z.do_request(Method, params={'hosts': Hosts_ID, 'groups': [{'groupid': Group_ID}]})
if re['result']['hostids']:
print('hosts information has been updated!')
elif Method == 'remove':
re = self.z.do_request('host.massremove', params={'hostids': Only_Host_ID, 'groupids': Group_ID})
if re['result']['hostids']:
print('hosts information has been updated!')
except Exception as e:
print(e)
def Method(self, ScreenName=None):
try:
Screen_ID = self.Get_ID(ScreenName=ScreenName)
re = self.z.do_request('screen.delete', params=Screen_ID)['result']['screenids']
if re:
print('%s has been delete' % ScreenName)
sys.exit(0)
print('The given screen name: "%s" not exists' % ScreenName)
except Exception as e:
print(e)
def Disable_Host(self, HostName=None, Method=None):
status = 0
data = []
try:
status = 1 if Method == 'disable' else status
Hostids = self.Get_ID(HostName=HostName)
if not Hostids:
exit('"%s" not exists!' % HostName)
for h in Hostids:
re = self.z.do_request('host.massupdate', params={'hosts': h, 'status': status})
data.append(re['result']['hostids'])
if not data:
exit('"%s" failed!' % Method)
print('hosts has been "%s" !' % Method)
except Exception as e:
print(e)
def main(self):
if len(sys.argv) == 1:
parse.print_help()
else:
args = parse.parse_args()
Method = ['delete', 'disable', 'enable', 'replace', 'remove', 'add', 'create']
# print(args)
if args.idc == 'xg':
self.__init__(idc='xg')
if args.method_link == 'unlink' and args.template and args.hostname:
self.Mass_Remove_Templates(HostName=args.hostname, Templates=args.template)
elif args.method_link == 'link' and args.template and args.hostname:
self.Mass_Add_Templates(HostName=args.hostname, Templates=args.template)
elif args.screen and args.hostname and args.graph:
self.Screen_Create(HostName=args.hostname, GraphName=args.graph, ScreenName=args.screen)
elif args.graph and args.hostname:
self.Get_GraphID(HostName=args.hostname, GraphName=args.graph)
elif args.method:
if args.screen and args.method in Method:
self.Method(ScreenName=args.screen)
elif args.group and args.hostname and args.method in Method:
self.Mass_Groups(HostName=args.hostname, GroupName=args.group, Method=args.method)
elif args.method == 'create' and args.template or args.link_template:
self.Create_Template(TemplateName=args.template, LinkTemplate=args.link_template)
elif args.method == 'delete' and args.template:
self.Delete_Template(TemplateName=args.template)
elif args.hostname and args.method in Method:
self.Disable_Host(HostName=args.hostname, Method=args.method)
elif args.hostname or args.template:
re = self.Get_ID(HostName=args.hostname, Template=args.template)
print(re)
metavar="IP")
parser.add_argument('--snmpsim-port',
dest="snmpsim_port",
default="161",
help="UDP port of the snmpsim server.",
metavar="161")
args = parser.parse_args()
try:
zapi = ZabbixAPI(url=args.api_url,
user=args.username,
password=args.password)
except ZabbixAPIException as err:
print(err.data)
else:
path = args.arg1[0]
if os.path.isdir(path):
# snmpsim
snmpsim_create = SnmpsimCreator(path, zapi, args.filter_str,
args.snmpsim_ip, args.snmpsim_dns,
args.snmpsim_port)
snmpsim_create.scan_snmpsim_root_dir()
hosts_create = HostsCreator(path, zapi, args.filter_str)
hosts_create.scan_snmpsim_root_dir()
else:
sys.exit("{0} is not a valid directory".format(path))
zapi.do_request('user.logout')
import os
from pyzabbix.api import ZabbixAPI
# Create ZabbixAPI class instance
pasted_URL = 'http://' + str(os.environ["MASTER_NODE_IP_PUBLIC"]) + '/zabbix/'
zapi = ZabbixAPI(url=str(pasted_URL), user='******', password='******')
node_name_removed = str(os.environ["NODE_NAME_REMOVED"])
# Get dictionary of host to be deleted
result_removed_host_id = zapi.do_request(
'host.get', {'filter': {
'name': [node_name_removed]
}})
# Get id of host to be deleted
parsed_removed_host_id = result_removed_host_id['result'][0]['hostid']
# Delete node based on its id
result_delete_node = zapi.do_request('host.delete', [parsed_removed_host_id])
# Logout from Zabbix
zapi.user.logout()
def main():
changed = False
module = AnsibleModule(supports_check_mode=False,
argument_spec={
"url": {
"type": "str",
"required": True
},
"default_password": {
"type": "str",
"required": False,
"default": "zabbix",
"no_log": True
},
"login_password": {
"type": "str",
"required": True,
"no_log": True
},
"users": {
"type": "list",
"required": False,
"no_log": False
}
})
try:
zapi = ZabbixAPI(
**{
'url': module.params['url'],
'user': '******',
'password': module.params['default_password']
})
admin_userid = get_userid_by_name(username='******', zapi=zapi)
change_password(userid=get_userid_by_name('Admin', zapi),
new_passwd=module.params['login_password'],
zapi=zapi)
changed = True
sleep(0.1)
zapi.user.logout()
except ZabbixAPIException as e:
pass
try:
zapi = ZabbixAPI(
**{
'url': module.params['url'],
'user': '******',
'password': module.params['login_password']
})
users_list = [
i["alias"] for i in zapi.do_request("user.get")["result"]
]
for user in module.params['users']:
if user["name"] not in users_list:
if not create_user(username=user['name'],
password=user['password'],
user_type=user['type'],
groups=user["groups"],
zapi=zapi):
return module.fail_json(msg=e.message, json=e.json)
else:
changed = True
users_list = [
i["alias"]
for i in zapi.do_request("user.get")["result"]
]
continue
if not is_credentials_valid(
**{
'url': module.params['url'],
'user': user['name'],
'password': user['password']
}):
changed = True
change_password(userid=get_userid_by_name(user['name'], zapi),
new_passwd=user['password'],
zapi=zapi)
sleep(0.1)
if not update_user(username=user['name'],
password=user['password'],
user_type=user['type'],
groups=user["groups"],
zapi=zapi):
return module.fail_json(msg=e.message, json=e.json)
sleep(0.1)
zapi.user.logout()
except ZabbixAPIException as e:
return module.fail_json(msg=e.message, json=e.json)
result = {"changed": changed}
module.exit_json(**result)
try:
zapi = ZabbixAPI(url=url, user=username, password=password)
print ('Auth Ok!')
except Exception as err:
print('Erro ao conectar ao Zabbix')
print('Erro: {}'.format(err))
hostname = 'CL-MATEUS-MAIOBAO-14.162'
gethost = zapi.do_request('host.get',
{
"filter": {
"host": [
hostname
]
}
}
)
'''
request = zapi.do_request('problem.get',
{
"output": "extend",
#"selectAcknowledges": "extend",
"selectTags": "extend",
"selectSuppressionData": "extend",
"hostids": gethost['result'][0]["hostid"],
"recent": "false",
try:
newincno = newinc["records"][0]["number"]
except:
print ("unable to retrieve new incident number\n")
#f.write("unable to retrieve new incident number\n")
zapi =
ZabbixAPI(url='http://'+zabbixsrv+'/zabbix',user=zabbixun,password=zabbixpw)
#zapi.user.login()
#f.write('Acknowledging event '+eventid+'\n')
#zapi.Event.acknowledge({'eventids':[eventid],'message':newincno})
# Get all monitored hosts
result1 = zapi.host.get(monitored_hosts=1, output='extend')
# Get all disabled hosts
result2 = zapi.do_request('host.get',
{
'filter': {'status': 1},
'output': 'extend'
})
# Filter results
hostnames1 = [host['host'] for host in result1]
hostnames2 = [host['host'] for host in result2['result']]
# Logout from Zabbix
zapi.user.logout()
#f.write('\n\nScript End :: '+datetime.datetime.now().ctime()+'\n\n')
#f.close()
import json
zabbix = {}
with open(f'conf.json', 'r') as confs:
zabbix = json.loads(confs.read())
try:
zapi = ZabbixAPI(url=zabbix['url'],
user=zabbix['username'],
password=zabbix['password'])
print('Auth Ok!')
except Exception as err:
print('Erro ao conectar ao Zabbix')
print('Erro: {}'.format(err))
getHostGroup = zapi.do_request(
'item.get', {
"filter": {
"state": 1
},
"output": ["hostid", "name", "itemid"],
"monitored": True
})
i = 0
for item in getHostGroup["result"]:
i += 1
print(f"Item {i} --> {item}")
for x in getHostGroup["result"]:
zapi.do_request('item.update', {"itemid": x['itemid'], "status": 1})
import os
from pyzabbix.api import ZabbixAPI
# Create ZabbixAPI class instance
pasted_URL = 'http://' + str(os.environ["MASTER_IP_PUBLIC"]) + '/zabbix/'
zapi = ZabbixAPI(url=str(pasted_URL), user='******', password='******')
# Create new hostgroup
result1 = zapi.do_request('hostgroup.create',
{'name': 'Unicore compute nodes'})
# Get id of newly created hostgroup
parsed_group_id_unicore = result1['result']['groupids'][0]
# Get dictionary of discovered hostgroup
result_discovered_host_groups = zapi.do_request(
'hostgroup.get', {'filter': {
'name': ['Discovered hosts']
}})
# Get id of discovered hostgroup
parsed_group_id_discovered = result_discovered_host_groups['result'][0][
'groupid']
# Get templateid of Linux Template
result2 = zapi.do_request('template.get',
{'filter': {
'host': ['Template OS Linux']
}})
parsed_template_id = result2['result'][0]['templateid']
class GeneralZabbix:
def __init__(self, sHostName, sZabbixIP, iZabbixPort, sZabUser, sZabPwd):
"""
sHostName is a name of host or array (HOST.HOST) IN ZABBIX
*Zab* are parameters for Zabbix connection.
"""
# oLog.debug("Entered GeneralZabbix.__init__")
self.sZabbixURL = 'http://' + sZabbixIP + "/zabbix"
self.sZabbixIP = sZabbixIP
self.iZabbixPort = iZabbixPort
self.dApplicationNamesToIds = {}
self.sHostName = sHostName
self.ldApplications = []
self.dItemNames = {}
self.dAppIds = {}
self.dApps = {}
# self.sArrayName = sHostName
self.sHostID = ''
self.iHostID = 0
try:
self.oZapi = ZabbixAPI(url=self.sZabbixURL, user=sZabUser, password=sZabPwd)
self.oAPI = self.oZapi
self.oZSend = ZabbixSender(zabbix_server=self.sZabbixIP, zabbix_port=self.iZabbixPort)
lsHosts = self.oZapi.host.get(filter={"host": sHostName})
if len(lsHosts) > 0:
# Just use the first host
self.sHostID = str(lsHosts[0]['hostid'])
self.iHostID = int(self.sHostID)
oLog.debug("host ID of host {1}: {0}".format(self.sHostID, self.sHostName))
else:
oLog.error("Invalid or non-existent host in Zabbix")
raise ZabInterfaceException("This host '{}' isn't known to Zabbix".format(sHostName))
except ZabbixAPIException as e:
oLog.error("Cannot connect to Zabbix API")
oLog.error(str(e))
raise ZabInterfaceException
return
def __fillApplications__(self, reFilter=None):
# receive the list of applications
ldApplications = self.oZapi.do_request('application.get', {'hostids': self.sHostID})
ldAppResult = ldApplications['result']
dBuf = {}
if len(ldAppResult) == 0:
# the host exists but didn't return anything, just continue
oLog.info("Array with ID {0} and name {1} doesn't answer".format(self.sHostID, self.sHostName))
else:
# oLog.debug("Applications on host {0}: {1}".format(self.sArrayName, ldAppResult))
# now filter the apps list for this host
for dApp in ldAppResult:
sAppName = dApp['name']
if reFilter:
if reFilter.match(sAppName):
dBuf[sAppName] = dApp['applicationid']
# oLog.debug('__fillApplications__: found app {}'.format(sAppName))
else:
# oLog.debug("__fillApplications__: skipped app {}".format(sAppName))
pass
else:
dBuf[sAppName] = dApp['applicationid']
self.dApplicationNamesToIds = dBuf
return
def _oPrepareZabMetric(self, sAppName, sParameter, iValue):
"""Prepare ZabbixMetric instance for sending to a Zabbix server"""
dFilter = {'name': sAppName + ' ' + sParameter}
try:
iAppID = self.dApplicationNamesToIds[sAppName]
dItem2Get = {'hostids': self.sHostID,
'applicationids': iAppID,
'filter': dFilter,
'sort': 'name'}
dResult = self.oZapi.do_request('item.get', dItem2Get)
try:
sKey = dResult['result'][0]['key_']
# now we have key, so we can prepare data to Zabbix
oRet = ZabbixMetric(host=self.sHostName, key=sKey, value=iValue)
except IndexError:
oLog.info("Can't receive item named '{}' from Zabbix with item.get".format(dFilter['name']))
oRet = None
except KeyError:
oLog.info('Unknown application name "{}"'.format(sAppName))
# oLog.info('Known apps: ' + str(self.dApplicationNamesToIds))
oRet = None
return oRet
def _SendMetrics(self, loMetrics):
"""Send only non-empty metrics to Zabbix"""
if loMetrics:
# skip empty objects from loMetrics
loMetrics = [o for o in loMetrics if o is not None]
self.oZSend.send(loMetrics)
else:
pass # dont send empty metrics
return
def _iGetHostID(self):
return int(self.sHostID)
def _sName(self):
return self.sHostName
def _bHasApplication(self, sAppName):
sAppName = sAppName.lower()
ldApplications = self.oZapi.do_request('application.get', {'hostids': self.sHostID})
for dApp in ldApplications['result']:
sNewName = dApp['name'].lower()
sNewID = dApp['applicationid']
self.dAppIds[sNewName] = dApp['applicationid']
self.dApps[sNewID] = ZabbixApplication(sNewName, self, dApp)
bRet = (sAppName in self.dAppIds)
return bRet
def _bHasItem(self, sItemName):
bRet = False
sItemName = sItemName.lower()
if sItemName in self.dItemNames:
bRet = True
else:
# try to refresh dItemNames
dGetItem = {'hostids': self.iHostID,
'search': {'name': sItemName}}
dItems = self.oAPI.do_request('item.get', dGetItem)
# oLog.debug('_bHasItem: result of item.get() is {}'.format(str(dItems)))
if len(dItems['result']) > 0:
# matching item(s) found
for dItemDict in dItems['result']:
# dItemDict = dItems['result'][0]
# oLog.debug("Item found: {}".format(str(dItemDict)))
sName = dItemDict['name'].lower()
dItemDict['key'] = dItemDict.get('key_') # from the Zabbix parameter 'key_'
self.dItemNames[sName] = ZabbixItem(sName, self, dItemDict)
bRet = True
else:
# No item found
bRet = False
# oLog.debug('_bHasItem: dItemNames after call is: ' + str(self.dItemNames))
return bRet
def _oGetItem(self, sItemName):
"""returns item object by name"""
sItemName = sItemName.lower()
if self._bHasItem(sItemName):
return self.dItemNames.get(sItemName, None)
else:
return None
def _oGetApp(self, sAppName):
sAppName = sAppName.lower()
if self._bHasApplication(sAppName):
return self.dApps[self.dAppIds[sAppName]]
else:
return None
def _oAddApp(self, sAppName):
# sAppName = sAppName.lower()
if self._bHasApplication(sAppName):
# already have this app
oApp = self._oGetApp(sAppName)
else:
oApp = ZabbixApplication(sAppName, self)
oApp._NewApp(sAppName)
self.dAppIds[sAppName] = oApp._iGetID
self.dApps[oApp._iGetID] = oApp
return oApp
def _oAddItem(self, sItemName, sAppName='', dParams=None):
# sItemName = sItemName.lower()
if self._bHasItem(sItemName):
# already have that item
oItem = self._oGetItem(sItemName)
oLog.debug('Already have that item, returned {}'.format(str(oItem)))
else:
# need to create item
oItem = ZabbixItem(sItemName, self, dParams)
self.dItemNames[sItemName] = oItem
if sAppName != '':
oApp = self._oGetApp(sAppName)
oItem._LinkWithApp(oApp)
oItem._NewZbxItem()
oLog.debug('Created a new item, returned {}'.format(str(oItem)))
return oItem
def _MakeTimeStamp(self):
"""make an application and item (if there are no), send current timestamp as a TS of last update"""
sTSAppName = 'Timestamps'
sItemName = 'Last updated'
if not self._bHasApplication(sTSAppName):
self._oAddApp(sTSAppName)
if self._bHasItem(sItemName):
oTimeStamp_Item = self._oGetItem(sItemName)
oLog.debug('Timestamp item: ' + str(oTimeStamp_Item))
else:
oTimeStamp_Item = self._oAddItem(
sItemName, sAppName=sTSAppName,
dParams={'key': "Update_Time", 'value_type': 3, 'units': 'unixtime',
'description': 'Date and time of last data update'})
# now the application and item must exist
oTimeStamp_Item._SendValue(int(time.time()), self.oZSend)
oLog.debug('TimeStamp set!')
return
def _SendInfoToZabbix(self, sArrayName, ldInfo):
"""send data to Zabbix via API"""
loMetrics = []
# oLog.debug('sendInfoToZabbix: data to send: {}'.format(str(ldInfo)))
for dInfo in ldInfo:
if self.sAppClass == 'System': # Special case
sAppName = self.sAppClass
else:
sAppName = (self.sAppClass + ' ' + dInfo['name']).strip()
for sName, oValue in dInfo.items():
try:
loMetrics.append(self.dOperations[sName](sAppName, oValue))
except KeyError:
# unknown names passed
oLog.info('Skipped unknown information item named {} with value {}'.format(
sName, str(oValue)))
pass
self._SendMetrics(loMetrics)
return
import os
from pyzabbix.api import ZabbixAPI
# Create ZabbixAPI class instance
pasted_URL = 'http://' + str(os.environ["MASTER_IP_PUBLIC"]) + '/zabbix/'
zapi = ZabbixAPI(url=str(pasted_URL), user='******', password='******')
# Create new hostgroup
result1 = zapi.do_request('hostgroup.create',
{'name': 'Unicore compute nodes'})
# Get id of newly created hostgroup
parsed_group_id_unicore = result1['result']['groupids'][0]
# Get dictionary of discovered hostgroup
result_discovered_host_groups = zapi.do_request(
'hostgroup.get', {'filter': {
'name': ['Discovered hosts']
}})
# Get id of discovered hostgroup
parsed_group_id_discovered = result_discovered_host_groups['result'][0][
'groupid']
# Get templateid of Linux Template
result2 = zapi.do_request('template.get',
{'filter': {
'host': ['Template OS Linux']
}})
parsed_template_id = result2['result'][0]['templateid']
class ZapiHelper(object):
def __init__(self, zbx_api_config):
self.zapi_url = zbx_api_config.get('zapi_url', 'zapi_url')
self.zapi_user = zbx_api_config.get('user', 'user')
self.zapi_password = zbx_api_config.get('password', 'password')
self.supported_api_major_versions = ['3.4']
self.output_formats = ['refer', 'shorten', 'extend']
self.import_export_formats = ['xml', 'json']
self.__init_api()
def __validate_api_versions(self, api_v):
"""check supported api versions"""
if api_v[0:3] not in self.supported_api_major_versions:
msg = 'Unsupported api version {0}.' \
'Supported versions are: {1}' \
.format(api_v[0:3], self.supported_api_major_versions)
raise RuntimeError(msg)
def __validate_output_format(self, out_format):
"""check supported output format"""
if out_format not in self.output_formats:
msg = 'Unsupported output format {0}.' \
'Supported formats are: {1}' \
.format(out_format, self.output_formas)
raise RuntimeError(msg)
def __valide_export_format(self, export_format):
"""check supported export format"""
if export_format not in self.import_export_formats:
msg = 'Unsupported export format {0}.' \
'Supported formats are: {1}' \
.format(export_format, self.import_export_formats)
raise RuntimeError(msg)
def __valide_import_format(self, import_format):
"""check supported import format"""
if import_format not in self.import_export_formats:
msg = 'Unsupported import format {0}.' \
'Supported formats are: {1}' \
.format(import_format, self.import_export_formats)
raise RuntimeError(msg)
def __init_api(self):
self.zapi = ZabbixAPI(self.zapi_url,
user=self.zapi_user,
password=self.zapi_password)
self.zapi_version = self.__validate_api_versions(
self.zapi.do_request('apiinfo.version')['result'])
def get_hosts(self, hosts=[], output='extend'):
""" get hosts from zabbix api
if hosts=[] return all hosts
"""
self.__validate_output_format(output)
hosts = self.zapi.host.get(filter={'host': hosts}, output=output)
return hosts
def get_templates(self, templates=[], output='extend'):
""" get templates from zabbix api
if templates=[] return all templates
"""
self.__validate_output_format(output)
templates = self.zapi.template.get(filter={'host': templates},
output=output)
res = {i['name']: i['templateid'] for i in templates}
return res
def api_export(self, export_obj, obj_id, export_format):
""" export objects from api
"""
self.__valide_export_format(export_format)
res = self.zapi.configuration.export(options={export_obj: [obj_id]},
format=export_format)
return res
def api_import(self, import_format, import_rules, import_source):
""" import objects to zabbix
"""
self.__valide_import_format(import_format)
args = {
'rules': import_rules,
'format': import_format,
'source': import_source
}
res = self.zapi.do_request('configuration.import', args)
return res
zapi = ZabbixAPI(url=zabbix['url'], user=zabbix['username'], password=zabbix['password'])
print ('Auth Ok!')
except Exception as err:
print('Erro ao conectar ao Zabbix')
print('Erro: {}'.format(err))
hostgroup = 'SICI'
getHostGroup = zapi.do_request('hostgroup.get',
{
"output": "extend",
"filter": {
"name": [
hostgroup
],
"sortfield": ["name"],
"sortorder": "DESC"
}
}
)
getHost = zapi.do_request('host.get',
{
"output": "extend",
"selectGroups": "extend",
"groupids": getHostGroup['result'][0]["groupid"]
}
)
zapi = ZabbixAPI(url=zabbix['url'], user=zabbix['username'], password=zabbix['password'])
print ('Auth Ok!')
except Exception as err:
print('Erro ao conectar ao Zabbix')
print('Erro: {}'.format(err))
hostgroup = 'SICI'
getHostGroup = zapi.do_request('hostgroup.get',
{
"output": "extend",
"filter": {
"name": [
hostgroup
],
"sortfield": ["name"],
"sortorder": "DESC"
}
}
)
print(getHostGroup)
#apiVersion = zapi.do_request('apiinfo.version')
request = zapi.do_request('event.get',
{
"output": "extend",
"select_acknowledges": "extend",
# graph settings of screen row
screen_row_settings = [{"graph": {"width": 450, "height": 100}},
{"graph": {"width": 450, "height": 100}},
{"graph": {"width": 500, "height": 100}}
]
# check settings and exit
if(col_number>len(screen_row_settings)):
print("Your col_number value is: {}\nYour screen_row_settings length is: {}\n".format(col_number,len(screen_row_settings)))
print("Increase number of lines in screen_row_settings list or decrease col_number value.")
exit(1)
# init zabbix api connection
zapi = ZabbixAPI(url=server, user=zbx_user, password=zbx_pass)
# create host search params
params = {'filter': {'name': host_name}, 'output': 'extend'}
# searching for host
res = zapi.do_request('host.get',params)
# get host id
hostid = res['result'][0]['hostid']
# create zabbix graphs search params
params = {}
# set hostid
params['hostids'] = hostid
# set param for extended output
params['output'] = 'extend'
# set graph name search criteria
params['search'] = {'name': 'CAM STATS'}
# searching for graphs
res = zapi.do_request('graph.get',params)
# close zabbix server session
zapi.user.logout()
# create empty list of graph names