def client(**kwargs):
    global zapi
    if not zapi:
        zapi = ZabbixAPI(kwargs['url'])
        zapi.login(kwargs['username'], kwargs['password'])
        print 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!')
示例#3
0
 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 main(argv):
    logging.basicConfig(
        format='%(asctime)s:%(process)d:[%(levelname)s](%(name)s):%(message)s',
        level=log_level)
    for module in skipmodules:
        logging.getLogger(module).setLevel(logging.ERROR)

    try:
        opts, args = getopt.getopt(argv, "hs:f:",
                                   ["help", "source=", "field="])
    except getopt.GetoptError:
        helpArgs()
        sys.exit()
    for opt, arg in opts:
        if opt in ("-h", "--help"):
            helpArgs()
            sys.exit()
        elif opt in ("-s", "--source"):
            hostname = arg
        elif opt in ("-f", "--field"):
            fieldname = arg

    zapi = ZabbixAPI(ZBXURI)
    zapi.login(ZBXUSER, ZBXPASS)
    logging.info("Connected to Zabbix API %s Version %s" %
                 (ZBXURI, zapi.api_version()))
    zapi.cicle_inventory_value(hostname=hostname, inventory_field=fieldname)
def loadconfig(configfile, checkssl, logging):
    configfile = configfile
    checkssl = checkssl
    logging = logging

    with open(configfile, 'r') as jsonfile:
        data = json.load(jsonfile)
        for jsoninfo in data:
            if 'zbx_url' in jsoninfo:
                zbx_url = jsoninfo['zbx_url']
            if 'zbx_username' in jsoninfo:
                zbx_username = jsoninfo['zbx_username']
            if 'zbx_password' in jsoninfo:
                zbx_password = jsoninfo['zbx_password']

    zapi = ZabbixAPI(zbx_url)

    if checkssl == 'nossl':
        import urllib3
        urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
        zapi.session.verify = False

    if logging == 'log':
        import sys
        import logging
        stream = logging.StreamHandler(sys.stdout)
        stream.setLevel(logging.DEBUG)
        log = logging.getLogger('pyzabbix')
        log.addHandler(stream)
        log.setLevel(logging.DEBUG)

    zapi.login(zbx_username, zbx_password)
    print("Connected to Zabbix API Version %s" % zapi.api_version())
    return (zapi)
def exporter(args):
    try:
        zapi = ZabbixAPI(server=args.zabbix_host)
        zapi.login(api_token=args.zabbix_api_token)
        print("Connected to Zabbix API Version %s" % zapi.api_version())

    except Exception as e:
        print(
            "Failed to connect with the Zabbix API. Please check your credentials."
        )
        print(str(e))
        exit(1)

    if args.debug is True:
        stream = logging.StreamHandler(sys.stdout)
        stream.setLevel(logging.DEBUG)
        log = logging.getLogger("pyzabbix")
        log.addHandler(stream)
        log.setLevel(logging.DEBUG)

    if args.export_type == "templates":
        export_templates(zapi)
    elif args.export_type == "mediatypes":
        export_mediaTypes(zapi)
    elif args.export_type == "hosts":
        export_hosts(zapi)
    elif args.export_type == "hostgroups":
        export_hosts_groups(zapi)
    elif args.export_type == "maps":
        export_maps(zapi)
    elif args.export_type == "images":
        export_images(zapi)
示例#7
0
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)
class ZabbixGateway(object):
    def __init__(self):
        self.user = settings.ZABBIX['USER']
        self.passwd = settings.ZABBIX['PASSWD']
        self.zabbix = ZabbixAPI(settings.ZABBIX['HOST'])

    def get_version(self):
        return self.zabbix.api_version()

    def get_user(self, userid):
        self.zabbix.login(self.user, self.passwd)
        res = self.zabbix.user.get(userids=str(userid))
        self.zabbix.user.logout()
        if len(res) == 1:
            return res[0]['alias']
        else:
            return None

    def create_user(self, username, raw_password):
        """Create zabbix user.
        zabbix method: user.create
        zabbix doc: https://www.zabbix.com/documentation/3.4/manual/api/reference/user/create
        """
        self.zabbix.login(self.user, self.passwd)
        groups = [
            {'usrgrpid': str(settings.ZABBIX['DEFAULT_GID'])}
        ]
        # TODO catch exceptions
        res = self.zabbix.user.create(alias=username, passwd=raw_password, usrgrps=groups)
        self.zabbix.user.logout()
        return int(res['userids'][0])
示例#9
0
def zabbix_login():
    """ Initiate a Zabbix API session """
    global ZAPI

    ZAPI = ZabbixAPI(ZABBIX_URL)
    LOGGER.info('Zabbix: Logging in into Zabbix API %s as %s', ZABBIX_URL, ZABBIX_USER)
    ZAPI.login(ZABBIX_USER, ZABBIX_PASSWORD)
    LOGGER.info('Connected to Zabbix API Version %s', ZAPI.api_version())
