code review 5461047: misc/dashboard: user interface

misc/dashboard/app/build/build.go

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package build
 
 import (
         "appengine"
         "appengine/datastore"
         "bytes"
         "compress/gzip"
         "crypto/sha1"
         "fmt"
         "http"
         "io"
         "json"
         "os"
-        "sort"
         "strings"
-        "template"
 )
 
 const commitsPerPage = 20
 
 // A Package describes a package that is listed on the dashboard.
 type Package struct {
         Name    string
         Path    string // (empty for the main Go tree)
         NextNum int    // Num of the next head Commit
 }
 
+func (p *Package) String() string {
+        return fmt.Sprintf("%s: %q", p.Path, p.Name)
+}
+
 func (p *Package) Key(c appengine.Context) *datastore.Key {
         key := p.Path
         if key == "" {
                 key = "go"
         }
         return datastore.NewKey(c, "Package", key, 0, nil)
 }
 
+// LastCommit returns the most recent Commit for this Package.
+func (p *Package) LastCommit(c appengine.Context) (*Commit, os.Error) {
+        var commits []*Commit
+        _, err := datastore.NewQuery("Commit").
+                Ancestor(p.Key(c)).
+                Order("-Time").
+                Limit(1).
+                GetAll(c, &commits)
+        if err != nil {
+                return nil, err
+        }
+        if len(commits) != 1 {
+                return nil, datastore.ErrNoSuchEntity
+        }
+        return commits[0], nil
+}
+
+// GetPackage fetches a Package by path from the datastore.
 func GetPackage(c appengine.Context, path string) (*Package, os.Error) {
         p := &Package{Path: path}
         err := datastore.Get(c, p.Key(c), p)
         if err == datastore.ErrNoSuchEntity {
                 return nil, fmt.Errorf("package %q not found", path)
         }
         return p, err
 }
 
 // A Commit describes an individual commit in a package.
 //
 // Each Commit entity is a descendant of its associated Package entity.
 // In other words, all Commits with the same PackagePath belong to the same
 // datastore entity group.
 type Commit struct {
         PackagePath string // (empty for Go commits)
         Hash        string
         ParentHash  string
         Num         int // Internal monotonic counter unique to this package.
 
         User string
         Desc string `datastore:",noindex"`
         Time datastore.Time
 
-        // Result is the Data string of each build Result for this Commit.
+        // ResultData is the Data string of each build Result for this Commit.
         // For non-Go commits, only the Results for the current Go tip, weekly,
         // and release Tags are stored here. This is purely de-normalized data.
         // The complete data set is stored in Result entities.
-        Result []string `datastore:",noindex"`
+        ResultData []string `datastore:",noindex"`
 }
 
 func (com *Commit) Key(c appengine.Context) *datastore.Key {
         if com.Hash == "" {
                 panic("tried Key on Commit with empty Hash")
         }
         p := Package{Path: com.PackagePath}
         key := com.PackagePath + "|" + com.Hash
         return datastore.NewKey(c, "Commit", key, 0, p.Key(c))
 }
 
 func (c *Commit) Valid() os.Error {
         if !validHash(c.Hash) {
                 return os.NewError("invalid Hash")
         }
         if c.ParentHash != "" && !validHash(c.ParentHash) { // empty is OK
                 return os.NewError("invalid ParentHash")
         }
         return nil
 }
 
 // AddResult adds the denormalized Reuslt data to the Commit's Result field.
 // It must be called from inside a datastore transaction.
 func (com *Commit) AddResult(c appengine.Context, r *Result) os.Error {
         if err := datastore.Get(c, com.Key(c), com); err != nil {
                 return err
         }
-        com.Result = append(com.Result, r.Data())
+        com.ResultData = append(com.ResultData, r.Data())
         _, err := datastore.Put(c, com.Key(c), com)
         return err
 }
 
