#!/usr/bin/env python

# -*-coding:utf-8 -*-

import requests

import json

class AutoZabbix:

    def __init__(self, hostname, visibleName, ip, groupname, template_name):

        self.url = 'http://192.168.67.230/zabbix/api_jsonrpc.php'

        self.headers = {'Content-Type': 'application/json'}

        auth = {

            "jsonrpc": "2.0",

            "method": "user.login",

            "params": {

                "user": "admin",  ###验证

                "password": ""

            },

            "id": 1,

            "auth": None,

        }

        response = requests.post(self.url, data=json.dumps(auth), headers=self.headers)

        # print(response.text)

        self.authid = json.loads(response.text)['result']  ### auth的id  也就是token

        self.hostname = hostname

        self.visibleName = visibleName

        self.ip = ip

        self.add_template = []  # 生成列表，用于给指定IP的主机添加模板

        # self.add_group = []  # 给指定IP的主机添加组

        self.group_name = groupname  # 多个组以逗号分隔，组名不能包含逗号[不支持多个组？？！]

        self.template_name = list(template_name.split(','))  # 多个模板以逗号分隔，模板名不能包含逗号

    def get_template(self):

        """

        输入模版名，返回模版ID

        :return:

        """

        content = {

            "jsonrpc": "2.0",

            "method": "template.get",

            "params": {

                # "output": "extend",

                # "output": ["host", "templateid"],

                "output": "templateid",

                "filter": {

                    "host": self.template_name

                }

            },

            "auth": self.authid,

            "id": 2

        }

        response = requests.post(self.url, data=json.dumps(content), headers=self.headers)

        result = json.loads(response.text)['result']

        # print(result)

        for item in result:

            for k, v in item.items():

                self.add_template.append(v)

        return self.add_template

    def get_group(self):

        """

        输入组名，查询返回组ID

        """

        content = {

            "jsonrpc": "2.0",

            "method": "hostgroup.get",

            "params": {

                # "output": "extend",

                "output": "groupid",

                "filter": {

                    "name": self.group_name

                }

            },

            "auth": self.authid,

            "id": 3

        }

        response = requests.post(self.url, data=json.dumps(content), headers=self.headers)

        response_dic = json.loads(response.text)

        print(response_dic)

        groupid = response_dic['result'][0]['groupid']

        return groupid

    # def get_hosts(self):

    #     content = {

    #         "jsonrpc": "2.0",

    #         "method": "host.get",

    #         "params": {

    #             "output": [

    #                 "hostid",

    #                 "host"

    #             ],

    #             "selectInterfaces": [

    #                 "interfaceid",

    #                 "ip"

    #             ]

    #         },

    #         "id": 3,

    #         "auth": self.authid

    #     }

    #

    #     response = requests.post(self.url, data=json.dumps(content), headers=self.headers)

    #     # response_dic = json.loads(response.text)

    #     print(response.text)

    def create_host(self):

        """

        添加主机，链接模版、添加组

        :return:

        """

        print(self.get_template())

        content = {

            "jsonrpc": "2.0",

            "method": "host.create",

            "params": {

                "host": self.hostname,

                "name": self.visibleName,

                "interfaces": [

                    {

                        "type": 1,

                        "main": 1,

                        "useip": 1,

                        "ip": self.ip,

                        "dns": "",

                        "port": ""

                    }

                ],

                "groups": [

                    {

                        "groupid": self.get_group()

                    }

                ],

                "templates": [

                    {

                        "templateid": ''

                    },

                    {

                        "templateid": ''

                    },

                    {

                        "templateid": ''

                    }

                ]

                # "inventory_mode": 0,

                # "inventory": {

                #     "macaddress_a": "01234",

                #     "macaddress_b": "56768"

                # }

            },

            "auth": self.authid,

            "id": 21

        }

        # print(json.dumps(content))

        response = requests.post(self.url, data=json.dumps(content), headers=self.headers)

        return response.text

hostname = '192.168.67.227'

