def check_cluster(trigger):
    zapi = ZabbixAPI(zabbix_site)
    zapi.login(zabbix_user,zabbix_pass)
    
    trigger_notok = zapi.trigger.get(monitored=1,selectHosts=1,
                                     output=['hosts'],withLastEventUnacknowledged=1,
                                     search={'description':trigger},filter={"value":1})

    trigger_host_list = []
    for trigger_item in trigger_notok:
        trigger_host = trigger_item['hosts'][0]['hostid']
        trigger_host_list.append(int(trigger_host))

    trigger_host_msglist = []
    trigger_host_list_nondup = list(set(trigger_host_list))
    for trigger_host_nondup in trigger_host_list_nondup:
        trigger_host_dict = zapi.host.get(hostids=trigger_host_nondup)
        trigger_host_name = trigger_host_dict[0]['host']
        trigger_host_count = trigger_host_list.count(trigger_host_nondup)
        trigger_host_msg = "{0} trigger(s) on {1}".format(trigger_host_count,trigger_host_name)
        trigger_host_msglist.append(trigger_host_msg)

    if not trigger_host_msglist:
        print "OK"
    else:
        print '; '.join(trigger_host_msglist)

    return True

class process_base(object):

    def __init__(self):
        ZABBIX_SERVER = 'http://192.168.1.203:82'
        #ZABBIX_SERVER = 'http://119.79.232.99:82'
        self.zapi = ZabbixAPI(ZABBIX_SERVER)
        # Login to the Zabbix API
        self.zapi.login('Admin', 'zabbix')
        self.zabbix_url = ZABBIX_SERVER

    def gid_2_group_list(self):
        '''
        '''
        return self.zapi.hostgroup.get(output='extend')

    def zabbix_url(self):
        # just for view.py intial the zabbix_url
        return self.zabbix_url

    def clock_2_time(self, clock_time):
        '''
        '''
        return datetime.fromtimestamp(int(clock_time)).strftime('%Y-%m-%d %X')

    def clock_2_timedelta(self, clock_time):
        '''

        '''
        time_delta = datetime.fromtimestamp(
            int(clock_time)) - datetime.fromtimestamp(0)
        delta_day = time_delta.days
        delta_hour = time_delta.seconds / 3600
        delta_min = time_delta.seconds % 3600 / 60
        return '%s days, %s hours, %s minutes' % (delta_day, delta_hour, delta_min)

def client(**kwargs):
    global zapi
    if not zapi:
        zapi = ZabbixAPI(kwargs['url'])
        zapi.login(kwargs['username'], kwargs['password'])
        print zapi.api_version()
    return zapi

def main(argv):

    cfgfile = "/etc/zabbix_stats.cfg"
    try:
        opts, args = getopt.getopt(argv, "hc:", ["configfile="])
    except getopt.GetoptError:
        print 'zabbix_stats.py -c <configfile>'
        sys.exit(2)
    for opt, arg in opts:
        if opt == '-h':
            print 'zabbix_stats.py -c <configfile>'
            sys.exit(2)
        elif opt in ("-c", "--configfile"):
            cfgfile = arg

    global pp
    pp = pprint.PrettyPrinter(indent=4)
    config = ConfigParser.ConfigParser()
    config.read(cfgfile)

    global zapi
    zapi = ZabbixAPI(config.get('Server', 'zabbixurl'))
    zapi.session.verify = False
    # Login to the Zabbix API
    zapi.login(config.get('Server', 'username'), config.get('Server', 'password'))

    while(1):
        Alerts()    