示例#10
0
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 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
示例#12
0
def login_check(cred, password):
    try:
        z = ZabbixAPI(cred['host'], user=cred['user'], password=password)
        result = True
        # return api version
        api = z.api_version()
    except:
        result = False
        api = None
    return result, api
示例#13
0
 def __createConnection(self):
     sendToLogger('debug', 'Connecting to zabbix-server on ' + str(self.zbx_url))
     try:
         zapi = ZabbixAPI(self.zbx_url)
         zapi.login(self.zbx_user, self.zbx_pass)
         sendToLogger('debug', 'Connected to zabbix-server API Version ' + zapi.api_version())
         return zapi
     except:
         sendToLogger('error', 'Connection to zabbix-server on ' + str(self.zbx_url) + ' failed.')
         exit(2)
示例#14
0
    def test_detecting_version(self):
        httpretty.register_uri(
            httpretty.POST,
            "http://example.com/api_jsonrpc.php",
            body=json.dumps({
                "jsonrpc": "2.0",
                "result": "4.0.0",
                "id": 0
            }),
        )

        zapi_detect = ZabbixAPI('http://example.com')
        self.assertEqual(zapi_detect.api_version(), '4.0.0')
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 _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 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'
示例#18
0
    def fetch_data(self, command):
        """
        Récupère des données depuis le serveur à partir des critères de sélection
        spécifiés en paramètre
        
        :param command: critère de sélection et connexion
        """
        super()._load_config()
        command.asserts()

        zapi = ZabbixAPI(server=self.serverUrl, timeout=2.5)
        datas = None

        try:
            zapi.login(command.user, command.password)
            self.logger.info("Try connecting to {}... Zabbix v{}...".format(
                self.serverUrl, zapi.api_version()))
        except (ZabbixAPIException, ReadTimeout, ValueError) as ex:
            self.logger.error("Try connecting to {} : {}".format(
                self.serverUrl, ex))

        # adapte les params en fonction du mode d'utilisation
        apiParams = dict(itemids=command.itemIds,
                         output='extend',
                         sortfield='clock')

        if (command.dateEnd and command.dateStart):
            apiParams["time_from"] = int(command.dateStart.timestamp())
            apiParams["time_till"] = int(command.dateEnd.timestamp())
            apiParams["sortorder"] = "ASC"
            detailHistory = "{} to {}".format(command.dateStart,
                                              command.dateEnd)
        else:
            # en mode limit, il faut inverser le tri pour récupérer les valeurs
            # les plus récentes
            apiParams["limit"] = command.limit
            apiParams["sortorder"] = "DESC"
            detailHistory = "{} last values".format(command.limit)

        try:
            datas = zapi.history.get(**apiParams)
            self.logger.info("Fetching history from {}...{} value(s)".format(
                detailHistory, len(datas)))
        except (ZabbixAPIException, ReadTimeout, ValueError) as ex:
            self.logger.error("Fetching history from {} : {}".format(
                detailHistory, ex))

        return datas
def main():
    logging.basicConfig(
        format='%(asctime)s:%(process)d:[%(levelname)s](%(name)s):%(message)s',
        level=log_level)
    for module in skipmodules:
        logging.getLogger(module).setLevel(logging.ERROR)
    try:
        zapi = ZabbixAPI(ZBXURI)
        zapi.login(ZBXUSER, ZBXPASS)
        logging.info("Connected to Zabbix API %s Version %s" %
                     (ZBXURI, zapi.api_version()))
        for host in zapi.all_hosts():
            zapi.device_items_to_inventory(hostname=host['host'])
    except Exception as e:
        logging.critical(str(e), exc_info=logshowerror)
        pass
示例#20
0
def main(url: str, login: str, passowrd: str, host: str, tg_id: str,
         tg_token: str) -> None:
    zapi = ZabbixAPI(url)
    zapi.login(login, passowrd)
    logging.info(zapi.api_version())

    media_type_id = get_tg_media_type_id(zapi)
    # update_tg_media_type(zapi, tg_token, media_type_id)

    user_id = get_user_id(zapi, login)
    # add_tg_id_to_user_media(zapi, login, tg_id, user_id, media_type_id)
    # FIXME: 'Error -32602: Invalid params., Invalid parameter "/1/user_medias/1/sendto": an array is expected.', -32602)

    host_id, int_id = get_host_and_interface_id(zapi, host)
    for i in range(1, 4):
        create_task_item(zapi, host_id, int_id, i)
        create_task_trigger(zapi, i)
