go 访问zabbix API

1.版本：zabbix 3.0
2.zabbix.go

package main
import (
	"bytes"
	"crypto/tls"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"sync"
	"time"
)

/**
Zabbix and Go's RPC implementations don't play with each other.. at all.
So I've re-created the wheel at bit.
*/
type JsonRPCResponse struct {
	Jsonrpc string      `json:"jsonrpc"`
	Error   ZabbixError `json:"error"`
	Result  interface{} `json:"result"`
	Id      int         `json:"id"`
}

type JsonRPCRequest struct {
	Jsonrpc string      `json:"jsonrpc"`
	Method  string      `json:"method"`
	Params  interface{} `json:"params"`

	// Zabbix 2.0:
	// The "user.login" method must be called without the "auth" parameter
	Auth string `json:"auth,omitempty"`
	Id   int    `json:"id"`
}

type ZabbixError struct {
	Code    int    `json:"code"`
	Message string `json:"message"`
	Data    string `json:"data"`
}

var mutexZabbix = &sync.Mutex{}

func (z *ZabbixError) Error() string {
	return z.Data
}
type ZabbixHost map[string]interface{}

type HostGet struct {
	Name      string `json:"name"`
	Hostid    string `json:"hostid"`
}

type API struct {
	url    string
	user   string
	passwd string
	id     int
	auth   string
}


const (
	//zabbix 服务器的IP和url
	IP = "0.0.0.0"
	Url = "http://"+IP+"/zabbix"
)
//server, user, passwd string,
func NewAPI(params ...string) (*API, error) {

	if len(params) == 3 && params[0] != "" && params[1] != "" && params[2] != "" {
		return &API{params[0] + "/api_jsonrpc.php", params[1], params[2], 1, ""}, nil
	}
	if len(params) == 1 && params[0] != "" {
		return &API{id: 1, url:Url+ "/api_jsonrpc.php", auth: params[0]}, nil
	}

	return nil, errors.New("new API 参数错误")
}

func (api *API) GetAuth() string {
	return api.auth
}

func (api *API) ZabbixRequest(method string, data interface{}) (JsonRPCResponse, error) {
	// Setup our JSONRPC Request data x
	id := api.id
	api.id = api.id + 1
	jsonobj := JsonRPCRequest{"2.0", method, data, api.auth, id}
	encoded, err := json.Marshal(jsonobj)
	if err != nil {
		return JsonRPCResponse{}, err
	}

	// Setup our HTTP request
	//client := &http.Client{}
	tr := &http.Transport{ //解决x509: certificate signed by unknown authority
		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
	}
	client := &http.Client{
		Timeout:   30 * time.Second,
		Transport: tr, //解决x509: certificate signed by unknown authority
	}

	request, err := http.NewRequest("POST", api.url, bytes.NewBuffer(encoded))

	if err != nil {
		return JsonRPCResponse{}, err
	}
	request.Header.Add("Content-Type", "application/json-rpc")
	if api.auth != "" {
		// XXX Not required in practice, check spec
		//request.SetBasicAuth(api.user, api.passwd)
		//request.Header.Add("Authorization", api.auth)
	}

	// Execute the request
	response, err := client.Do(request)

	if err != nil {
		return JsonRPCResponse{}, err
	}

	/**
	We can't rely on response.ContentLength because it will
	be set at -1 for large responses that are chunked. So
	we treat each API response as streamed data.
	*/
	var result JsonRPCResponse
	var buf bytes.Buffer

	_, err = io.Copy(&buf, response.Body)
	if err != nil {
		return JsonRPCResponse{}, err
	}

	err = json.Unmarshal(buf.Bytes(), &result)
	if err != nil {
		return JsonRPCResponse{}, err
	}

	response.Body.Close()

	return result, nil
}

func (api *API) Login() (bool, error) {
	params := make(map[string]string, 0)
	params["user"] = api.user
	params["password"] = api.passwd

	response, err := api.ZabbixRequest("user.login", params)
	if err != nil {
		fmt.Printf("Error: %s\n", err)
		return false, err
	}

	if response.Error.Code != 0 {
		return false, &response.Error
	}

	api.auth = response.Result.(string)
	return true, nil
}

func (api *API) Version() (string, error) {
	response, err := api.ZabbixRequest("APIInfo.version", make(map[string]string, 0))
	if err != nil {
		return "", err
	}

	if response.Error.Code != 0 {
		return "", &response.Error
	}

	return response.Result.(string), nil
}

/**
Interface to the host.* calls
*/
func (api *API) Host(method string, data interface{}) ([]ZabbixHost, error) {
	response, err := api.ZabbixRequest("host."+method, data)
	if err != nil {
		return nil, err
	}

	if response.Error.Code != 0 {
		return nil, &response.Error
	}

	// XXX uhg... there has got to be a better way to convert the response
	// to the type I want to return
	res, err := json.Marshal(response.Result)
	var ret []ZabbixHost
	err = json.Unmarshal(res, &ret)
	return ret, nil
}

func GetApi() (*API, error) {
	fmt.Println("GetAPI")
	//zbxUrl := beego.AppConfig.String("ZbxUrl")
	//zbxUser := beego.AppConfig.String("ZbxUser")
	//zbxPassword := beego.AppConfig.String("ZbxPassword")
	zbxUrl := ""
	zbxUser := ""
	zbxPassword := ""

	api, _ := NewAPI(zbxUrl+"/api_jsonrpc.php", zbxUser, zbxPassword)
	if ok, err := api.Login(); ok {
		return api, nil
	} else {
		return nil, err
	}
}

//验证sessionid 并返回用户信息
func CheckAuthentication(sessionid string) (JsonRPCResponse, error) {
	params := []string{sessionid}
	api, _ := NewAPI(Url+"/api_jsonrpc.php", "", "")
	response, err := api.ZabbixRequest("user.checkAuthentication", params)
	if err != nil {
		fmt.Printf("Error: %s\n", err)
		return JsonRPCResponse{}, err
	}

	if response.Error.Code != 0 {
		return JsonRPCResponse{}, &response.Error
	}

	return response, nil
}

func main(){
	fmt.Println("start main")
	//NewAPI,ZabbixRequest,Login
	url := Url
	user := "user"
	password := "password"
	api,err :=NewAPI(url,user,password)
	if err != nil {
		fmt.Println("NewAPI  fail")
	}
	login,err :=api.Login()
	if login {
		//
		fmt.Println("login auth ok")
	}else{
		fmt.Println("login auth fail",err)
	}
	//请求数据
	method:= "host.get"
	//api.Host  method:= "get"
	data   := map[string]interface{}{
		"groupids":"8",
		"output":   []string{"name", "hostid"},
		//"search":    map[string]interface{}{"name":"aix"},
		//"filter": map[string]int{"hostid":10110},
		"selectGroups":[]string{"name", "hostid"},
	}
	//获取结果
	result,err:=api.ZabbixRequest(method,data)
	if err != nil {
		return
	}
	if result.Error.Code != 0 {
		err = errors.New(result.Error.Message)
		return
	}

	//json 转化
	res, err := json.Marshal(result.Result)
	if err != nil {
		return
	}
	var resultData []HostGet
	err = json.Unmarshal(res, &resultData)
	if err != nil {
		return
	}
	//取值
	for j := range resultData {
		fmt.Println("value=",resultData[j].Name,resultData[j].Hostid)
	}

	//re,err:=api.Host(method,data)
	fmt.Printf("re,err---",re,err)
	//for k,v:=range re{
	//	fmt.Println(k)
	//	fmt.Println(v)
	//}
}