Improvements to commits page

monitoring/go/alertserver/main.go

 /*
         Provides roll-up statuses and alerting for Skia build/test/perf.
 */
 
 package main
 
 import (
         "encoding/json"
         "flag"
         "fmt"
         "io/ioutil"
         "net/http"
         "os"
         "os/user"
         "path/filepath"
         "runtime"
+        "strconv"
         "strings"
         "time"
 )
 
 import (
         "github.com/fiorix/go-web/autogzip"
         "github.com/golang/glog"
         "github.com/influxdb/influxdb/client"
 )
 
 import (
         "skia.googlesource.com/buildbot.git/go/common"
         "skia.googlesource.com/buildbot.git/go/email"
         "skia.googlesource.com/buildbot.git/go/gitinfo"
         "skia.googlesource.com/buildbot.git/go/login"
         "skia.googlesource.com/buildbot.git/go/metadata"
         "skia.googlesource.com/buildbot.git/go/skiaversion"
         "skia.googlesource.com/buildbot.git/go/util"
         "skia.googlesource.com/buildbot.git/monitoring/go/alerting"
+        "skia.googlesource.com/buildbot.git/monitoring/go/commit_cache"
 )
 
 const (
         COOKIESALT_METADATA_KEY          = "cookiesalt"
         CLIENT_ID_METADATA_KEY           = "client_id"
         CLIENT_SECRET_METADATA_KEY       = "client_secret"
+        DEFAULT_COMMITS_TO_LOAD          = 35
         INFLUXDB_NAME_METADATA_KEY       = "influxdb_name"
         INFLUXDB_PASSWORD_METADATA_KEY   = "influxdb_password"
         GMAIL_CLIENT_ID_METADATA_KEY     = "gmail_clientid"
         GMAIL_CLIENT_SECRET_METADATA_KEY = "gmail_clientsecret"
         GMAIL_CACHED_TOKEN_METADATA_KEY  = "gmail_cached_token"
         GMAIL_TOKEN_CACHE_FILE           = "google_email_token.data"
 )
 
 var (
-        alertManager *alerting.AlertManager = nil
-        gitInfo      *gitinfo.GitInfo       = nil
+        alertManager *alerting.AlertManager    = nil
+        gitInfo      *gitinfo.GitInfo          = nil
+        commitCache  *commit_cache.CommitCache = nil
 )
 
 // flags
 var (
         graphiteServer        = flag.String("graphite_server", "localhost:2003", "Where is Graphite metrics ingestion server running.")
         host                  = flag.String("host", "localhost", "HTTP service host")
         port                  = flag.String("port", ":8001", "HTTP service port (e.g., ':8001')")
         useMetadata           = flag.Bool("use_metadata", true, "Load sensitive values from metadata not from flags.")
         influxDbHost          = flag.String("influxdb_host", "localhost:8086", "The InfluxDB hostname.")
         influxDbName          = flag.String("influxdb_name", "root", "The InfluxDB username.")
         influxDbPassword      = flag.String("influxdb_password", "root", "The InfluxDB password.")
         influxDbDatabase      = flag.String("influxdb_database", "", "The InfluxDB database.")
         emailClientIdFlag     = flag.String("email_clientid", "", "OAuth Client ID for sending email.")
         emailClientSecretFlag = flag.String("email_clientsecret", "", "OAuth Client Secret for sending email.")
         alertPollInterval     = flag.String("alert_poll_interval", "1s", "How often to check for new alerts.")
         alertsFile            = flag.String("alerts_file", "alerts.cfg", "Config file containing alert rules.")
         testing               = flag.Bool("testing", false, "Set to true for locally testing rules. No email will be sent.")
         workdir               = flag.String("workdir", ".", "Directory to use for scratch work.")
 )
 
 func userHasEditRights(email string) bool {
         if strings.HasSuffix(email, "@google.com") {
                 return true
         }
         return false
 }
 