示例#21
0
class ZabbixConnectionModule(object):
    def __init__(self, zabbix_server, zabbix_username, zabbix_password):
        self.zabbix_server = zabbix_server
        self.zabbix_username = zabbix_username
        self.zabbix_password = zabbix_password
        self.zabbix_server = ZabbixAPI(self.zabbix_server)

    def zabbix_api_connect(self):
        try:
            self.zabbix_server.login(self.zabbix_username,
                                     self.zabbix_password)
            logging.info("Connected to Zabbix API Version %s" %
                         self.zabbix_server.api_version())
            return self.zabbix_server
        except ZabbixAPI.ZabbixAPIException:
            logging.exception("Couldn't connect to Zabbix API.")
            sys.exit()
示例#22
0
 def get_dashboard(cfg):
     zapi = ZabbixAPI(url=cfg['url'],
                      user=cfg['api_user'],
                      password=cfg['api_pass'])
     v = zapi.api_version()
     try:
         boards = zapi.dashboard.get(
             output='extend',
             selectWidgets='extend',
             selectUsers='extend',
             selectUserGroups='extend',
         )
     except Exception as inst:
         return "API not supports this feature"
     res = "*Available dashboards:\n*"
     res += "\n".join("{} : {}".format(b['dashboardid'], b['name'])
                      for b in boards)
     return res
示例#23
0
def setup(hass, config):
    """Set up the Zabbix component."""

    conf = config[DOMAIN]
    protocol = "https" if conf[CONF_SSL] else "http"

    url = urljoin(f"{protocol}://{conf[CONF_HOST]}", conf[CONF_PATH])
    username = conf.get(CONF_USERNAME)
    password = conf.get(CONF_PASSWORD)

    zapi = ZabbixAPI(url)
    try:
        zapi.login(username, password)
        _LOGGER.info("Connected to Zabbix API Version %s", zapi.api_version())
    except ZabbixAPIException as login_exception:
        _LOGGER.error("Unable to login to the Zabbix API: %s", login_exception)
        return False

    hass.data[DOMAIN] = zapi
    return True
示例#24
0
def getCredentials(zabAuth, grafAuth):
    """                              
    Parameters: Zabbix Authentication file with two lines,
        <URL>                                            
        <username>                                      
        <password>                                     
    Grafana Authentication file with two lines,       
        <token>                                      
        <URL>                                       
    Returns: ZabbixAPI Object, token, and url      
    """
    zabbixAPI = None
    try:
        inFile = open(zabAuth, "r")
        ZURL = inFile.readline().strip()
        username = inFile.readline().strip()
        password = inFile.readline().strip()
        print(ZURL)
        print(username)
        inFile.close()
    except IOError:
        print("Couldn't open %s..." % zabAuth)
        sys.exit(0)

    zabbixAPI = ZabbixAPI(ZURL)
    zabbixAPI.login(username, password)
    print("Zabbix API version = " + zabbixAPI.api_version())

    try:
        inFile = open(grafAuth, "r")
        token = inFile.readline().strip()
        URL = inFile.readline().strip()
        inFile.close()
    except IOError:
        print("Couldn't open %s..." % grafAuth)
        sys.exit(0)

    return zabbixAPI, token, URL
示例#25
0
def setup(hass, config):
    """Set up the Zabbix component."""

    conf = config[DOMAIN]
    if conf[CONF_SSL]:
        schema = "https"
    else:
        schema = "http"

    url = urljoin("{}://{}".format(schema, conf[CONF_HOST]), conf[CONF_PATH])
    username = conf.get(CONF_USERNAME, None)
    password = conf.get(CONF_PASSWORD, None)

    zapi = ZabbixAPI(url)
    try:
        zapi.login(username, password)
        _LOGGER.info("Connected to Zabbix API Version %s", zapi.api_version())
    except ZabbixAPIException as login_exception:
        _LOGGER.error("Unable to login to the Zabbix API: %s", login_exception)
        return False

    hass.data[DOMAIN] = zapi
    return True
示例#26
0
def setup(hass, config):
    """Set up the Zabbix component."""
    from pyzabbix import ZabbixAPI, ZabbixAPIException

    conf = config[DOMAIN]
    if conf[CONF_SSL]:
        schema = 'https'
    else:
        schema = 'http'

    url = urljoin('{}://{}'.format(schema, conf[CONF_HOST]), conf[CONF_PATH])
    username = conf.get(CONF_USERNAME, None)
    password = conf.get(CONF_PASSWORD, None)

    zapi = ZabbixAPI(url)
    try:
        zapi.login(username, password)
        _LOGGER.info("Connected to Zabbix API Version %s", zapi.api_version())
    except ZabbixAPIException:
        _LOGGER.error("Unable to login to the Zabbix API")
        return False

    hass.data[DOMAIN] = zapi
    return True
示例#27
0
#!/usr/bin/python

import sys
from pyzabbix import ZabbixAPI

#api_key=str(sys.argv[1])

zapi = ZabbixAPI("http://zabbix.ns2online.com.br")
zapi.session.verify = False
zapi.login("monitoracao", "Senha1234")