def main():

    # Enter administrator credentials for the Zabbix Web Frontend
    username = raw_input('Username: ')
    password = getpass()

    zapi = ZabbixAPI(zabbix_server, username, password)
    zapi.login(username, password)
    print "Connected to Zabbix API Version %s" % zapi.api_version()

    for h in zapi.host.get(extendoutput=True):
        # Make sure the hosts are named according to their FQDN
        if h['dns'] != h['host']:
            print '%s is actually connecting to %s.' % (h['host'],h['dns'])

        # Make sure they are using hostnames to connect rather than IPs
        if h['useip'] == '1':
            print '%s is using IP instead of hostname. Skipping.' % h['host']
            continue

        # Set their IP record to match what the DNS system says it should be
        try:
            lookup = socket.gethostbyaddr(h['dns'])
        except socket.gaierror, e:
            print h['dns'], e
            continue
        actual_ip = lookup[2][0]
        if actual_ip != h['ip']:
            print "%s has the wrong IP: %s. Changing it to: %s" % (h['host'], h['ip'], actual_ip)
            update_host_ip(zapi,h['hostid'],actual_ip)

    def test_host_get(self):
        httpretty.register_uri(
            httpretty.POST,
            "http://example.com/api_jsonrpc.php",
            body=json.dumps({
                "jsonrpc": "2.0",
                "result": [{"hostid": 1234}],
                "id": 0
            }),
        )

        zapi = ZabbixAPI('http://example.com')
        zapi.auth = "123"
        result = zapi.host.get()

        # Check request
        self.assertEqual(
            httpretty.last_request().body,
            json.dumps({
                'jsonrpc': '2.0',
                'method': 'host.get',
                'params': {},
                'auth': '123',
                'id': 0,
            })
        )

        # Check response
        self.assertEqual(result, [{"hostid": 1234}])

    def test_host_delete(self):
        httpretty.register_uri(
            httpretty.POST,
            "http://example.com/api_jsonrpc.php",
            body=json.dumps({
                "jsonrpc": "2.0",
                "result": {
                    "itemids": [
                        "22982",
                        "22986"
                    ]
                },
                "id": 0
            }),
        )

        zapi = ZabbixAPI('http://example.com')
        zapi.auth = "123"
        result = zapi.host.delete("22982", "22986")

        # Check request
        self.assertEqual(
            httpretty.last_request().body,
            json.dumps({
                'jsonrpc': '2.0',
                'method': 'host.delete',
                'params': ["22982", "22986"],
                'auth': '123',
                'id': 0,
            })
        )

        # Check response
        self.assertEqual(set(result["itemids"]), set(["22982", "22986"]))

    def test_login(self):
        httpretty.register_uri(
            httpretty.POST,
            "http://example.com/api_jsonrpc.php",
            body=json.dumps({
                "jsonrpc": "2.0",
                "result": "0424bd59b807674191e7d77572075f33",
                "id": 0
            }),
        )

        zapi = ZabbixAPI('http://example.com')
        zapi.login('mylogin', 'mypass')

        # Check request
        self.assertEqual(
            httpretty.last_request().body,
            json.dumps({
                'jsonrpc': '2.0',
                'method': 'user.login',
                'params': {'user': 'mylogin', 'password': 'mypass'},
                'id': 0,
            })
        )
        self.assertEqual(
            httpretty.last_request().headers['content-type'],
            'application/json-rpc'
        )
        self.assertEqual(
            httpretty.last_request().headers['user-agent'],
            'python/pyzabbix'
        )

        # Check response
        self.assertEqual(zapi.auth, "0424bd59b807674191e7d77572075f33")

class ZabbixUtils(object):
    def __init__(self):
        s = requests.Session()
        s.auth = (CONF.zabbix.username, CONF.zabbix.password)
        s.verify = False

        self.zapi = ZabbixAPI(CONF.zabbix.url, s)
        self.zapi.login(CONF.zabbix.username, CONF.zabbix.password)

    def set_graphite_format(self, s):
        """
        Removes whitespaces and lowercases the string
        """
        return ''.join(s.split()).lower()

    def get_hosts_per_hostgroup(self):
        """Returns a dictionary with Zabbix's hostgroup->hosts mapping."""
        d = {}
        for hostgroup in self.zapi.hostgroup.get(real_hosts=1, 
                                                 output="extend",
                                                 selectHosts="extend"):
            name = hostgroup["name"]
            hosts = [host["name"] for host in hostgroup["hosts"]]
            d[name] = hosts
        return d

    def get_items_by_host(self, h, filters=[]):
        """Returns a formated list of (metric, value) pairs.

            h: Zabbix's name for the host.
            filters: a list of keys to search for.
        """
        d = {}
        for f in filters:
            for item in self.zapi.item.get(search={"key_": f},
                                      host=h, 
                                      output=["itemid",
                                              "name", 
                                              "lastvalue", 
                                              "key_"]):
                itemid = item.pop("itemid")
                d[itemid] = item

        l = []
        for m in d.values():
            l.append([m["key_"], m["lastvalue"]])

        l_metric = []
        hostgroups = [group["name"] for group in self.zapi.host.get(
                                            search={"name": h},
                                            output="groups", 
                                            selectGroups="extend")[0]["groups"]]
        h = self.set_graphite_format(h)
        for hgroup in hostgroups:
            hgroup = self.set_graphite_format(hgroup)
            for m in l:
                k = self.set_graphite_format(m[0])
                l_metric.append([".".join([hgroup, h, k]), m[1]])

        return l_metric

