Ignore traces

golden/go/skiacorrectness/main.go

 package main
 
 import (
         "encoding/json"
         "flag"
         "fmt"
         "html/template"
         "io/ioutil"
         "net/http"
         "os"
@@ skipping 52 matching lines @@
 )
 
 // ResponseEnvelope wraps all responses. Some fields might be empty depending
 // on context or whether there was an error or not.
 type ResponseEnvelope struct {
         Data   *interface{} `json:"data"`
         Err    *string      `json:"err"`
         Status int          `json:"status"`
 }
 
-var analyzer *analysis.Analyzer = nil
+var (
+        analyzer    *analysis.Analyzer = nil
+        ignoreStore types.IgnoreStore
+)
 
 // *****************************************************************************
 // *****************************************************************************
 // New polymer based UI code begin.
 // *****************************************************************************
 // *****************************************************************************
 
 // polyMainHandler is the main page for the Polymer based frontend.
 func polyMainHandler(w http.ResponseWriter, r *http.Request) {
         glog.Infof("Poly Main Handler: %q\n", r.URL.Path)
@@ skipping 44 matching lines @@
                 util.ReportError(w, r, err, "Failed to load test information")
                 return
         }
         w.Header().Set("Content-Type", "application/json")
         enc := json.NewEncoder(w)
         if err := enc.Encode(res); err != nil {
                 util.ReportError(w, r, err, "Failed to encode result")
         }
 }
 