visibleName = 'vpn'

ip = '192.168.67.227'

groupname = 'office_server'

template_name = 'disk-IO-status,Template ICMP Ping,Template OS Linux,Template Linux TCP Status'  # 模板之间用逗号分隔

obj = AutoZabbix(hostname, visibleName, ip, groupname, template_name)

response = obj.create_host()

print(response)

# 登录：

#!/usr/bin/env python

import urllib2

import json

#定义URL账户密码

url = 'http://zabbixip/zabbix/api_jsonrpc.php'

username = 'admin'

password = 'password'

#定义通过HTTP方式访问API地址的函数，后面每次请求API的各个方法都会调用这个函数

def requestJson(url,values):

    data = json.dumps(values)

    req = urllib2.Request(url, data, {'Content-Type': 'application/json-rpc'})

    response = urllib2.urlopen(req, data)

    output = json.loads(response.read())

#   print output

    try:

        message = output['result']

    except:

        message = output['error']['data']

        print message

        quit()

    return output['result']

#API接口认证的函数，登录成功会返回一个Token

def authenticate(url, username, password):

    values = {'jsonrpc': '2.0',

              'method': 'user.login',

              'params': {

                  'user': username,

                  'password': password

              },

              'id': ''

              }

    idvalue = requestJson(url,values)

    return idvalue

# API

#!/usr/bin/env python

#coding=utf-8

import sys

import argparse

import urllib2

import json

#定义更新action函数

def mediatypeupdate(mediatypeid,status,auth):

    values = {'jsonrpc': '2.0',

              'method': 'mediatype.update',

              'params': {

                  "mediatypeid": mediatypeid,

                  "status": status

              },

              'auth': auth,

              'id': ''

              }

    output = requestJson(url,values)

#定义读取状态函数

def triggerget(auth):

    values = {'jsonrpc': '2.0',

           "method":"trigger.get",

               "params": {

                        "output": [

                        "triggerid",

                        "description",

                        "priority"

                        ],

              "filter": {

                         "value": 1

                         },

              "expandData":"hostname",

              "sortfield": "priority",

              "sortorder": "DESC"

            },

              'auth': auth,

              'id': ''

              }

    output = requestJson(url,values)

    return output

#定义通过ip获取主机id的函数

def ipgetHostsid(ip,url,auth):

    values = {'jsonrpc': '2.0',

              'method': 'host.get',

              'params': {

                  'output': [ "host" ],

                  'filter': {

                      'ip': ip

                  },

              },

              'auth': auth,

              'id': ''

              }

    output = requestJson(url,values)

    return output

#定义通过主机id获取开启关闭监控函数

def idupdatehost(status,hostid,url,auth):

    values = {'jsonrpc': '2.0',

              'method': 'host.update',

              'params': {

                  "hostid": hostid,

                  "status": status

              },

              'auth': auth,

              'id': ''

              }

    output = requestJson(url,values)

    return output

#定义通过项目hostid获取itemid函数

def getHostsitemsid(hostid,itemsname,url,auth):

    values = {'jsonrpc': '2.0',

              'method': "item.get",

              "params": {

                    "output": ["itemids"],

                    "hostids": hostid,

            "filter":{

                    "key_": itemsname,

                },

                },

              'auth': auth,

              'id': ''

              }

    output = requestJson(url,values)

    if len(output)==0:

        return output

    else:

        return output[0]['itemid']

#定义通过项目id获取监控项目最近值信息的函数

def getHostsitemsvalue(itemid,url,auth):

    values = {'jsonrpc': '2.0',

              'method': "history.get",

              "params": {

                    "output": "extend",

                    "history":3,

                    "itemids":itemid,

                    "sortfield": "clock",

                    "sortorder": "DESC",

                    "limit":1,

                },

              'auth': auth,

              'id': ''

              }

    output = requestJson(url,values)

    if len(output)==0:

        return output

    else:

        return output[0]["value"]

#定义更新读取状态action函数