zapi.timeout = 5.1

print("Conectado %s" % zapi.api_version())

#for h in zapi.host.get(output="extend"):
#    print(h['hostid']
示例#28
0
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_description = config.media_description
        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()
        if config.verbose:
            self.logger.setLevel(logging.DEBUG)
        else:
            self.logger.setLevel(logging.INFO)
        formatter = logging.Formatter(
            '%(asctime)s - %(levelname)s - %(message)s')

        # Log to stdout
        ch = logging.StreamHandler()
        if config.verbose:
            ch.setLevel(logging.DEBUG)

        ch.setFormatter(formatter)
        self.logger.addHandler(ch)  # Use logger to log information

        # Log from pyzabbix
        log = logging.getLogger('pyzabbix')
        log.addHandler(ch)
        if config.verbose:
            log.setLevel(logging.DEBUG)

    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, description):
        """
        Retrieves the mediatypeid by description

        Args:
            description (str): Zabbix media type description

        Returns:
            The mediatypeid for specified media type description

        """
        result = self.conn.mediatype.get(filter={'description': description})

        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,
            'type': 1,
            'usrgrps': [{
                'usrgrpid': str(groupid)
            }],
            'passwd': random_passwd
        }
        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)

            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
                elif 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()

                if self.ldap_media:
                    self.logger.info(
                        '>>> Updating/create user media for "%s", update "%s"'
                        % (eachUser, self.media_description))
                    if self.ldap_conn.get_user_media(ldap_users[eachUser],
                                                     self.ldap_media):
                        sendto = self.ldap_conn.get_user_media(
                            ldap_users[eachUser],
                            self.ldap_media).decode("utf8")
                    else:
                        sendto = self.ldap_conn.get_user_media(
                            ldap_users[eachUser], self.ldap_media)

                    if sendto and not self.dryrun:
                        self.update_media(eachUser, self.media_description,
                                          sendto, media_opt_filtered)
                else:
                    self.logger.info(
                        '>>> Ignoring media for "%s" because of configuration'
                        % (eachUser))

        self.ldap_conn.disconnect()
示例#29
0
import sys, socket, time, re, datetime
from pyzabbix import ZabbixAPI
from difflib import Differ

trigprevlist = []
triglist = []
counter = 0

try:
    zapi = ZabbixAPI(z_url)
    zapi.session.timeout = 5
    zapi.login(z_user, z_pass)
except Exception as e:
    print(e)
    exit(3)
print ("Connected to Zabbix API Version %s" % zapi.api_version())

irc = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #defines the socket
print("Establishing connection to [%s]" % (server))
irc.connect((server, 6667))              #connects to the server
irc.setblocking(False)

sock_auth = "USER "+ botuser +" "+ botuser +" "+ botuser +" :This is the Steinvord bot!\n"
sock_nick = "NICK "+ botnick +"\n"
sock_nicksrv = "PRIVMSG nickserv :iNOOPE\r\n"
sock_join = "JOIN "+ channel +"\n"
irc.send(sock_auth.encode(encoding))
irc.send(sock_nick.encode(encoding))
irc.send(sock_nicksrv.encode(encoding))
irc.send(sock_join.encode(encoding))
示例#30
0
    p.print_help()
    print "NOTE: Zabbix 1.8.0 doesn't check LDAP when authenticating."
    sys.exit(-1)

def errmsg(msg):
    sys.stderr.write(msg + "\n")
    sys.exit(-1)

if  __name__ == "__main__":
    options, args = get_options()

    zapi = ZabbixAPI(server=options.server,log_level=3)

    try:
        zapi.login(options.username, options.password)
        print "Zabbix API Version: %s" % zapi.api_version()
        print "Logged in: %s" % str(zapi.test_login())
    except ZabbixAPIException, e:
        sys.stderr.write(str(e) + '\n')

    try:
        for host in zapi.host.get(monitored_hosts=True, extendoutput=True):
            if host['dns'] == "":
                print "%s - %s - %s" % (host['host'], host['ip'], host['useip'])
            else:
                print "%s - %s - %s" % (host['dns'], host['ip'], host['useip'])

            if host['useip'] == "1" and host['dns'] != "":
                print "Updating %s to monitor by FQDN." % host['dns']
                newhost = host
                newhost['useip'] = 0
示例#31
0
def connectZabbix(region):
    zapi = ZabbixAPI("http://" + region[1], user=username, password=pas)
    print("Connected to %s Zabbix API Version %s" %
          (region[0], zapi.api_version()))
    return zapi
#!/bin/python
from pyzabbix import ZabbixAPI
import pandas as pd

templateid = []
items = []
nometemplate = []
n = 1

user = str(raw_input("Digite o User: "******"Digite a senha: "))

zapi = ZabbixAPI('http://localhost/zabbix')
zapi.login('Admin', 'zabbix')