-func (c *Commit) GetResult(builder, goHash string) *Result {
-        for _, r := range c.Result {
+// Result returns the build Result for this Commit for the given builder/goHash.
+func (c *Commit) Result(builder, goHash string) *Result {
+        for _, r := range c.ResultData {
                 p := strings.SplitN(r, "|", 4)
                 if len(p) != 4 || p[0] != builder || p[3] != goHash {
                         continue
                 }
-                return &Result{
-                        Builder:     p[0],
-                        Hash:        c.Hash,
-                        PackagePath: c.PackagePath,
-                        GoHash:      p[3],
-                        OK:          p[1] == "true",
-                        LogHash:     p[2],
-                }
+                return partsToHash(c, p)
         }
         return nil
+}
+
+// Results returns the build Results for this Commit for the given goHash.
+func (c *Commit) Results(goHash string) (results []*Result) {
+        for _, r := range c.ResultData {
+                p := strings.SplitN(r, "|", 4)
+                if len(p) != 4 || p[3] != goHash {
+                        continue
+                }
+                results = append(results, partsToHash(c, p))
+        }
+        return
+}
+
+// partsToHash converts a Commit and ResultData substrings to a Result.
+func partsToHash(c *Commit, p []string) *Result {
+        return &Result{
+                Builder:     p[0],
+                Hash:        c.Hash,
+                PackagePath: c.PackagePath,
+                GoHash:      p[3],
+                OK:          p[1] == "true",
+                LogHash:     p[2],
+        }
 }
 
 // A Result describes a build result for a Commit on an OS/architecture.
 //
 // Each Result entity is a descendant of its associated Commit entity.
 type Result struct {
         Builder     string // "arch-os[-note]"
         Hash        string
         PackagePath string // (empty for Go commits)
 
         // The Go Commit this was built against (empty for Go commits).
         GoHash string
 
         OK      bool
         Log     []byte `datastore:"-"`        // for JSON unmarshaling
         LogHash string `datastore:",noindex"` // Key to the Log record.
 }
 
 func (r *Result) Key(c appengine.Context) *datastore.Key {
         p := Package{Path: r.PackagePath}
         key := r.Builder + "|" + r.PackagePath + "|" + r.Hash + "|" + r.GoHash
         return datastore.NewKey(c, "Result", key, 0, p.Key(c))
 }
 
-func (r *Result) Data() string {
-        return fmt.Sprintf("%v|%v|%v|%v", r.Builder, r.OK, r.LogHash, r.GoHash)
-}
-
 func (r *Result) Valid() os.Error {
         if !validHash(r.Hash) {
                 return os.NewError("invalid Hash")
         }
         if r.PackagePath != "" && !validHash(r.GoHash) {
                 return os.NewError("invalid GoHash")
         }
         return nil
+}
+
+// Data returns the Result in string format
+// to be stored in Commit's ResultData field.
+func (r *Result) Data() string {
+        return fmt.Sprintf("%v|%v|%v|%v", r.Builder, r.OK, r.LogHash, r.GoHash)
 }
 
 // A Log is a gzip-compressed log file stored under the SHA1 hash of the
 // uncompressed log text.
 type Log struct {
         CompressedLog []byte
 }
 
 func PutLog(c appengine.Context, text []byte) (hash string, err os.Error) {
         h := sha1.New()
@@ skipping 15 matching lines @@
         Name string // the tag itself (for example: "release.r60")
         Hash string
 }
 
 func (t *Tag) Key(c appengine.Context) *datastore.Key {
         p := &Package{}
         return datastore.NewKey(c, "Tag", t.Kind, 0, p.Key(c))
 }
 
 func (t *Tag) Valid() os.Error {
-        if t.Kind != "weekly" || t.Kind != "release" || t.Kind != "tip" {
+        if t.Kind != "weekly" && t.Kind != "release" && t.Kind != "tip" {
                 return os.NewError("invalid Kind")
         }
         if !validHash(t.Hash) {
                 return os.NewError("invalid Hash")
         }
         return nil
+}
+
+// GetTag fetches a Tag by name from the datastore.
+func GetTag(c appengine.Context, tag string) (*Tag, os.Error) {
+        t := &Tag{Kind: tag}
+        if err := datastore.Get(c, t.Key(c), t); err != nil {
+                if err == datastore.ErrNoSuchEntity {
+                        return nil, os.NewError("tag not found: " + tag)
+                }
+                return nil, err
+        }
+        if err := t.Valid(); err != nil {
+                return nil, err
+        }
+        return t, nil
 }
 
 // commitHandler retrieves commit data or records a new commit.
 //
 // For GET requests it returns a Commit value for the specified
 // packagePath and hash.
 //
 // For POST requests it reads a JSON-encoded Commit value from the request
 // body and creates a new Commit entity. It also updates the "tip" Tag for
 // each new commit at tip.
@@ skipping 121 matching lines @@
                 Order("-Num").
                 Run(c)
         for {
                 com := new(Commit)
                 if _, err := t.Next(com); err != nil {
                         if err == datastore.Done {
                                 err = nil
                         }
                         return nil, err
                 }
-                if com.GetResult(builder, goHash) == nil {
+                if com.Result(builder, goHash) == nil {
                         return com.Hash, nil
                 }
         }
         panic("unreachable")
 }
 
 // packagesHandler returns a list of the non-Go Packages monitored
 // by the dashboard.
 func packagesHandler(r *http.Request) (interface{}, os.Error) {
-        c := appengine.NewContext(r)
+        return Packages(appengine.NewContext(r))
+}
+
+// Packages returns all non-Go packages.
+func Packages(c appengine.Context) ([]*Package, os.Error) {
         var pkgs []*Package
         for t := datastore.NewQuery("Package").Run(c); ; {
                 pkg := new(Package)
                 if _, err := t.Next(pkg); err == datastore.Done {
                         break
                 } else if err != nil {
                         return nil, err
                 }
                 if pkg.Path != "" {
                         pkgs = append(pkgs, pkg)
@@ skipping 38 matching lines @@
                 if _, err := datastore.Put(c, res.Key(c), res); err != nil {
                         return err
                 }
                 // add Result to Commit
                 com := &Commit{PackagePath: res.PackagePath, Hash: res.Hash}
                 return com.AddResult(c, res)
         }
         return nil, datastore.RunInTransaction(c, tx, nil)
 }
 
+// logHandler displays log text for a given hash.
+// It handles paths like "/log/hash".
 func logHandler(w http.ResponseWriter, r *http.Request) {
         c := appengine.NewContext(r)
         h := r.URL.Path[len("/log/"):]
         k := datastore.NewKey(c, "Log", h, 0, nil)
         l := new(Log)
         if err := datastore.Get(c, k, l); err != nil {
                 logErr(w, r, err)
                 return
         }
         d, err := gzip.NewReader(bytes.NewBuffer(l.CompressedLog))
         if err != nil {
                 logErr(w, r, err)
                 return
         }
         if _, err := io.Copy(w, d); err != nil {
                 logErr(w, r, err)
         }
 }
 
-var uiTemplate = template.Must(template.ParseFile("build/ui.html"))
-
-func uiHandler(w http.ResponseWriter, r *http.Request) {
-        c := appengine.NewContext(r)
-
-        p := &Package{}
-        q := datastore.NewQuery("Commit").
-                Ancestor(p.Key(c)).
-                Order("-Time").
-                Limit(commitsPerPage)
-        var commits []*Commit
-        if _, err := q.GetAll(c, &commits); err != nil {
-                logErr(w, r, err)
-                return
-        }
-
-        builders := make(map[string]bool)
-        for _, commit := range commits {
-                for _, r := range commit.Result {
-                        p := strings.SplitN(r, "|", 4)
-                        if len(p) != 4 {
-                                continue
-                        }
-                        builders[p[0]] = true
-                }
-        }
-
-        c.Infof("\ncommits: %v\nq: %v\nkey: %v", commits, q, p.Key(c))
-
-        err := uiTemplate.Execute(w, struct {
-                Commits  []*Commit
-                Builders []string
-        }{
-                commits,
-                keys(builders),
-        })
-        if err != nil {
-                logErr(w, r, err)
-        }
-}
-
-func keys(m map[string]bool) (s []string) {
-        for k := range m {
-                s = append(s, k)
-        }
-        sort.Strings(s)
-        return
-}
-
-type errBadMethod string
-
-func (e errBadMethod) String() string {
-        return "bad method: " + string(e)
-}
-
 type dashHandler func(*http.Request) (interface{}, os.Error)
 
 type dashResponse struct {
         Response interface{}
         Error    string
+}
+
+// errBadMethod is returned by a dashHandler when
+// the request has an unsuitable method.
+type errBadMethod string
+
+func (e errBadMethod) String() string {
+        return "bad method: " + string(e)
 }
 
 // AuthHandler wraps a http.HandlerFunc with a handler that validates the
 // supplied key and builder query parameters.
 func AuthHandler(h dashHandler) http.HandlerFunc {
         return func(w http.ResponseWriter, r *http.Request) {
                 // Put the URL Query values into r.Form to avoid parsing the
                 // request body when calling r.FormValue.
                 r.Form = r.URL.Query()
 
@@ skipping 46 matching lines @@
         http.HandleFunc("/init", initHandler)
 
         // authenticated handlers
         http.HandleFunc("/commit", AuthHandler(commitHandler))
         http.HandleFunc("/packages", AuthHandler(packagesHandler))
         http.HandleFunc("/result", AuthHandler(resultHandler))
         http.HandleFunc("/tag", AuthHandler(tagHandler))
         http.HandleFunc("/todo", AuthHandler(todoHandler))
 
         // public handlers
-        http.HandleFunc("/", uiHandler)
         http.HandleFunc("/log/", logHandler)
 }
 
 func validHash(hash string) bool {
         // TODO(adg): correctly validate a hash
         return hash != ""
 }
 
 func logErr(w http.ResponseWriter, r *http.Request, err os.Error) {
         appengine.NewContext(r).Errorf("Error: %v", err)
         w.WriteHeader(http.StatusInternalServerError)
         fmt.Fprint(w, "Error: ", err)
 }