def mediatypeget(mediatypeid,auth):

    values = {'jsonrpc': '2.0',

              'method': 'mediatype.get',

              'params': {

                "output": "extend",

              "filter": {

                        "mediatypeid":mediatypeid,

                         },

              },

              'auth': auth,

              'id': ''

              }

    output = requestJson(url,values)

    if len(output)==0:

        return output

    else:

        return output[0]['status']

#定义maintenance维修模式host函数

def maintenancecreate(maintenancename,active_since,active_till,hostid,auth):

    values = {'jsonrpc': '2.0',

              'method': 'maintenance.create',

              'params': {

              "name": maintenancename,

              "active_since": active_since,

              "active_till": active_till,

              "hostids": [

                    hostid

                ],

                "timeperiods": [

                            {

                "timeperiod_type": 0,

                "every": 1,

                "dayofweek": 64,

                "start_time": 64800,

                "period": 3600

                            }

                                ]

              },

              'auth': auth,

              'id': ''

              }

    output = requestJson(url,values)

#定义通过模糊获取关闭主机信息函数

def disabledhostget(url,auth):

    values = {'jsonrpc': '2.0',

              'method': 'host.get',

            "params": {

                "output": ["host"],

                'selectInterfaces': [ "ip" ],

                "filter": {

                    "status":1

        }

    },

              'auth': auth,

              'id': ''

              }

    output = requestJson(url,values)

    return output

#定义maintenance维修模式group函数

def maintenancecreategroup(maintenancename,active_since,active_till,groupid,auth):

    values = {'jsonrpc': '2.0',

              'method': 'maintenance.create',

              'params': {

              "name": maintenancename,

              "active_since": active_since,

              "active_till": active_till,

              "groupids": [

                    groupid

                ],

                "timeperiods": [

                            {

                "timeperiod_type": 0,

                "every": 1,

                "dayofweek": 64,

                "start_time": 64800,

                "period": 3600

                            }

                                ]

              },

              'auth': auth,

              'id': ''

              }

    output = requestJson(url,values)

#定义通过host groups named 获取groupid

def groupnameGroupid(groupname,auth):

    values = {'jsonrpc': '2.0',

              'method': 'hostgroup.get',

              "params": {

                    "output": "extend",

                    "filter": {

                        "name": [

                            groupname

                        ]

                    }

                },

              'auth': auth,

              'id': ''

              }

    output = requestJson(url,values)

    return output

#定义模糊查询维护主机

def maintenanceget(url,auth):

    values = {'jsonrpc': '2.0',

              'method': 'maintenance.get',

              "params": {

                    "output": "extend",

                },

              'auth': auth,

              'id': ''

              }

    output = requestJson(url,values)

    return output

#定义批量恢复处于维护主机

def maintenancedelete(maintenanceid,url,auth):

    values = {'jsonrpc': '2.0',

              'method': 'maintenance.delete',

              "params": [

                    maintenanceid

                ],

              'auth': auth,

              'id': ''

              }

    output = requestJson(url,values)

    return output

#定义通过hostid获取graphid的函数

def getgraphid(hostid,graphname,url,auth):

        values = {'jsonrpc': '2.0',

                          'method': 'graph.get',

                          'params': {

                                  "output": "name",

                                  "hostids": hostid,

                                  "sortfield": "name",

                          'filter': {

                                        "name": graphname

                                  },

                          },

                          'auth': auth,

                          'id': ''

                          }

        output = requestJson(url,values)

        return output

# 调用:

#!/usr/bin/env python

#coding=utf-8

import urllib2

import sys

import json

import argparse

from login import *

from function import *

#登陆zabbix获取auth

auth = authenticate(url, username, password)

#状态0是启用监控，1是禁用监控

status=1

#定义操作ip

hostip='192.168.1.100'

#通过hostip获取zabbix hostid

hostids=ipgetHostsid(hostip,url,auth)

hostid=hostids[0]['hostid']

#通过主机id开启关闭监控

idupdatehost(status,hostid,url,auth)