print(zapi.api_version())

for i in zapi.template.get(output='extend'):
    templateid.append(i['host'])

for x in templateid:
    #print x
    for linha in zapi.template.get(selectItems={'items': 'name'},
                                   filter={'name': x}):
        tam = len(linha['items'])
        #nometemplate.append(x)
        #items.append(linha['items'])
        for h in range(0, tam):
            nometemplate.append(x)
            items.append(linha['items'][h]['name'])
        #tam = len(linha['items'])
示例#33
0
    with open(filename, 'rb') as file:
        obj = pickle.load(file)
    return obj


logw('Start.')
if len(c.vuln_api_key) != 64:
    logw('Error: not a valid Vulners API-key.')
    exit(1)

# создаем сессию в заббикс
try:
    zapi = ZabbixAPI(c.zbx_url, timeout=10)
    zapi.session.verify = c.zbx_verify_ssl_certs
    zapi.login(c.zbx_user, c.zbx_pass)
    logw('Connected to Zabbix API v.{zapi_ver}'.format(zapi_ver=zapi.api_version()))
except Exception as e:
    logw('Error: Can\'t connect to Zabbix API. Exception: {e}'.format(e=e))
    exit(1)

# Если матрица хостов есть - загружаем дамп с диска
if os.path.exists(c.h_matrix_dumpfile):
    logw('Found a dump of the h_matrix in {h_matrix_dumpfile}. Loading.'.format(h_matrix_dumpfile=c.h_matrix_dumpfile))
    h_matrix = dump_load(c.h_matrix_dumpfile)
    total_hosts = len(h_matrix)
else:
        # если дампа матрицы на диске нет - формируем (исходные данные из zabbix и затем обогащаем их через vulners)
    total_hosts = 0
    try:
        h_matrix = zapi.item.get(search={'key_': item_key}, monitored=True, output=['hostid'])
        full_hosts = len(h_matrix)
示例#34
0
    return obj


logw('Start.')
if len(c.vuln_api_key) != 64:
    logw('Error: not a valid Vulners API-key.')
    exit(1)

# создаем сессию в заббикс
try:
    zapi = ZabbixAPI(c.zbx_url, timeout=10)
    zapi.session.verify = c.zbx_verify_ssl_certs
    zapi.login(c.zbx_user, c.zbx_pass)
    # todo: checking that zabbix version >= 3.4
    logw('Connected to Zabbix API v.{zapi_ver}'.format(
        zapi_ver=zapi.api_version()))
except Exception as e:
    logw('Error: Can\'t connect to Zabbix API. Exception: {e}'.format(e=e))
    exit(1)

# Если матрица хостов есть - загружаем дамп с диска
if os.path.exists(c.h_matrix_dumpfile):
    logw(
        'Found a dump of the h_matrix in {h_matrix_dumpfile}. Loading.'.format(
            h_matrix_dumpfile=c.h_matrix_dumpfile))
    h_matrix = dump_load(c.h_matrix_dumpfile)
    total_hosts = len(h_matrix)
else:
    # если дампа матрицы на диске нет - формируем (исходные данные из zabbix и затем обогащаем их через vulners)
    total_hosts = 0
    try:
