// addCalculatedTraces adds the traces returned from evaluating the given
// formula over the given tile to the QueryResponse.
func addCalculatedTraces(qr *QueryResponse, tile *tiling.Tile, formula string) error {
ctx := parser.NewContext(tile)
traces, err := ctx.Eval(formula)
if err != nil {
return fmt.Errorf("Failed to evaluate formula %q: %s", formula, err)
}
hasFormula := false
for _, tr := range traces {
if tiling.IsFormulaID(tr.Params()["id"]) {
hasFormula = true
}
tg := traceGuiFromTrace(tr, tr.Params()["id"], tile)
qr.Traces = append(qr.Traces, tg)
}
if !hasFormula {
// If we haven't added the formula trace to the response yet, add it in now.
f := types.NewPerfTraceN(len(tile.Commits))
tg := traceGuiFromTrace(f, tiling.AsFormulaID(formula), tile)
qr.Traces = append(qr.Traces, tg)
}
return nil
}
// queryHandler handles queries for and about traces.
//
// Queries look like:
//
// /query/0/-1/?arch=Arm7&arch=x86&scale=1
//
// Where they keys and values in the query params are from the ParamSet.
// Repeated parameters are matched via OR. I.e. the above query will include
// anything that has an arch of Arm7 or x86.
//
// The first two path paramters are tile scale and tile number, where -1 means
// the last tile at the given scale.
//
// The normal response is JSON of the form:
//
// {
// "matches": 187,
// }
//
// If the path is:
//
// /query/0/-1/traces/?arch=Arm7&arch=x86&scale=1
//
// Then the response is the set of traces that match that query.
//
// {
// "traces": [
// {
// // All of these keys and values should be exactly what Flot consumes.
// data: [[1, 1.1], [20, 30]],
// label: "key1",
// _params: {"os: "Android", ...}
// },
// {
// data: [[1.2, 2.1], [20, 35]],
// label: "key2",
// _params: {"os: "Android", ...}
// }
// ]
// }
//
// If the path is:
//
// /query/0/-1/traces/?__shortcut=11
//
// Then the traces in the shortcut with that ID are returned, along with the
// git hash at the step function, if the shortcut came from an alert.
//
// {
// "traces": [
// {
// // All of these keys and values should be exactly what Flot consumes.
// data: [[1, 1.1], [20, 30]],
// label: "key1",
// _params: {"os: "Android", ...}
// },
// ...
// ],
// "hash": "a012334...",
// }
//
//
// TODO Add ability to query across a range of tiles.
func queryHandler(w http.ResponseWriter, r *http.Request) {
glog.Infof("Query Handler: %q\n", r.URL.Path)
match := queryHandlerPath.FindStringSubmatch(r.URL.Path)
glog.Infof("%#v", match)
if r.Method != "GET" || match == nil || len(match) != 4 {
http.NotFound(w, r)
return
}
if err := r.ParseForm(); err != nil {
util.ReportError(w, r, err, "Failed to parse query params.")
}
tileScale, err := strconv.ParseInt(match[1], 10, 0)
if err != nil {
util.ReportError(w, r, err, "Failed parsing tile scale.")
return
}
tileNumber, err := strconv.ParseInt(match[2], 10, 0)
if err != nil {
util.ReportError(w, r, err, "Failed parsing tile number.")
return
}
glog.Infof("tile: %d %d", tileScale, tileNumber)
tile := masterTileBuilder.GetTile()
w.Header().Set("Content-Type", "application/json")
ret := &QueryResponse{
Traces: []*tiling.TraceGUI{},
Hash: "",
}
if match[3] == "" {
// We only want the count.
total := 0
for _, tr := range tile.Traces {
if tiling.Matches(tr, r.Form) {
total++
}
}
glog.Info("Count: ", total)
inc := json.NewEncoder(w)
if err := inc.Encode(map[string]int{"matches": total}); err != nil {
glog.Errorf("Failed to write or encode output: %s", err)
return
}
} else {
// We want the matching traces.
shortcutID := r.Form.Get("__shortcut")
if shortcutID != "" {
sh, err := shortcut.Get(shortcutID)
if err != nil {
http.NotFound(w, r)
return
}
if sh.Issue != "" {
if tile, err = trybot.TileWithTryData(tile, sh.Issue); err != nil {
util.ReportError(w, r, err, "Failed to populate shortcut data with trybot result.")
return
}
}
ret.Hash = sh.Hash
for _, k := range sh.Keys {
if tr, ok := tile.Traces[k]; ok {
tg := traceGuiFromTrace(tr.(*types.PerfTrace), k, tile)
if tg != nil {
ret.Traces = append(ret.Traces, tg)
}
} else if tiling.IsFormulaID(k) {
// Re-evaluate the formula and add all the results to the response.
formula := tiling.FormulaFromID(k)
if err := addCalculatedTraces(ret, tile, formula); err != nil {
glog.Errorf("Failed evaluating formula (%q) while processing shortcut %s: %s", formula, shortcutID, err)
}
} else if strings.HasPrefix(k, "!") {
glog.Errorf("A calculated trace is slipped through: (%s) in shortcut %s: %s", k, shortcutID, err)
}
}
} else {
for key, tr := range tile.Traces {
if tiling.Matches(tr, r.Form) {
tg := traceGuiFromTrace(tr.(*types.PerfTrace), key, tile)
if tg != nil {
ret.Traces = append(ret.Traces, tg)
}
}
}
}
enc := json.NewEncoder(w)
if err := enc.Encode(ret); err != nil {
glog.Errorf("Failed to write or encode output: %s", err)
return
}
}
}