def initiate_connection():
    global connection
    logger.error('Initiating connection')
    login = settings.ZABBIX_USER
    passwd = settings.ZABBIX_PASSWORD
    connection = ZabbixAPI(server=settings.ZABBIX_URL)
    connection.login(login, passwd)

    def _connect(self):
        s = requests.Session()
        s.auth = (CONF.zabbix.username, CONF.zabbix.password)
        s.verify = False
        conn = ZabbixAPI(CONF.zabbix.url, s)
        conn.login(CONF.zabbix.username, CONF.zabbix.password)

        return conn

def auth_zabbix(server_ip, username="Admin", password="zabbix"):
    logging.debug("Authentication - Zabbix Server")

    zapi = ZabbixAPI("http://" + server_ip + "/zabbix")
    zapi.login(username, password)

    logging.debug("Connected to Zabbix API Version %s" % zapi.api_version())
    return zapi

 def test_get_api_version(self):
     zapi = ZabbixAPI(url='http://127.0.0.1',
                      user='Admin',
                      password='zabbix')
     if os.environ['ZABBIX_VERSION'] == '3':
         self.assertEqual(zapi.api_version(), '3.0.1')
     elif os.environ['ZABBIX_VERSION'] == '2':
         self.assertEqual(zapi.api_version(), '2.4.7')
     else:
         self.fail('api_version() not tested!')

def get_zabbix_api():
    zapi = None
    if zabbix_comment_update:
        zapi = ZabbixAPI(zabbix_url)
        try:
            zapi.login(zabbix_user, zabbix_password)
        except Exception as e:
            print 'some errors occurs'
            print e
    return zapi

class ZabbixClinet(object):
    def __init__(self, idc, address, username, password):
        self.idc = idc
        self.address = address
        try:
            self.zbx_api = ZabbixAPI(address)
            self.zbx_api.login(username, password)
        except Exception, error:
            # logging.warning(error)
            raise Exception

def _get_zabbix(server = None, password = None, user = None):
    from pyzabbix import ZabbixAPI
    import thoth.zabbix as zabbix
    zabbix_server = server if server else os.environ.get('ZABBIX_SERVER', 'http://127.0.0.1')
    zabbix_user = user if user else os.environ.get('ZABBIX_USER', 'Admin')
    zabbix_password = password if password else os.environ.get('ZABBIX_PASSWORD', 'zabbix')
    if zabbix_server and not match('^http[s]*://', zabbix_server):
        zabbix_server = 'http://' + zabbix_server
    zbx = ZabbixAPI(zabbix_server)
    zbx.login(zabbix_user, zabbix_password)
    return zabbix.MonitorZabbix(zbx)

    def set_zabbix_handle(self, name, host, user, password, ssl_verify):
        if not self.zabbix_handles.get(name, False):
            zapi = ZabbixAPI(host)
            zapi.session.verify = ssl_verify
            zapi.login(user, password)

            self.Server.create(host=host, token=zapi.auth)
            self.zabbix_handles[name] = zapi
            ret = zapi
        else:
            ret = self.zabbix_handles[host]
        return ret

    def sample(self):
        zapi = ZabbixAPI("http://zabbix.tonyrogers.me/zabbix/")
        zapi.session.verify = False
        zapi.login("Admin", "zabbix")
        ret = zapi.item.get(output=['lastvalue'],filter={'host':'zabbix.tonyrogers.me'},search={'key_':'zabbix[wcache,values]'})

        self.items.append({'x': self.seedX,
                           'y': ret[0]['lastvalue']})
        self.seedX += 1
        if len(self.items) > 10:
            self.items.popleft()
        return {'points': list(self.items)}

def disable_on_zabbix(instance_name):
    zapi = ZabbixAPI(zabbix_api)
    zapi.login(zabbix_user, zabbix_pass)

    hosts = zapi.host.get(filter={
        "name": instance_name
    })
    if len(hosts) > 0 and 'hostid' in hosts[0]:
        hostid = hosts[0]['hostid']
        print("Disabling on Zabbix: %s %s" %
              (instance_name, hostid))
        zapi.host.update(hostid=hostid, status=1)

def authentication(server_url,user,password):

  if server_url and user and password:
    ZABBIX_SERVER = server_url
    zapi = ZabbixAPI(ZABBIX_SERVER)
    try:
      # Login to the Zabbix API
      zapi.login(user,password)
      return zapi
    except Exception, e:
      print(e)
      sys.exit(1)