示例#35
0
class ZabbixConfig(object):

    def __init__(self, endpoint, user, password=''):

        self.zapi = ZabbixAPI(endpoint)
        self.zapi.login(user, password)
        print("Connected to Zabbix API Version %s" % self.zapi.api_version())

        self.item_id = None
        self.trigger_id = None

    def create_action(self, sendto, web_url, use_zabbix_severity=False):

        use_console_link = True

        medias = self.zapi.mediatype.get(output='extend')
        try:
            media_id = [m for m in medias if m['description'] == 'Alerta'][0]['mediatypeid']
        except Exception:
            print('media does not exist. creating...')
            response = self.zapi.mediatype.create(
                type=SCRIPT,
                description='Alerta',
                exec_path='zabbix-alerta',
                exec_params='{ALERT.SENDTO}\n{ALERT.SUBJECT}\n{ALERT.MESSAGE}\n',
                maxattempts='5',
                attempt_interval='5s'
            )
            media_id = response['mediatypeids'][0]

        users = self.zapi.user.get(output='extend')
        admin_user_id = [u for u in users if u['alias'] == 'Admin'][0]['userid']

        media_alerta = {
            'mediatypeid': media_id,
            'sendto': sendto,
            'active': ENABLED,
            'severity': NIWAHD,
            'period': '1-7,00:00-24:00'
        }

        try:
            self.zapi.user.updatemedia(
                users={"userid": admin_user_id},
                medias=media_alerta
            )
        except ZabbixAPIException as e:
            sys.exit(e)

        default_message = (
            "resource={HOST.NAME1}\r\n"
            "event={ITEM.KEY1}\r\n"
            "environment=Production\r\n"
            "severity={TRIGGER.SEVERITY}" + ("!!" if use_zabbix_severity else "") + "\r\n"
            "status={TRIGGER.STATUS}\r\n"
            "ack={EVENT.ACK.STATUS}\r\n"
            "service={TRIGGER.HOSTGROUP.NAME}\r\n"
            "group=Zabbix\r\n"
            "value={ITEM.VALUE1}\r\n"
            "text={TRIGGER.STATUS}: {TRIGGER.NAME}\r\n"
            "tags={EVENT.TAGS}\r\n"
            "attributes.ip={HOST.IP1}\r\n"
            "attributes.thresholdInfo={TRIGGER.TEMPLATE.NAME}: {TRIGGER.EXPRESSION}\r\n"
            "attributes.eventId={EVENT.ID}\r\n"
            "attributes.triggerId={TRIGGER.ID}\r\n"
            "type=zabbixAlert\r\n"
            "dateTime={EVENT.DATE}T{EVENT.TIME}Z\r\n"
        )

        operations_console_link = 'attributes.moreInfo=<a href="%s/tr_events.php?triggerid={TRIGGER.ID}&eventid={EVENT.ID}" target="_blank">Zabbix console</a>' % web_url
        operations = {
            "operationtype": SEND_MESSAGE,
            "opmessage": {
                "default_msg": USE_DATA_FROM_OPERATION,
                "mediatypeid": media_id,
                "subject": "{TRIGGER.STATUS}: {TRIGGER.NAME}",
                "message": default_message + operations_console_link if use_console_link else ''
            },
            "opmessage_usr": [
                {
                    "userid": admin_user_id
                }
            ]
        }

        recovery_console_link = 'attributes.moreInfo=<a href="%s/tr_events.php?triggerid={TRIGGER.ID}&eventid={EVENT.RECOVERY.ID}" target="_blank">Zabbix console</a>' % web_url
        recovery_operations = {
            "operationtype": SEND_MESSAGE,
            "opmessage": {
                "default_msg": USE_DATA_FROM_OPERATION,
                "mediatypeid": media_id,
                "subject": "{TRIGGER.STATUS}: {TRIGGER.NAME}",
                "message": default_message + recovery_console_link if use_console_link else ''
            },
            "opmessage_usr": [
                {
                    "userid": admin_user_id
                }
            ]
        }

        try:
            self.zapi.action.create(
                name='Forward to Alerta',
                eventsource=TRIGGERS,
                status=ENABLED,
                esc_period=120,
                def_shortdata="{TRIGGER.NAME}: {TRIGGER.STATUS}",
                def_longdata=default_message,
                r_shortdata="{TRIGGER.NAME}: {TRIGGER.STATUS}",
                r_longdata=default_message,
                maintenance_mode=DO_NOT_PAUSE_EXEC,
                operations=[operations],
                recovery_operations=[recovery_operations]
            )
        except ZabbixAPIException as e:
            print(e)

    def test_action(self, trapper, endpoint, key=None):

        hosts = self.zapi.host.get()
        zabbix_server_id = [h for h in hosts if h['name'] == 'Zabbix server'][0]['hostid']

        # enable zabbix server monitoring
        self.zapi.host.update(hostid=zabbix_server_id, status=ENABLED)

        description = 'Test trigger event on {HOST.NAME}'
        try:
            response = self.zapi.item.create(
                name='Test Zabbix-Alerta Integration',
                type=ZABBIX_TRAPPER,
                key_='test.alerta',
                value_type=TEXT,
                hostid=zabbix_server_id,
                status=ENABLED
            )
            self.item_id = response['itemids'][0]

            response = self.zapi.trigger.create(
                hostid=zabbix_server_id,
                description=description,
                expression='{Zabbix server:test.alerta.diff()}>0',
                type=GENERATE_MULTIPLE_EVENTS,
                priority=INFORMATION,
                status=ENABLED,
                manual_close=ALLOW_MANUAL_CLOSE
            )
            self.trigger_id = response['triggerids'][0]
        except ZabbixAPIException:
            triggers = self.zapi.trigger.get(hostids=zabbix_server_id)
            self.trigger_id = [t for t in triggers if t['description'] == description][0]['triggerid']
            self.item_id = self.zapi.item.get(triggerids=self.trigger_id)[0]['itemid']

        def zabbix_send(value):
            cfg = protobix.ZabbixAgentConfig()
            cfg.server_active = trapper
            zbx = protobix.DataContainer(cfg)

            zbx.data_type = 'items'
            zbx.add_item(host='Zabbix server', key='test.alerta', value=value)
            response = zbx.send()
            print(response)

        print('sending test items')
        now = int(time.time())
        zabbix_send('OK')

        print('wait for items to be received')
        count = 0
        while True:
            count += 1
            response = self.zapi.history.get(itemids=[self.item_id], history=TEXT, time_from=now, output='extend', sortfield='clock',
                                             sortorder='DESC', limit=10)
            zabbix_send('RETRY%s' % count)
            if len(response) > 1:
                break
            print('waiting 5 seconds...')
            time.sleep(5)

        print('sent items received by zabbix')
        print(response)

        from_date = datetime.utcnow().replace(microsecond=0).isoformat() + ".000Z"

        print('wait for triggered event')
        while True:
            response = self.zapi.event.get(objectids=self.trigger_id, time_from=now, output='extend',
                                           sortfield=['clock', 'eventid'], sortorder='DESC')
            if len(response) > 0 and 'eventid' in response[0]:
                event_id = response[0]['eventid']
                break
            print('waiting 2 seconds...')
            time.sleep(2)

        print('event triggered')
        print(response[0])

        print('wait for alert')
        while True:
            response = self.zapi.alert.get(eventid=event_id, time_from=now, output='extend',)
            if len(response) > 0:
                break
            print('waiting 2 seconds...')
            time.sleep(2)

        print('alert triggered by event')
        print(response[0])

        api = Client(endpoint, key)

        print('check alert received by Alerta')
        while True:
            try:
                response = api.get_alerts(query=[('event', 'test.alerta'), ('from-date', from_date)])
            except Exception as e:
                sys.exit(e)
            if len(response) > 0:
                break
            time.sleep(5)
        print(response[0].last_receive_id)

        print('success!')

    def clean_up(self):

        try:
            self.zapi.trigger.delete(self.trigger_id)
            self.zapi.item.delete(self.item_id)
        except ZabbixAPIException:
            pass
