func queryAgentAlive(queries []*cmodel.GraphLastParam, reqHost string, result map[string]interface{}) []cmodel.GraphLastResp {
data := []cmodel.GraphLastResp{}
if len(queries) > 0 {
if strings.Index(g.Config().Api.Query, reqHost) >= 0 {
proc.LastRequestCnt.Incr()
for _, param := range queries {
if param == nil {
continue
}
last, err := graph.Last(*param)
if err != nil {
log.Printf("graph.last fail, resp: %v, err: %v", last, err)
}
if last == nil {
continue
}
data = append(data, *last)
}
proc.LastRequestItemCnt.IncrBy(int64(len(data)))
} else {
s, err := json.Marshal(queries)
if err != nil {
setError(err.Error(), result)
}
url := g.Config().Api.Query + "/graph/last"
reqPost, err := http.NewRequest("POST", url, bytes.NewBuffer([]byte(s)))
if err != nil {
setError(err.Error(), result)
}
reqPost.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(reqPost)
if err != nil {
setError(err.Error(), result)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
err = json.Unmarshal(body, &data)
if err != nil {
setError(err.Error(), result)
}
}
}
return data
}
func configGraphRoutes() {
// method:post
http.HandleFunc("/graph/history", func(w http.ResponseWriter, r *http.Request) {
// statistics
proc.HistoryRequestCnt.Incr()
var body GraphHistoryParam
decoder := json.NewDecoder(r.Body)
err := decoder.Decode(&body)
if err != nil {
StdRender(w, "", err)
return
}
if len(body.EndpointCounters) == 0 {
StdRender(w, "", errors.New("empty_payload"))
return
}
data := []*cmodel.GraphQueryResponse{}
isPacketLossRate := detectCounter("packet-loss-rate", body)
isAverage := detectCounter("average", body)
if isPacketLossRate || isAverage {
// NQM Case
if isPacketLossRate {
data = append(data, nqmData(body, "packet-loss-rate", "packets-sent")...)
} else if isAverage {
data = append(data, nqmData(body, "average", "transmission-time")...)
}
} else {
for _, ec := range body.EndpointCounters {
regx, _ := regexp.Compile("(\\.\\$\\s*|\\s*)$")
endpoint := regx.ReplaceAllString(ec.Endpoint, "")
counter := regx.ReplaceAllString(ec.Counter, "")
result := graphQueryOne(ec, body, endpoint, counter)
if result == nil {
continue
}
data = append(data, result)
}
}
// statistics
proc.HistoryResponseCounterCnt.IncrBy(int64(len(data)))
for _, item := range data {
proc.HistoryResponseItemCnt.IncrBy(int64(len(item.Values)))
}
StdRender(w, data, nil)
})
// post, info
http.HandleFunc("/graph/info", func(w http.ResponseWriter, r *http.Request) {
// statistics
proc.InfoRequestCnt.Incr()
var body []*cmodel.GraphInfoParam
decoder := json.NewDecoder(r.Body)
err := decoder.Decode(&body)
if err != nil {
StdRender(w, "", err)
return
}
if len(body) == 0 {
StdRender(w, "", errors.New("empty"))
return
}
data := []*cmodel.GraphFullyInfo{}
for _, param := range body {
if param == nil {
continue
}
info, err := graph.Info(*param)
if err != nil {
log.Printf("graph.info fail, resp: %v, err: %v", info, err)
}
if info == nil {
continue
}
data = append(data, info)
}
StdRender(w, data, nil)
})
// post, last
http.HandleFunc("/graph/last", func(w http.ResponseWriter, r *http.Request) {
// statistics
proc.LastRequestCnt.Incr()
var body []*cmodel.GraphLastParam
decoder := json.NewDecoder(r.Body)
err := decoder.Decode(&body)
if err != nil {
StdRender(w, "", err)
return
}
if len(body) == 0 {
StdRender(w, "", errors.New("empty"))
return
}
data := []*cmodel.GraphLastResp{}
for _, param := range body {
if param == nil {
continue
}
last, err := graph.Last(*param)
if err != nil {
log.Printf("graph.last fail, resp: %v, err: %v", last, err)
}
if last == nil {
continue
}
data = append(data, last)
}
// statistics
proc.LastRequestItemCnt.IncrBy(int64(len(data)))
StdRender(w, data, nil)
})
// post, last/raw
http.HandleFunc("/graph/last/raw", func(w http.ResponseWriter, r *http.Request) {
// statistics
proc.LastRawRequestCnt.Incr()
var body []*cmodel.GraphLastParam
decoder := json.NewDecoder(r.Body)
err := decoder.Decode(&body)
if err != nil {
StdRender(w, "", err)
return
}
if len(body) == 0 {
StdRender(w, "", errors.New("empty"))
return
}
data := []*cmodel.GraphLastResp{}
for _, param := range body {
if param == nil {
continue
}
last, err := graph.LastRaw(*param)
if err != nil {
log.Printf("graph.last.raw fail, resp: %v, err: %v", last, err)
}
if last == nil {
continue
}
data = append(data, last)
}
// statistics
proc.LastRawRequestItemCnt.IncrBy(int64(len(data)))
StdRender(w, data, nil)
})
}
func configGraphRoutes() {
// method:post
http.HandleFunc("/graph/history", func(w http.ResponseWriter, r *http.Request) {
// statistics
proc.HistoryRequestCnt.Incr()
var body GraphHistoryParam
decoder := json.NewDecoder(r.Body)
err := decoder.Decode(&body)
if err != nil {
StdRender(w, "", err)
return
}
if len(body.EndpointCounters) == 0 {
StdRender(w, "", errors.New("empty_payload"))
return
}
data := []*cmodel.GraphQueryResponse{}
for _, ec := range body.EndpointCounters {
request := cmodel.GraphQueryParam{
Start: int64(body.Start),
End: int64(body.End),
ConsolFun: body.CF,
Endpoint: ec.Endpoint,
Counter: ec.Counter,
}
result, err := graph.QueryOne(request)
if err != nil {
log.Printf("graph.queryOne fail, %v", err)
}
if result == nil {
continue
}
data = append(data, result)
}
// statistics
proc.HistoryResponseCounterCnt.IncrBy(int64(len(data)))
for _, item := range data {
proc.HistoryResponseItemCnt.IncrBy(int64(len(item.Values)))
}
StdRender(w, data, nil)
})
// post, info
http.HandleFunc("/graph/info", func(w http.ResponseWriter, r *http.Request) {
// statistics
proc.InfoRequestCnt.Incr()
var body []*cmodel.GraphInfoParam
decoder := json.NewDecoder(r.Body)
err := decoder.Decode(&body)
if err != nil {
StdRender(w, "", err)
return
}
if len(body) == 0 {
StdRender(w, "", errors.New("empty"))
return
}
data := []*cmodel.GraphFullyInfo{}
for _, param := range body {
if param == nil {
continue
}
info, err := graph.Info(*param)
if err != nil {
log.Printf("graph.info fail, resp: %v, err: %v", info, err)
}
if info == nil {
continue
}
data = append(data, info)
}
StdRender(w, data, nil)
})
// post, last
http.HandleFunc("/graph/last", func(w http.ResponseWriter, r *http.Request) {
// statistics
proc.LastRequestCnt.Incr()
var body []*cmodel.GraphLastParam
decoder := json.NewDecoder(r.Body)
err := decoder.Decode(&body)
if err != nil {
StdRender(w, "", err)
return
}
if len(body) == 0 {
StdRender(w, "", errors.New("empty"))
return
}
data := []*cmodel.GraphLastResp{}
for _, param := range body {
if param == nil {
continue
}
last, err := graph.Last(*param)
if err != nil {
log.Printf("graph.last fail, resp: %v, err: %v", last, err)
}
if last == nil {
continue
}
data = append(data, last)
}
// statistics
proc.LastRequestItemCnt.IncrBy(int64(len(data)))
StdRender(w, data, nil)
})
// post, last/raw
http.HandleFunc("/graph/last/raw", func(w http.ResponseWriter, r *http.Request) {
// statistics
proc.LastRawRequestCnt.Incr()
var body []*cmodel.GraphLastParam
decoder := json.NewDecoder(r.Body)
err := decoder.Decode(&body)
if err != nil {
StdRender(w, "", err)
return
}
if len(body) == 0 {
StdRender(w, "", errors.New("empty"))
return
}
data := []*cmodel.GraphLastResp{}
for _, param := range body {
if param == nil {
continue
}
last, err := graph.LastRaw(*param)
if err != nil {
log.Printf("graph.last.raw fail, resp: %v, err: %v", last, err)
}
if last == nil {
continue
}
data = append(data, last)
}
// statistics
proc.LastRawRequestItemCnt.IncrBy(int64(len(data)))
StdRender(w, data, nil)
})
}
