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.")
@@ skipping 104 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()
-        if err != nil {
-                util.ReportError(w, r, err, fmt.Sprintf("Failed to read branch information from the repo: %s", err))
+        q := r.URL.Query()
+        // Case 1: Requesting specific commit range by index.
+        if start, ok := q["start"]; ok {
+                startInt, err := strconv.ParseInt(start[0], 10, 32)
+                if err != nil {
+                        util.ReportError(w, r, err, fmt.Sprintf("Invalid value for parameter 'start' (%s): %v", start, err))
+                        return
+                }
+                startIdx := int(startInt)
+                endIdx := commitCache.NumCommits()
+                if end, ok := q["end"]; ok {

[jcgregorio, 2014/12/09 16:30:05]

This seems like a repeated pattern:

 if end, ok := q["end"]; ok {
			endInt, err := strconv.ParseInt(end[0], 10, 32)
			if err != nil {
				util.ReportError(w, r, err, fmt.Sprintf("Invalid value for parameter 'end'
(%s): %v", end, err))
				return
			}
			endIdx = int(endInt)
		}

Maybe break it out into a func?

[borenet, 2014/12/09 20:17:12]

Done.

+                        endInt, err := strconv.ParseInt(end[0], 10, 32)
+                        if err != nil {
+                                util.ReportError(w, r, err, fmt.Sprintf("Invalid value for parameter 'end' (%s): %v", end, err))
+                                return
+                        }
+                        endIdx = int(endInt)
+                }
+                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
         }
-        commits := make([]*gitinfo.LongCommit, len(commitHashes))
-        for i, h := range commitHashes {
-                c, err := gitInfo.Details(h)
+        // Case 2: Requesting N (or the default number) commits.
+        commitsToLoad := DEFAULT_COMMITS_TO_LOAD
+        if n, ok := q["n"]; ok {
+                intN, err := strconv.ParseInt(n[0], 10, 32)
                 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 value for parameter 'n' (%s): %v", n, err))
                         return
                 }
-                commits[i] = c
+                commitsToLoad = int(intN)
         }
-        data := struct {
-                Commits     []*gitinfo.LongCommit `json:"commits"`
-                BranchHeads []*gitinfo.GitBranch  `json:"branch_heads"`
-        }{
-                Commits:     commits,
-                BranchHeads: branchHeads,
-        }
-        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 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)
 }