示例#36
0
def connect_to_host(host, user, password):
    print "Connecting to " + host
    api = ZabbixAPI(host)
    api.login(user, password)
    print("Connected to Zabbix API Version %s" % api.api_version())
    return api
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):
        reply = self.zbx_api.host.get(filter={'name': hostname}, output='shorten')
        if not reply:
            raise ZbxException("hostname: {} not found".format(hostname))
        hostid = reply[0]['hostid']
        log.debug('hostID %s', hostid)

        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):
        reply = self.zbx_api.host.get(filter={'name': hostname}, output='shorten')
        if not reply:
            raise ZbxException("hostname: {} not found".format(hostname))
        hostid = reply[0]['hostid']
        log.debug('hostID %s', hostid)

        if '+' in item_in:
            item_in_split = list(map(str.strip, item_in.split('+')))
            item_in_data = self.zbx_api.item.get(filter={'hostid': hostid, 'key_': item_in_split[0]}, output=['lastvalue'])
            for item_in_elem in item_in_split[1:]:
                item_in_data[0]['lastvalue'] = str(int(item_in_data[0]['lastvalue']) + int(self.zbx_api.item.get(filter={'hostid': hostid, 'key_': item_in_elem}, output=['lastvalue'])[0]['lastvalue']))
        else:
            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))

        if '+' in item_out:
            item_out_split = list(map(str.strip, item_out.split('+')))
            item_out_data = self.zbx_api.item.get(filter={'hostid': hostid, 'key_': item_out_split[0]}, output=['lastvalue'])
            for item_out_elem in item_out_split[1:]:
                item_out_data[0]['lastvalue'] = str(int(item_out_data[0]['lastvalue']) + int(self.zbx_api.item.get(filter={'hostid': hostid, 'key_': item_out_elem}, output=['lastvalue'])[0]['lastvalue']))
        else:
            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=['elements', '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 maps 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']
示例#38
0
#print "NEW_EPOCH: %s" % new_epoch


#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())


found_host=False

for h in zapi.host.get(filter={"host": host_name}, output="extend"):
  if (h['host'] == host_name):
    found_host=True
    host_id = h['hostid']
    host_status = h['status']
    #msg = "host %s (%s) status is '%s'" % (h['host'],h['hostid'],h['status'])

    if (host_status == "1"): host_status_text = "disabled"
    if (host_status == "0"): host_status_text = "enabled"

    #logger.info("host_status_text: %s",host_status_text)
示例#39
0
#!/bin/python
from pyzabbix import ZabbixAPI

zapi = ZabbixAPI('http://localhost/zabbix')
zapi.login('Admin', 'zabbix')
print('Connected to Zabbix API Version %s' % zapi.api_version() + '\n')

# Get a list of all issues (AKA tripped triggers)
triggers = zapi.trigger.get(
    only_true=1,
    skipDependent=1,
    monitored=1,
    active=1,
    output='extend',
    expandDescription=1,
    selectHosts=['host'],
)

