Add alerting for CTFE V2.

prober/go/prober/main.go

 // Prober is an HTTP prober that periodically sends out HTTP requests to specified
 // endpoints and reports if the returned results match the expectations. The results
 // of the probe, including latency, are recored in InfluxDB using the Carbon protocol.
 // See probers.json as an example of the config file format.
 package main
 
 import (
         "encoding/json"
         "flag"
         "fmt"
@@ skipping 16 matching lines @@
 var (
         graphiteServer = flag.String("graphite_server", "localhost:2003", "Where is Graphite metrics ingestion server running.")
         config         = flag.String("config", "probers.json,buildbots.json", "Comma separated names of prober config files.")
         prefix         = flag.String("prefix", "prober", "Prefix to add to all prober values sent to Graphite.")
         useMetadata    = flag.Bool("use_metadata", true, "Load sensitive values from metadata not from flags.")
         apikey         = flag.String("apikey", "", "The API Key used to make issue tracker requests. Only for local testing.")
         runEvery       = flag.Duration("run_every", 1*time.Minute, "How often to run the probes.")
 
         // bodyTesters is a mapping of names to functions that test response bodies.
         bodyTesters = map[string]BodyTester{
-                "buildbotJSON":     testBuildbotJSON,
-                "skfiddleJSONGood": skfiddleJSONGood,
-                "skfiddleJSONBad":  skfiddleJSONBad,
-                "validJSON":        validJSON,
+                "buildbotJSON":                   testBuildbotJSON,
+                "ctfeChromiumPerfParametersJSON": ctfeChromiumPerfParametersJSON,
+                "ctfeGetTasksJSON":               ctfeGetTasksJSON,
+                "ctfeGetTasksNonEmptyJSON":       ctfeGetTasksNonEmptyJSON,
+                "ctfeRevDataJSON":                ctfeRevDataJSON,
+                "skfiddleJSONGood":               skfiddleJSONGood,
+                "skfiddleJSONBad":                skfiddleJSONBad,
+                "validJSON":                      validJSON,
         }
 )
 
 const (
         TIMEOUT              = time.Duration(5 * time.Second)
         ISSUE_TRACKER_PERIOD = 15 * time.Minute
 )
 
 // BodyTester tests the response body from a probe and returns true if it passes all tests.
 type BodyTester func(io.Reader) bool
@@ skipping 113 matching lines @@
         }
         glog.Infof("%#v", s)
         return len(s.CompileErrors) == 0
 }
 
 // skfiddleJSONBad tests that the compile completed w/error.
 func skfiddleJSONBad(r io.Reader) bool {
         return !skfiddleJSONGood(r)
 }
 
+// decodeJSONObject reads a JSON object from r and returns the resulting object. Returns nil if the
+// JSON is invalid or can't be decoded to a map[string]interface{}.
+func decodeJSONObject(r io.Reader) map[string]interface{} {
+        var obj map[string]interface{}
+        if json.NewDecoder(r).Decode(&obj) != nil {
+                return nil
+        }
+        return obj
+}
+
+// hasKeys tests that the given decoded JSON object has at least the provided keys. If obj is nil,
+// returns false.
+func hasKeys(obj map[string]interface{}, keys []string) bool {
+        if obj == nil {
+                return false
+        }
+        for _, key := range keys {
+                if _, ok := obj[key]; !ok {
+                        return false
+                }
+        }
+        return true
+}
+
+// ctfeChromiumPerfParametersJSON tests that the response contains valid JSON with the keys
+// expected by ct/templates/chromium_perf.html.
+func ctfeChromiumPerfParametersJSON(r io.Reader) bool {
+        return hasKeys(decodeJSONObject(r), []string{"benchmarks", "platforms"})
+}
+
+// ctfeGetTasksJSONObject tests that obj has the attributes expected by
+// ct/res/imp/pending-tasks-sk.html and ct/res/imp/*-runs-sk.html. Returns false if obj is nil.
+func ctfeGetTasksJSONObject(obj map[string]interface{}) bool {
+        if !hasKeys(obj, []string{"data", "permissions", "pagination"}) {
+                return false
+        }
+        data, dataOk := obj["data"].([]interface{})
+        permissions, permissionsOk := obj["permissions"].([]interface{})
+        if !dataOk || !permissionsOk || len(data) != len(permissions) {
+                return false
+        }
+        // TODO(benjaminwagner): Other checks required?
+        return true
+}
+
+// ctfeGetTasksJSON tests that the response contains valid JSON and satisfies
+// ctfeGetTasksJSONObject.
+func ctfeGetTasksJSON(r io.Reader) bool {
+        return ctfeGetTasksJSONObject(decodeJSONObject(r))
+}
+
+// ctfeGetTasksNonEmptyJSON tests the same as ctfeGetTasksJSON and also checks that there is at
+// least one task present.
+func ctfeGetTasksNonEmptyJSON(r io.Reader) bool {
+        obj := decodeJSONObject(r)
+        if !ctfeGetTasksJSONObject(obj) {
+                return false
+        }
+        data := obj["data"].([]interface{})
+        if len(data) < 1 {
+                return false
+        }
+        return true
+}
+
+// ctfeRevDataJSON tests that the response contains valid JSON with the keys expected by
+// ct/res/imp/chromium-builds-sk.html.
+func ctfeRevDataJSON(r io.Reader) bool {
+        return hasKeys(decodeJSONObject(r), []string{"commit", "author", "committer"})
+}
+
 // monitorIssueTracker reads the counts for all the types of issues in the skia
 // issue tracker (code.google.com/p/skia) and stuffs the counts into Graphite.
 func monitorIssueTracker() {
         c := &http.Client{
                 Transport: &http.Transport{
                         Dial: dialTimeout,
                 },
         }
 
         if *useMetadata {
@@ skipping 130 matching lines @@
                 Transport: &http.Transport{
                         Dial: dialTimeout,
                 },
         }
         probeOneRound(cfg, c)
         for _ = range time.Tick(*runEvery) {
                 probeOneRound(cfg, c)
                 liveness.Update()
         }
 }