+func getIntParam(name string, r *http.Request) (*int, error) {
+        raw, ok := r.URL.Query()[name]
+        if !ok {
+                return nil, nil
+        }
+        v64, err := strconv.ParseInt(raw[0], 10, 32)
+        if err != nil {
+                return nil, fmt.Errorf("Invalid value for parameter %q: %s -- %v", name, raw, err)
+        }
+        v32 := int(v64)
+        return &v32, nil
+}
+
 func alertJsonHandler(w http.ResponseWriter, r *http.Request) {
         w.Header().Set("Content-Type", "application/json")
         type displayAlert struct {
                 Id           string `json:"id"`
                 Name         string `json:"name"`
                 Query        string `json:"query"`
                 Condition    string `json:"condition"`
                 Message      string `json:"message"`
                 Active       bool   `json:"active"`
                 Snoozed      bool   `json:"snoozed"`
@@ skipping 77 matching lines @@
 func makeResourceHandler() func(http.ResponseWriter, *http.Request) {
         fileServer := http.FileServer(http.Dir("./"))
         return func(w http.ResponseWriter, r *http.Request) {
                 w.Header().Add("Cache-Control", string(300))
                 fileServer.ServeHTTP(w, r)
         }
 }
 
 func commitsJsonHandler(w http.ResponseWriter, r *http.Request) {
         w.Header().Set("Content-Type", "application/json")
-        gitInfo.Update(true, true)
-        commitHashes := gitInfo.From(time.Now().AddDate(0, 0, -45))
-        branchHeads, err := gitInfo.GetBranches()
+        // Case 1: Requesting specific commit range by index.
+        startIdx, err := getIntParam("start", r)
         if err != nil {
-                util.ReportError(w, r, err, fmt.Sprintf("Failed to read branch information from the repo: %s", err))
+                util.ReportError(w, r, err, fmt.Sprintf("Invalid parameter: %v", err))
                 return
         }
-        commits := make([]*gitinfo.LongCommit, len(commitHashes))
-        for i, h := range commitHashes {
-                c, err := gitInfo.Details(h)
+        if startIdx != nil {
+                endIdx := commitCache.NumCommits()
+                end, err := getIntParam("end", r)
                 if err != nil {
-                        util.ReportError(w, r, err, fmt.Sprintf("Failed to obtain commit details for %s: %s", h, err))
+                        util.ReportError(w, r, err, fmt.Sprintf("Invalid parameter: %v", err))
                         return
                 }
-                commits[i] = c
+                if end != nil {
+                        endIdx = *end
+                }
+                if err := commitCache.RangeAsJson(w, *startIdx, endIdx); err != nil {
+                        util.ReportError(w, r, err, fmt.Sprintf("Failed to load commit range from cache: %v", err))
+                        return
+                }
+                return
         }
-        data := struct {
-                Commits     []*gitinfo.LongCommit `json:"commits"`
-                BranchHeads []*gitinfo.GitBranch  `json:"branch_heads"`
-        }{
-                Commits:     commits,
-                BranchHeads: branchHeads,
+        // Case 2: Requesting N (or the default number) commits.
+        commitsToLoad := DEFAULT_COMMITS_TO_LOAD
+        n, err := getIntParam("n", r)
+        if err != nil {
+                util.ReportError(w, r, err, fmt.Sprintf("Invalid parameter: %v", err))
+                return
         }
-        if err := json.NewEncoder(w).Encode(data); err != nil {
-                util.ReportError(w, r, err, fmt.Sprintf("Failed to encode commit data as JSON: %s", err))
+        if n != nil {
+                commitsToLoad = *n
+        }
+        if err := commitCache.LastNAsJson(w, commitsToLoad); err != nil {
+                util.ReportError(w, r, err, fmt.Sprintf("Failed to load commits from cache: %v", err))
                 return
         }
 }
 
 func commitsHandler(w http.ResponseWriter, r *http.Request) {
         http.ServeFile(w, r, "res/html/commits.html")
 }
 
 func runServer(serverURL string) {
         _, filename, _, _ := runtime.Caller(0)
@@ skipping 81 matching lines @@
         }
         alertManager, err = alerting.NewAlertManager(dbClient, *alertsFile, parsedPollInterval, emailAuth, *testing)
         if err != nil {
                 glog.Fatalf("Failed to create AlertManager: %v", err)
         }
 
         gitInfo, err = gitinfo.CloneOrUpdate("https://skia.googlesource.com/skia.git", *workdir, true)
         if err != nil {
                 glog.Fatalf("Failed to check out Skia: %v", err)
         }
+        commitCache, err = commit_cache.New(gitInfo)
+        if err != nil {
+                glog.Fatalf("Failed to create commit cache: %v", err)
+        }
+        go func() {
+                for _ = range time.Tick(time.Minute) {
+                        if err := commitCache.Update(); err != nil {
+                                glog.Errorf("Failed to update commit cache: %v", err)
+                        }
+                }
+        }()
         runServer(serverURL)
 }