# Do another query to find out which issues are Unacknowledged
unack_triggers = zapi.trigger.get(
    only_true=1,
    skipDependent=1,
    monitored=1,
    active=1,
    output='extend',
    expandDescription=1,
    selectHosts=['host'],
    withLastEventUnacknowledged=1,
)
unack_trigger_ids = [t['triggerid'] for t in unack_triggers]
for t in triggers:
示例#40
0
    '%(asctime)s  %(process)d  %(levelname)s  %(message)s  [%(filename)s:%(lineno)d]'
)

triggered_host = sys.argv[1]
trigger_id = sys.argv[2]
event_id = sys.argv[3]

logging.info(
    'Getting Started with the event: {}/tr_events.php?triggerid={}&eventid={}'.
    format(zbx_url, trigger_id, event_id))

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.info(
        'Error: Can\'t connect to Zabbix API. Exception: {}'.format(e))
    exit(1)

# todo: добавить обработку "закытие события, без выполнения действия"
try:
    ack = zapi.event.get(eventids=event_id,
                         select_acknowledges=['alias', 'message'],
                         output=['alias', 'message'])
    ack_alias = ack[0]['acknowledges'][0]['alias']
    if ack_alias not in acknowledge_users:
        logging.info(
            'Not trusted user in acknowledge: {}. Skipping this request to fix.'
            .format(ack_alias))
示例#41
0
                                     priority='0', comments=trig_proto_comm, status='0')
        print('Created host "{}" (id: {})\n'.format(zbx_vname, host_id))
        return host_id
    except Exception as e:
        print('Can\'t create host {}. Exception: {}'.format(zbx_host, e))
        exit(1)

if not len(sys.argv) > 1:
    print('\nYou do not specify the objects that you want to create.\nShow help:   ./prepare.py -h\nTypical use: ./prepare.py -uvtda')
    exit(0)

try:
    zapi = ZabbixAPI(zbx_url, timeout=5)
    zapi.session.verify = zbx_verify_ssl
    zapi.login(zbx_user, zbx_pass)
    zapi_ver = zapi.api_version()
    print('Connected to Zabbix API v.{}\n'.format(zapi.api_version()))
    zapi_ver_float = float(zapi_ver.split('.')[0] + '.' + zapi_ver.split('.')[1])
    if zapi_ver_float < required_zapi_ver:
        print('Required Zabbix version {} or higher\nExit.'.format(required_zapi_ver))
        exit(0)
except Exception as e:
    print('Error: Can\'t connect to Zabbix API. Exception: {}'.format(e))
    exit(1)


host_use_ip = 1


# CHECK Z-UTILS
if args.utils:
示例#42
0
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'
	return triggers
#---------------------------------------------------------------------------------------------------------------------
def checkGroups(hostgroup):
	hostgroup = hostgroup[:-1]
	groups = zapi.hostgroup.get(output='extend')
	groupids = []
	for i in range(len(groups)):
		if hostgroup not in groups[i]['name']:
			continue
		else:
			groupids.append(groups[i]['groupid'])
	return groupids
#---------------------------------------------------------------------------------------------------------------------
zapi = ZabbixAPI("http://zabbix_ip/zabbix/api_jsonrpc.php")
zapi.login("zabbix_user", "zabbix_password")
print("Connected to Zabbix API Version %s" % zapi.api_version())
time_till = time.mktime(datetime.now().timetuple())
time_from = time_till - 60 * 60 * 2  # 2 hours
#---------------------------------------------------------#
if time_from_arg == 0:                                    #
	time_from = time_till - 60 * 60 * 2                   #  
else:                                                     #
	time_from = time_till - time_from_arg                 #
if time_till_arg > 0:                                     #
	time_till = time_till - time_till_arg                 #
#---------------------------------------------------------#

if "*" in hostgroup:
	groupids = checkGroups(hostgroup)
triggers = getTriggers()
tot = len(triggers)
示例#44
0
          debug_print('Creating graph: %s' % graph_name)
          zabbix.graph.create(graph)
    except ZabbixAPIException as e:
      print >> sys.stderr, 'ZabbixAPIException thrown on graph: %s' % graph_name
      traceback.print_exc()
            
            

#####################################################################################################
# main 
#####################################################################################################

## connect to Zabbix API ##
zabbix = ZabbixAPI(zabbix_url)
zabbix.login(zabbix_user, zabbix_password)
debug_print('Connected to Zabbix API Version %s' % zabbix.api_version())

for cluster in clusters:
  zabbix_items = {} # item_key -> (itemid, item_name)
  
  debug_print('Searching Zabbix items of node %s' % cluster)
  items = zabbix.item.getObjects(host=cluster)
  if not items:
    print 'WARNING: Cannot find items of Storwize node %s in Zabbix. Check Storwize node name and check Zabbix API user permissions to administer node %s in Zabbix.' % (cluster, cluster)
         
  for i in items:
    if ('key_' in i) and ('itemid' in i) and ('name' in i):
      zabbix_items[ i['key_'] ] = ( i['itemid'], i['name'] )
  items = None