-// IgnoreRule is the GUI struct for dealing with Ignore rules.
-type IgnoreRule struct {
-        ID      string    `json:"id"`
-        Name    string    `json:"name"`
-        Expires time.Time `json:"expires"`
-        Query   string    `json:"query"`
-        Note    string    `json:"note"`
-        Count   int       `json:"count"`
-}
-
-// ignores is an in memory database of ignore rules.
-//
-// TODO replace with a database.
-var ignores = []*IgnoreRule{
-        &IgnoreRule{
-                ID:      "1",
-                Name:    "jcgregorio@google.com",
-                Expires: time.Now().Add(time.Hour),
-                Query:   "config=gpu",
-                Note:    "Because",
-                Count:   354,
-        },
-        &IgnoreRule{
-                ID:      "2",
-                Name:    "jcgregorio@google.com",
-                Expires: time.Now().Add(2 * time.Hour * 24),
-                Query:   "arch=x86&bench_type=playback&config=8888&extra_config=GDI&os=Android",
-                Note:    "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod",
-                Count:   12,
-        },
-}
-
-// deleteIgnoreRule deletes an Ignore rule.
-//
-// TODO replace with database action.
-func deleteIgnoreRule(id string) {
-        for i, r := range ignores {
-                if r.ID == id {
-                        ignores = append(ignores[:i], ignores[i+1:]...)
-                        break
-                }
-        }
-}
-
-// addIgnoreRule adds the IgnoreRule to the database.
-//
-// TODO replace with database action.
-func addIgnoreRule(ig *IgnoreRule) {
-        ignores = append(ignores, ig)
-}
-
 // polyIgnoresJSONHandler returns the current ignore rules in JSON format.
 func polyIgnoresJSONHandler(w http.ResponseWriter, r *http.Request) {
         w.Header().Set("Content-Type", "application/json")
+        ignores, err := analyzer.ListIgnoreRules()
+        if err != nil {
+                util.ReportError(w, r, err, "Failed to retrieve ignored traces.")
+        }
+
+        // TODO(stephana): Wrap in response envelope if it makes sense !
         enc := json.NewEncoder(w)
         if err := enc.Encode(ignores); err != nil {
                 util.ReportError(w, r, err, "Failed to encode result")
         }
 }
 
 func polyIgnoresDeleteHandler(w http.ResponseWriter, r *http.Request) {
         user := login.LoggedInAs(r)
         if user == "" {
                 util.ReportError(w, r, fmt.Errorf("Not logged in."), "You must be logged in to add an ignore rule.")
                 return
         }
-        id := mux.Vars(r)["id"]
-        deleteIgnoreRule(id)
-        w.Header().Set("Content-Type", "application/json")
-        enc := json.NewEncoder(w)
-        if err := enc.Encode(ignores); err != nil {
-                util.ReportError(w, r, err, "Failed to encode result")
+        id, err := strconv.ParseInt(mux.Vars(r)["id"], 10, 0)
+        if err != nil {
+                util.ReportError(w, r, err, "ID must be valid integer.")
+                return
+        }
+
+        if err := analyzer.DeleteIgnoreRule(int(id), user); err != nil {
+                util.ReportError(w, r, err, "Unable to delete ignore rule.")
+        } else {
+                // If delete worked just list the current ignores and return them.
+                polyIgnoresJSONHandler(w, r)
         }
 }
 
-type IngoresAddRequest struct {
+type IgnoresAddRequest struct {
         Duration string `json:"duration"`
         Filter   string `json:"filter"`
         Note     string `json:"note"`
 }
 
 var durationRe = regexp.MustCompile("([0-9]+)([smhdw])")
 
 // polyIgnoresAddHandler is for adding a new ignore rule.
 func polyIgnoresAddHandler(w http.ResponseWriter, r *http.Request) {
         user := login.LoggedInAs(r)
         if user == "" {
                 util.ReportError(w, r, fmt.Errorf("Not logged in."), "You must be logged in to add an ignore rule.")
                 return
         }
-        req := &IngoresAddRequest{}
+        req := &IgnoresAddRequest{}
         if err := parseJson(r, req); err != nil {
-                util.ReportError(w, r, err, "Failed to decode result")
+                util.ReportError(w, r, err, "Failed to parse submitted data.")
                 return
         }
         parsed := durationRe.FindStringSubmatch(req.Duration)
         if len(parsed) != 3 {
                 util.ReportError(w, r, fmt.Errorf("Rejected duration: %s", req.Duration), "Failed to parse duration")
                 return
         }
         // TODO break out the following into its own func, add tests.
         n, err := strconv.ParseInt(parsed[1], 10, 32)
         if err != nil {
                 util.ReportError(w, r, err, "Failed to parse duration")
                 return
         }
         d := time.Second
         switch parsed[2][0] {
         case 's':
                 d = time.Duration(n) * time.Second
         case 'm':
                 d = time.Duration(n) * time.Minute
         case 'h':
                 d = time.Duration(n) * time.Hour
         case 'd':
                 d = time.Duration(n) * 24 * time.Hour
         case 'w':
                 d = time.Duration(n) * 7 * 24 * time.Hour
         }
-        ig := &IgnoreRule{
-                ID:      "foo",
-                Name:    user,
-                Expires: time.Now().Add(d),
-                Query:   req.Filter,
-                Note:    req.Note,
+        ignoreRule := types.NewIgnoreRule(user, time.Now().Add(d), req.Filter, req.Note)
+        if err != nil {
+                util.ReportError(w, r, err, "Failed to create ignore rule.")
+                return
         }
-        addIgnoreRule(ig)
-        w.Header().Set("Content-Type", "application/json")
-        enc := json.NewEncoder(w)
-        if err := enc.Encode(ignores); err != nil {
-                util.ReportError(w, r, err, "Failed to encode result")
+
+        if err := analyzer.AddIgnoreRule(ignoreRule); err != nil {
+                util.ReportError(w, r, err, "Failed to create ignore rule.")
+                return
         }
+
+        polyIgnoresJSONHandler(w, r)
 }
 
 // polyIgnoresHandler is for setting up ignores rules.
 func polyIgnoresHandler(w http.ResponseWriter, r *http.Request) {
         glog.Infof("Poly Ignores Handler: %q\n", r.URL.Path)
         w.Header().Set("Content-Type", "text/html")
         if *local {
                 loadTemplates()
         }
         if err := ignoresTemplate.Execute(w, struct{}{}); err != nil {
@@ skipping 267 matching lines @@
         diffStore, err := filediffstore.NewFileDiffStore(client, *imageDir, *gsBucketName, filediffstore.DEFAULT_GS_IMG_DIR_NAME, cacheFactory, filediffstore.RECOMMENDED_WORKER_POOL_SIZE)
         if err != nil {
                 glog.Fatalf("Allocating DiffStore failed: %s", err)
         }
         conf, err := database.ConfigFromFlagsAndMetadata(*local, db.MigrationSteps())
         if err != nil {
                 glog.Fatal(err)
         }
         vdb := database.NewVersionedDB(conf)
         expStore := expstorage.NewCachingExpectationStore(expstorage.NewSQLExpectationStore(vdb))
+        ignoreStore = types.NewSQLIgnoreStore(vdb)
         tileStore := filetilestore.NewFileTileStore(*tileStoreDir, "golden", -1)
 
         // Initialize the Analyzer
         imgFS := NewURLAwareFileServer(*imageDir, IMAGE_URL_PREFIX)
-        analyzer = analysis.NewAnalyzer(expStore, tileStore, diffStore, imgFS.GetURL, 10*time.Minute)
+        analyzer = analysis.NewAnalyzer(expStore, tileStore, diffStore, ignoreStore, imgFS.GetURL, 10*time.Minute)
 
         router := mux.NewRouter()
 
         // Wire up the resources. We use the 'rest' prefix to avoid any name
         // clashes witht the static files being served.
         router.HandleFunc("/rest/counts", autogzip.HandleFunc(tileCountsHandler)).Methods("GET")
         router.HandleFunc("/rest/triage", autogzip.HandleFunc(listTestDetailsHandler)).Methods("GET")
         router.HandleFunc("/rest/triage/{testname}", autogzip.HandleFunc(testDetailsHandler)).Methods("GET")
         router.HandleFunc("/rest/triage", autogzip.HandleFunc(triageDigestsHandler)).Methods("POST")
         router.HandleFunc("/rest/status", autogzip.HandleFunc(statusHandler)).Methods("GET")
@@ skipping 24 matching lines @@
         // Everything else is served out of the static directory.
         router.PathPrefix("/").Handler(http.FileServer(http.Dir(*staticDir)))
 
         // Send all requests to the router
         http.Handle("/", router)
 
         // Start the server
         glog.Infoln("Serving on http://127.0.0.1" + *port)
         glog.Fatal(http.ListenAndServe(*port, nil))
 }