def main(zabbix, user, password, host):
zapi = ZabbixAPI(url=zabbix,
user=user, password=password)
host_id = zapi.get_id(item_type='host', item=host)
if host_id is None:
create_zabbix_host(zapi=zapi, host=host)
else:
update_zabbix_host(zapi=zapi, host=host, host_id=host_id)
def main(zabbix, user, password, host):
zapi = ZabbixAPI(url=zabbix, user=user, password=password)
host_id = zapi.get_id(item_type='host', item=host)
if host_id is None:
create_zabbix_host(zapi=zapi, host=host)
else:
update_zabbix_host(zapi=zapi, host=host, host_id=host_id)
# Read CSV file
hostFile = open(fileName)
hostReader = csv.reader(hostFile, delimiter=';', quotechar='|')
# Uncomment if your csv has headers
#headers = hostReader.next()
hostData = list(hostReader)
# CSV Parsing
for host in hostData:
wantedGroups = []
actualGroupIds = []
hostName = host[1].split("-")[0]
moveHost = False
# Get Zabbixhost informations
hostId = zapi.get_id('host', item=hostName, with_id=False, hostid=None)
hostObj = zapi.host.get(hostids=hostId, selectGroups='extend')
if hostId:
# Create a comparison array of hostgroups id
for hg in hostObj[0]['groups']:
actualGroupIds.append(hg['groupid'])
print "Working on ", hostName, " [id ", hostId, "]"
for hostgroupName in host[0].split("-"):
hostGroupId = zapi.get_id('hostgroup',
item=hostgroupName,
with_id=False,
hostid=None)
wantedGroups.append({'groupid': hostGroupId})
class ZabbixCLI(ZabbixCLIArguments):
def __init__(self, template=None):
ZabbixCLIArguments.__init__(self)
self._configureLogging()
log.debug('Parser arguments: %s', self.args)
# if no arguments, jsut print help
if len(sys.argv) <= 1:
self.argparser.print_help()
sys.exit()
if not self.args.get('template'):
sys.exit('Template should be specified.')
self.url = self.args['server']
try:
self.zapi = ZabbixAPI(
self.url,
user=self.args['user'],
password=self.args['pass'])
except:
log.error('Error while trying open connection to zabbix server: %s',
self.url)
# If we need to delete an object and exit
if self.args.get('delete'):
template_id = self.zapi.get_id('template', self.args['delete'][1])
if ZabbixObject(self.zapi,
{'name': self.args['delete'][2]},
template_id=template_id,
obj_type=self.args['delete'][0]).delete():
log.info(
'"{2}" {0} was deleted from "{1}"'.format(
*self.args['delete']))
else:
log.exit(
'Error while trying to delete: "{2}" {0} from "{1}"'.format(
*self.args['delete']))
exit()
# Set template name from __init__ params or args
if template:
self.template_name = template
else:
self.template_name = self.args.get('template')
# Load template from file
self.template = ZabbixTemplateFile(self.template_name, templates_dir=self.args.get('templates_dir'))
self.template_id = None
# When template loaded, set defaults and run apply process
if self.template:
self.config = ZabbixDefaults()
self.apply()
def _configureLogging(self):
"""
Configure logging output. Format and colors.
"""
# Set logging level
if self.args.get('debug'):
logLevel = logging.DEBUG
else:
logLevel = logging.INFO
# Set colored output
colors = {'reset': '\033[0m', 'green': '\x1b[32m', 'cyan': '\x1b[36m'}
logFormat = '{reset}{cyan}[{green}%(asctime)s{cyan}]{reset} %(message)s'.format(
**colors)
logging.basicConfig(
level=logLevel,
format=logFormat,
datefmt='%d/%m/%Y %H:%M:%S')
def _apply_linked_templates(self):
"""
Recursive apply list of linked templates. They will applied before main
template will start applying.
"""
if self.template.get('templates') and not self.args.get('only', False):
log.info('%s depends from:', self.template.get('name'))
# Show linked template list before applying
for linked_template in self.template.get('templates', []):
log.info("\t\t%s", linked_template)
# Apply list of linked templates
for linked_template in self.template.get('templates', []):
ZabbixCLI(template=linked_template)
def _apply_template(self, template):
return ZabbixTemplate(self.zapi, template).apply()
def _apply_macro(self, macro):
ZabbixMacro(self.zapi, macro, self.template_id).apply()
def _apply_macros(self):
for macro in self.template.get('macros', []):
self._apply_macro(macro)
def _apply_app(self, app):
return ZabbixApp(self.zapi, app, self.template_id).apply()
def _apply_item(self, item):
ZabbixItem(self.zapi, item, self.config, self.template_id).apply()
def _apply_items(self, items, app_id):
for item in items:
item['app_id'] = app_id
self._apply_item(item)
def _apply_item_prototype(self, prototype):
ZabbixItemPrototype(self.zapi, prototype, self.config, self.template_id).apply()
def _apply_item_prototypes(self, discovery, app_id):
items = discovery.get('items', [])
rule_id = self.zapi.get_id(
'discoveryrule',
discovery['name'],
templateid=self.template_id)
for item in items:
item.update({'rule_id': rule_id, 'app_id': app_id})
self._apply_item_prototype(item)
def _apply_graph(self, graph):
ZabbixGraph(self.zapi, graph, self.config, self.template_id).apply()
def _apply_graphs(self):
for graph in self.template.get('graphs', []):
self._apply_graph(graph)
def _apply_graph_prototype(self, prototype):
ZabbixGraphPrototype(self.zapi, prototype, self.config, self.template_id).apply()
def _apply_graph_prototypes(self, discovery):
graphs = discovery.get('graphs', [])
for graph in graphs:
self._apply_graph_prototype(graph)
def _apply_trigger(self, trigger):
ZabbixTrigger(self.zapi, trigger, self.config, self.template_id).apply()
def _apply_triggers(self):
for trigger in self.template.get('triggers', []):
self._apply_trigger(trigger)
def _apply_trigger_prototype(self, prototype):
ZabbixTriggerPrototype(self.zapi, prototype, self.config, self.template_id).apply()
def _apply_trigger_prototypes(self, discovery):
triggers = discovery.get('triggers', [])
for triggers in triggers:
self._apply_trigger_prototype(triggers)
def _apply_autoreg(self):
autoreg = self.template.get('autoreg')
if autoreg:
ZabbixAutoreg(self.zapi, self.template).apply()
def _apply_trigger_action(self):
alerts = self.template.get('alerts', [])
for alert in alerts:
ZabbixTriggerAction(self.zapi, alert, self.config, self.template_id, self.template_name).apply()
def _apply_discovery(self, discovery):
ZabbixDiscovery(self.zapi, discovery, self.config, self.template_id).apply()
def _apply_discoveries(self):
discoveries = self.template.get('discovery', {})
for app, discovery in discoveries.iteritems():
app_id = self._apply_app(app)
self._apply_discovery(discovery)
self._apply_item_prototypes(discovery, app_id)
self._apply_graph_prototypes(discovery)
self._apply_trigger_prototypes(discovery)
def _disable_item(self, id_):
ZabbixItem(self.zapi).disable(id_)
def _disable_app(self, app):
items = self.zapi.get_id(
'item',
None,
hostid=self.template_id,
app_name=app)
for item in items:
self._disable_item(item)
def clean(self):
"""
Find and clean unused zabbix objects in current template.
"""
def getUnusedObjects(type_, o):
"""
Return list of unused zabbix objects of specific type in current template
"""
unused_items = []
# Get current objects from current template
current_items = self.zapi.get_id(type_, templateids=self.template_id, name=True)
if current_items:
log.debug("Current %s: %s", type_, current_items)
template_items = []
for item in o:
if isinstance(item, dict):
template_items.append(item.get('name'))
else:
template_items.append(item)
log.debug("Template %s: %s", type_, template_items)
# Filter out similar objects from zabbix and template
unused_items = filter(lambda x: x not in template_items, current_items)
log.debug("Unused %s: %s", type_, unused_items)
return { type_: unused_items }
def removeObjects(template_objects):
"""
Remove unused zabbix objects in current template.
"""
# Find unused objects
for objects in template_objects:
unused_objects = getUnusedObjects(*objects)
# Process each object type
for type_, objects_list in unused_objects.iteritems():
# Get zabbix id for each unused object
for name in objects_list:
object_id = self.zapi.get_id(type_, name)
if object_id:
# Make function to remove object
func = 'self.zapi.{object_type}.delete'.format(object_type=type_)
log.info('Unused: %s \'%s\' was removed', type_, name)
eval(func)(object_id)
# Init lists for objects
items = apps = discovery = itemprototype = graphprototype = triggerprototype = []
for app, item in self.template.get('applications', {}).iteritems():
apps.append(app)
items.extend(item)
for app, disc in self.template.get('discovery', {}).iteritems():
apps.append(app)
discovery.append(disc)
itemprototype.extend(disc.get('items', {}))
graphprototype.extend(disc.get('graphs',{}))
triggerprototype.extend(disc.get('triggers', {}))
# Cleanup should be executed in folowing order
obj_for_cleanup = collections.OrderedDict()
obj_for_cleanup['application'] = apps
obj_for_cleanup['item'] = items
obj_for_cleanup['usermacro'] = map(lambda x: {'name':x.get('macro')}, self.template.get('macros', []))
obj_for_cleanup['graph'] = self.template.get('graphs', [])
obj_for_cleanup['trigger'] = self.template.get('triggers', [])
obj_for_cleanup['discoveryrule'] = discovery
obj_for_cleanup['itemprototype'] = itemprototype
obj_for_cleanup['graphprototype'] = graphprototype
obj_for_cleanup['triggerprototype'] = triggerprototype
# Make tuple (obj_type, value) to compare with
template_objects = []
for k,v in obj_for_cleanup.iteritems():
template_objects.append((k,v))
# Remove unused objects
removeObjects(template_objects)
def apply(self):
"""
Apply current template to zabbix.
"""
self._apply_linked_templates()
self.template_id = self._apply_template(self.template)
# Cleanup unused objects
self.clean()
apps = self.template.get('applications', {})
for app, items in apps.iteritems():
# check if disabled whole app
if str(items).lower() == 'disabled':
self._disable_app(app)
else:
app_id = self._apply_app(app)
self._apply_items(items, app_id)
self._apply_macros()
self._apply_graphs()
self._apply_triggers()
self._apply_discoveries()
self._apply_autoreg()
self._apply_trigger_action()
log.info("Done: '%s'", self.template.get('name'))
# all other stdin lines contains a trap itself
trapstr = inp.read().rstrip()
logging.debug("hostname is: %s", hostname)
logging.debug("IP address is: %s", ip)
logging.debug("trap info is: %s", trapstr)
logging.debug("api_config: %s, %s, %si", api_config['zabbix_url'],
api_config['zabbix_user'], api_config['zabbix_passwd'])
# using ZabbixAPI check if a hostname and a corresponding item exists
z = ZabbixAPI(api_config['zabbix_url'],
user=api_config['zabbix_user'],
password=api_config['zabbix_passwd'])
hostid = z.get_id("host", item=hostname)
if not hostid:
# device's hostname may not match to the one in zabbix
# in this case try to find out a hostname by the device's ipaddress
res = z.hostinterface.get(search={'ip': ip},
output=['hostid', 'interfaceid'])
if not res:
logging.error("there is no hostname %s in Zabbix. Discarding trap...",
hostname)
exit(1)
hostid = res[0]['hostid']
res = z.host.get(hostids=hostid, output=['hostid', 'name'])
if not res:
logging.error("there is no hostname %s in Zabbix. Discarding trap...",
def main():
parser = ArgumentParser()
parser.add_argument("-z", "--zabbix", help="Zabbox URL", required=True)
parser.add_argument("-u", "--user", help="Zabbix user name", required=True)
parser.add_argument("-p",
"--password",
help="Zabbix user password",
required=True)
parser.add_argument("-D",
"--dir",
help="Directory where charts will be saved",
required=True)
parser.add_argument("-s",
"--start_time",
help="Chart data start time",
required=True)
parser.add_argument("-d",
"--duration",
help="Chart data duration",
required=True)
parser.add_argument("-H", "--host", help="Host name", required=True)
args = parser.parse_args()
zabbix = args.zabbix
user = args.user
password = args.password
host = args.host
start_time = args.start_time
duration = int(args.duration)
chart_dir = args.dir
if duration < 60:
duration = 60
zapi = ZabbixAPI(url=zabbix, user=user, password=password)
host_id = zapi.get_id(item_type='host', item=host)
zapi = ZabbixAPI(url=zabbix, user=user, password=password)
graphs = zapi.do_request(method="graph.get", params={"hostids":
host_id})['result']
graph_ids = {}
for graph in graphs:
if graph['name'] in GRAPH_NAMES:
graph_ids[graph['graphid']] = graph['name']
s = requests.Session()
payload = {
'name': user,
'password': password,
'enter': 'Sign in',
'autologin': '******',
'request': ''
}
url = "{0}/index.php?login=1".format(zabbix)
s.post(url, data=payload)
for graph_id, graph_name in graph_ids.iteritems():
url = ("{0}/chart2.php?"
"graphid={1}&stime={2}&period={3}".format(
zabbix, graph_id, start_time, duration))
response = s.get(url, stream=True)
file_name = "{0}/{1}-{2}.png".format(chart_dir, host,
graph_name.replace(" ", "_"))
with open(file_name, 'wb') as f:
shutil.copyfileobj(response.raw, f)
#!/usr/bin/env python
import sys
from zabbix.api import ZabbixAPI
if len(sys.argv) > 1:
hostname = sys.argv[1]
z = ZabbixAPI(
url='https://zabbix.local',
user='******',
password='******')
# Get zabbix host id
hostId = z.get_id('host', hostname)
# Remove host by id
result = z.do_request('host.delete', [hostId]).get('result', {}).get('hostids',[None])[0]
# Output
if result:
print '{hostname} removed from zabbix.'.format(hostname=hostname)
else:
sys.exit(1)
def main(argv):
print('-- Host Bulk Insert --')
# Parse arguments and build work variables
args = ArgumentParser()
zabbixURL = args.Z
zabbixUsername = args.u
zabbixPassword = args.p
csvFile = args.f
hostGroupNames = []
templateNames = []
proxyNames = []
hostGroupId = {}
templateId = {}
proxyId = {}
# Static values from zabbix api
interfaceType = {'agent': 1, 'SNMP': 2, 'IMPI': 3, 'JMX': 4}
print('Reading CSV file: {}'.format(csvFile))
hostData = parseCSV(csvFile, ';')
# jsonPrint(hostData)
# API Connect
print('Connecting to {}'.format(zabbixURL))
zapi = ZabbixAPI(url=zabbixURL,
user=zabbixUsername,
password=zabbixPassword)
print('Parsing templates, proxy and hostgroups')
# Read all host groups and templates
for host in hostData:
for hostgroupName in host['Groups'].split(","):
hostGroupNames.append(hostgroupName)
for templateName in host['Templates'].split(","):
if templateName != 'DO_NOT_ADD':
templateNames.append(templateName)
if len(host['Proxy']) > 0:
proxyNames.append(host['Proxy'])
print('Templates: {}'.format(set(templateNames)))
print('Hostgroups: {}'.format(set(hostGroupNames)))
print('Proxyes: {}'.format(set(proxyNames)))
# Foreach UNIQUE hostgroup, create if missing
for hostgroupName in set(hostGroupNames):
if (zapi.get_id('hostgroup',
item=hostgroupName,
with_id=False,
hostid=None) == None):
print('Creating missing hostgroup: {}'.format(hostgroupName))
zapi.hostgroup.create(name=hostgroupName)
# Create associative array Name=>Id
hostGroupId[hostgroupName] = zapi.get_id('hostgroup',
item=hostgroupName,
with_id=False,
hostid=None)
# Foreach UNIQUE template
for templateName in set(templateNames):
# TODO : what if template does not exist ?
# Create associative array Name=>Id
templateId[templateName] = zapi.get_id('template',
item=templateName,
with_id=False,
hostid=None)
# Foreach UNIQUE proxy
for proxyName in set(proxyNames):
# TODO : what if proxy does not exist ?
# Create associative array Name=>Id
f = {'host': proxyName}
proxyObj = zapi.proxy.get(filter=f)
proxyId[proxyName] = proxyObj[0]['proxyid']
# Create objects and add hosts
for host in hostData:
h_groups = []
h_templates = []
h_name = host['Hostname']
h_desc = host['Description']
h_ip = host['IP Address']
h_dns = host['DNSName']
h_interfaces = []
h_proxy = host['Proxy']
h_tags = []
h_macros = []
if (host['Interfaces'] == 'DO_NOT_ADD'):
print('Skipping host: {}'.format(h_name))
continue
if len(host['DNSName']) > 0:
h_useip = 0
else:
h_useip = 1
# Check and skip existing hosts
if args.s:
f = {'host': h_name}
hosts = zapi.host.get(filter=f,
output='extend',
selectTags='extend')
if hosts:
print('Host {} already exists!! Skpping'.format(h_name))
continue
print('Working on: {}'.format(h_name))
# Build Tags object
if len(host['Tags']) > 0:
for tagString in host['Tags'].split(","):
[tagName, tagValue] = tagString.split("=")
h_tags.append({'tag': tagName, 'value': tagValue})
# jsonPrint(h_tags)
# Build Macro object
if len(host['Macros']) > 0:
for macroString in host['Macros'].split(","):
[macroName, macroValue] = macroString.split("=")
h_macros.append({'macro': macroName, 'value': macroValue})
# jsonPrint(h_macros)
# Build interface object
for interface in host['Interfaces'].split(","):
if (interfaceType[interface] == 1):
port = 10050
else:
port = 161
h_interfaces.append({
'type': interfaceType[interface],
'main': 1,
'useip': h_useip,
'ip': h_ip,
'dns': h_dns,
'port': port
})
# Build hostgroup object
for hostgroup in host['Groups'].split(","):
h_groups.append({
'groupid': hostGroupId[hostgroup],
})
# Build template object
for template in host['Templates'].split(","):
h_templates.append({
'templateid': templateId[template],
})
if len(h_proxy) > 0:
zapi_result = zapi.host.create(host=h_name,
tags=h_tags,
description=h_desc,
interfaces=h_interfaces,
groups=h_groups,
templates=h_templates,
proxy_hostid=proxyId[h_proxy],
macros=h_macros)
else:
zapi_result = zapi.host.create(host=h_name,
tags=h_tags,
description=h_desc,
interfaces=h_interfaces,
groups=h_groups,
templates=h_templates,
macros=h_macros)
jsonPrint(zapi_result)
def main():
parser = ArgumentParser()
parser.add_argument("-z", "--zabbix",
help="Zabbox URL",
required=True)
parser.add_argument("-u", "--user",
help="Zabbix user name",
required=True)
parser.add_argument("-p", "--password",
help="Zabbix user password",
required=True)
parser.add_argument("-D", "--dir",
help="Directory where charts will be saved",
required=True)
parser.add_argument("-s", "--start_time",
help="Chart data start time",
required=True)
parser.add_argument("-d", "--duration",
help="Chart data duration",
required=True)
parser.add_argument("-H", "--host",
help="Host name",
required=True)
args = parser.parse_args()
zabbix = args.zabbix
user = args.user
password = args.password
host = args.host
start_time = args.start_time
duration = int(args.duration)
chart_dir = args.dir
if duration < 60:
duration = 60
zapi = ZabbixAPI(url=zabbix,
user=user, password=password)
host_id = zapi.get_id(item_type='host', item=host)
zapi = ZabbixAPI(url=zabbix,
user=user, password=password)
graphs = zapi.do_request(method="graph.get",
params={"hostids": host_id})['result']
graph_ids = {}
for graph in graphs:
if graph['name'] in GRAPH_NAMES:
graph_ids[graph['graphid']] = graph['name']
s = requests.Session()
payload = {'name': user,
'password': password,
'enter': 'Sign in',
'autologin': '******',
'request': ''}
url = "{0}/index.php?login=1".format(zabbix)
s.post(url, data=payload)
for graph_id, graph_name in graph_ids.iteritems():
url = ("{0}/chart2.php?"
"graphid={1}&stime={2}&period={3}".format(zabbix,
graph_id,
start_time,
duration))
response = s.get(url, stream=True)
file_name = "{0}/{1}-{2}.png".format(chart_dir,
host,
graph_name.replace(" ", "_"))
with open(file_name, 'wb') as f:
shutil.copyfileobj(response.raw, f)
