Misthios/grafana-zabbix
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

remove unused

Browse Source
This commit is contained in:
Alexander Zobnin
2020-06-01 12:11:12 +03:00
parent bf69d9037a
commit 55c30b5cad
2 changed files with 2 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
pkg/datasource.go
View File

@@ -12,8 +12,6 @@ import (
"time"
"github.com/alexanderzobnin/grafana-zabbix/pkg/gtime"
simplejson "github.com/bitly/go-simplejson"
"github.com/grafana/grafana_plugin_model/go/datasource"
hclog "github.com/hashicorp/go-hclog"
plugin "github.com/hashicorp/go-plugin"
@@ -34,8 +32,8 @@ type ZabbixDatasource struct {
logger log.Logger
}
// ZabbixDatasourceInstance stores state about a specific datasource and provides methods to make
// requests to the Zabbix API
// ZabbixDatasourceInstance stores state about a specific datasource
// and provides methods to make requests to the Zabbix API
type ZabbixDatasourceInstance struct {
url *url.URL
authToken string
@@ -193,34 +191,6 @@ func readZabbixSettings(dsInstanceSettings *backend.DataSourceInstanceSettings)
return zabbixSettings, nil
}
// Query receives requests from the Grafana backend. Requests are filtered by query type and sent to the
// applicable ZabbixDatasource.
// func (p *ZabbixPlugin) Query(ctx context.Context, tsdbReq *datasource.DatasourceRequest) (resp *datasource.DatasourceResponse, err error) {
// zabbixDS, err := p.GetDatasource(tsdbReq)
// if err != nil {
// return nil, err
// }
// queryType, err := GetQueryType(tsdbReq)
// if err != nil {
// return nil, err
// }
// switch queryType {
// case "zabbixAPI":
// resp, err = zabbixDS.ZabbixAPIQuery(ctx, tsdbReq)
// case "query":
// resp, err = zabbixDS.queryNumericItems(ctx, tsdbReq)
// case "connectionTest":
// resp, err = zabbixDS.TestConnection(ctx, tsdbReq)
// default:
// err = errors.New("Query not implemented")
// return BuildErrorResponse(err), nil
// }
// return
// }
// GetDatasource Returns cached datasource or creates new one
func (ds *ZabbixDatasource) GetDatasource(pluginContext backend.PluginContext) (*ZabbixDatasourceInstance, error) {
dsSettings := pluginContext.DataSourceInstanceSettings
@@ -244,79 +214,8 @@ func (ds *ZabbixDatasource) GetDatasource(pluginContext backend.PluginContext) (
return dsInstance, nil
}
// GetQueryType determines the query type from a query or list of queries
func GetQueryType(tsdbReq *datasource.DatasourceRequest) (string, error) {
queryType := "query"
if len(tsdbReq.Queries) > 0 {
firstQuery := tsdbReq.Queries[0]
queryJSON, err := simplejson.NewJson([]byte(firstQuery.ModelJson))
if err != nil {
return "", err
}
queryType = queryJSON.Get("queryType").MustString("query")
}
return queryType, nil
}
// // BuildDataResponse transforms a Zabbix API response to the QueryDataResponse
// func BuildDataResponse(responseData interface{}) (*backend.QueryDataResponse, error) {
// jsonBytes, err := json.Marshal(responseData)
// if err != nil {
// return nil, err
// }
// return &backend.QueryDataResponse{
// Responses: map[string]backend.DataResponse{
// "zabbixAPI": {
// Frames: ,
// }
// },
// }, nil
// }
func BuildAPIResponse(responseData *interface{}) (*ZabbixAPIResourceResponse, error) {
return &ZabbixAPIResourceResponse{
Result: *responseData,
}, nil
}
// BuildResponse transforms a Zabbix API response to a DatasourceResponse
func BuildResponse(responseData interface{}) (*datasource.DatasourceResponse, error) {
jsonBytes, err := json.Marshal(responseData)
if err != nil {
return nil, err
}
return &datasource.DatasourceResponse{
Results: []*datasource.QueryResult{
{
RefId: "zabbixAPI",
MetaJson: string(jsonBytes),
},
},
}, nil
}
// BuildErrorResponse creates a QueryResult that forwards an error to the front-end
func BuildErrorResponse(err error) *datasource.DatasourceResponse {
return &datasource.DatasourceResponse{
Results: []*datasource.QueryResult{
{
RefId: "zabbixAPI",
Error: err.Error(),
},
},
}
}
// BuildMetricsResponse builds a response object using a given TimeSeries array
func BuildMetricsResponse(metrics []*datasource.TimeSeries) (*datasource.DatasourceResponse, error) {
return &datasource.DatasourceResponse{
Results: []*datasource.QueryResult{
{
RefId: "zabbixMetrics",
Series: metrics,
},
},
}, nil
}

44
pkg/zabbix_api.go
View File

@@ -2,7 +2,6 @@ package main
import (
"encoding/json"
"errors"
"fmt"
"regexp"
"time"
@@ -11,20 +10,9 @@ import (
simplejson "github.com/bitly/go-simplejson"
"github.com/grafana/grafana-plugin-sdk-go/backend"
"github.com/grafana/grafana-plugin-sdk-go/data"
"github.com/grafana/grafana_plugin_model/go/datasource"
"golang.org/x/net/context"
)
type FunctionCategories struct {
Transform []map[string]interface{}
Aggregate []map[string]interface{}
Filter []map[string]interface{}
Trends []map[string]interface{}
Time []map[string]interface{}
Alias []map[string]interface{}
Special []map[string]interface{}
}
// ZabbixAPIQuery handles query requests to Zabbix
func (dsInstance *ZabbixDatasourceInstance) ZabbixAPIQuery(ctx context.Context, apiReq *ZabbixAPIRequest) (*ZabbixAPIResourceResponse, error) {
var result interface{}
@@ -45,38 +33,6 @@ func (dsInstance *ZabbixDatasourceInstance) ZabbixAPIQuery(ctx context.Context,
return BuildAPIResponse(&result)
}
func (ds *ZabbixDatasourceInstance) ZabbixAPIQueryOld(ctx context.Context, tsdbReq *datasource.DatasourceRequest) (*datasource.DatasourceResponse, error) {
result, queryExistInCache := ds.queryCache.Get(HashString(tsdbReq.String()))
if !queryExistInCache {
queries := []requestModel{}
for _, query := range tsdbReq.Queries {
req := requestModel{}
err := json.Unmarshal([]byte(query.GetModelJson()), &req)
if err != nil {
return nil, err
}
queries = append(queries, req)
}
if len(queries) == 0 {
return nil, errors.New("At least one query should be provided")
}
query := queries[0].Target
var err error
result, err = ds.ZabbixRequest(ctx, query.Method, query.Params)
ds.queryCache.Set(HashString(tsdbReq.String()), result)
if err != nil {
ds.logger.Debug("ZabbixAPIQuery", "error", err)
return nil, errors.New("ZabbixAPIQuery is not implemented yet")
}
}
return BuildResponse(result)
}
// TestConnection checks authentication and version of the Zabbix API and returns that info
func (ds *ZabbixDatasourceInstance) TestConnection(ctx context.Context) (string, error) {
_, err := ds.getAllGroups(ctx)