Add git revision info to the titlebar

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
         "encoding/json"
         "flag"
         "fmt"
@@ skipping 80 matching lines @@
                 "waterfall", "river", "breeze", "moon", "rain", "wind", "sea", "morning",
                 "snow", "lake", "sunset", "pine", "shadow", "leaf", "dawn", "glitter",
                 "forest", "hill", "cloud", "meadow", "sun", "glade", "bird", "brook",
                 "butterfly", "bush", "dew", "dust", "field", "fire", "flower", "firefly",
                 "feather", "grass", "haze", "mountain", "night", "pond", "darkness",
                 "snowflake", "silence", "sound", "sky", "shape", "surf", "thunder",
                 "violet", "water", "wildflower", "wave", "water", "resonance", "sun",
                 "wood", "dream", "cherry", "tree", "fog", "frost", "voice", "paper",
                 "frog", "smoke", "star",
         }
+
+        gitHash = ""
+        gitInfo = ""
 )
 
 // flags
 var (
         useChroot = flag.Bool("use_chroot", false, "Run the compiled code in the schroot jail.")
         port      = flag.String("port", ":8000", "HTTP service address (e.g., ':8000')")
 )
 
 // lineNumbers adds #line numbering to the user's code.
 func LineNumbers(c string) string {
@@ skipping 45 matching lines @@
         }
         workspaceTemplate, err = htemplate.ParseFiles(
                 filepath.Join(cwd, "templates/workspace.html"),
                 filepath.Join(cwd, "templates/titlebar.html"),
                 filepath.Join(cwd, "templates/content.html"),
         )
         if err != nil {
                 panic(err)
         }
 
+        // The git command returns output of the format:
+        //
+        //   f672cead70404080a991ebfb86c38316a4589b23 2014-04-27 19:21:51 +0000
+        //
+        logOutput, err := doCmd(`git log --format=%H%x20%ai HEAD^..HEAD`, true)
+        if err != nil {
+                panic(err)
+        }
+        logInfo := strings.Split(logOutput, " ")
+        gitHash = logInfo[0]
+        gitInfo = logInfo[1] + " " + logInfo[2] + " " + logInfo[0][0:6]
+
         // Connect to MySQL server. First, get the password from the metadata server.
         // See https://developers.google.com/compute/docs/metadata#custom.
         req, err := http.NewRequest("GET", "http://metadata/computeMetadata/v1/instance/attributes/password", nil)
         if err != nil {
                 panic(err)
         }
         client := http.Client{}
         req.Header.Add("X-Google-Metadata-Request", "True")
         if resp, err := client.Do(req); err == nil {
                 password, err := ioutil.ReadAll(resp.Body)
@@ skipping 38 matching lines @@
           hash      CHAR(64)  DEFAULT ''                 NOT NULL,
           hidden    INTEGER   DEFAULT 0                  NOT NULL,
 
           FOREIGN KEY (name) REFERENCES workspace(name)
         )`
                 _, err = db.Exec(sql)
                 log.Printf("Info: status creating sqlite table for workspace try: %q\n", err)
         }
 }
 
+// Titlebar is used in titlebar template expansion.
+type Titlebar struct {
+        GitHash string
+        GitInfo string
+}
+
 // userCode is used in template expansion.
 type userCode struct {
-        Code string
-        Hash string
+        Code     string
+        Hash     string
+        Titlebar Titlebar
 }
 
 // expandToFile expands the template and writes the result to the file.
 func expandToFile(filename string, code string, t *template.Template) error {
         f, err := os.Create(filename)
         if err != nil {
                 return err
         }
         defer f.Close()
-        return t.Execute(f, userCode{Code: code})
+        return t.Execute(f, userCode{Code: code, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}})
 }
 
 // expandCode expands the template into a file and calculate the MD5 hash.
 func expandCode(code string) (string, error) {
         h := md5.New()
         h.Write([]byte(code))
         hash := fmt.Sprintf("%x", h.Sum(nil))
         // At this point we are running in skia/experimental/webtry, making cache a
         // peer directory to skia.
         // TODO(jcgregorio) Make all relative directories into flags.
@@ skipping 110 matching lines @@
         filename := match[1]
         http.ServeFile(w, r, fmt.Sprintf("../../../inout/%s", filename))
 }
 
 type Try struct {
         Hash     string `json:"hash"`
         CreateTS string `json:"create_ts"`
 }
 
 type Recent struct {
-        Tries []Try
+        Tries    []Try
+        Titlebar Titlebar
 }
 
 // recentHandler shows the last 20 tries.
 func recentHandler(w http.ResponseWriter, r *http.Request) {
         log.Printf("Recent Handler: %q\n", r.URL.Path)
 
         var err error
         rows, err := db.Query("SELECT create_ts, hash FROM webtry ORDER BY create_ts DESC LIMIT 20")
         if err != nil {
                 http.NotFound(w, r)
                 return
         }
         recent := []Try{}
         for rows.Next() {
                 var hash string
                 var create_ts time.Time
                 if err := rows.Scan(&create_ts, &hash); err != nil {
                         log.Printf("Error: failed to fetch from database: %q", err)
                         continue
                 }
                 recent = append(recent, Try{Hash: hash, CreateTS: create_ts.Format("2006-02-01")})
         }
-        if err := recentTemplate.Execute(w, Recent{Tries: recent}); err != nil {
+        if err := recentTemplate.Execute(w, Recent{Tries: recent, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}}); err != nil {
                 log.Printf("ERROR: Failed to expand template: %q\n", err)
         }
 }
 
 type Workspace struct {
-        Name  string
-        Code  string
-        Hash  string
-        Tries []Try
+        Name     string
+        Code     string
+        Hash     string
+        Tries    []Try
+        Titlebar Titlebar
 }
 
 // newWorkspace generates a new random workspace name and stores it in the database.
 func newWorkspace() (string, error) {
         for i := 0; i < 10; i++ {
                 adj := workspaceNameAdj[rand.Intn(len(workspaceNameAdj))]
                 noun := workspaceNameNoun[rand.Intn(len(workspaceNameNoun))]
                 suffix := rand.Intn(1000)
                 name := fmt.Sprintf("%s-%s-%d", adj, noun, suffix)
                 if _, err := db.Exec("INSERT INTO workspace (name) VALUES(?)", name); err == nil {
@@ skipping 39 matching lines @@
                         }
                 }
                 var code string
                 var hash string
                 if len(tries) == 0 {
                         code = DEFAULT_SAMPLE
                 } else {
                         hash = tries[len(tries)-1].Hash
                         code, _ = getCode(hash)
                 }
-                if err := workspaceTemplate.Execute(w, Workspace{Tries: tries, Code: code, Name: name, Hash: hash}); err != nil {
+                if err := workspaceTemplate.Execute(w, Workspace{Tries: tries, Code: code, Name: name, Hash: hash, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}}); err != nil {
                         log.Printf("ERROR: Failed to expand template: %q\n", err)
                 }
         } else if r.Method == "POST" {
                 name, err := newWorkspace()
                 if err != nil {
                         http.Error(w, "Failed to create a new workspace.", 500)
                         return
                 }
                 http.Redirect(w, r, "/w/"+name, 302)
         }
@@ skipping 99 matching lines @@
                                 http.NotFound(w, r)
                                 return
                         }
                         // Update 'code' with the code found in the database.
                         if err := db.QueryRow("SELECT code FROM webtry WHERE hash=?", hash).Scan(&code); err != nil {
                                 http.NotFound(w, r)
                                 return
                         }
                 }
                 // Expand the template.
-                if err := indexTemplate.Execute(w, userCode{Code: code, Hash: hash}); err != nil {
+                if err := indexTemplate.Execute(w, userCode{Code: code, Hash: hash, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}}); err != nil {
                         log.Printf("ERROR: Failed to expand template: %q\n", err)
                 }
         } else if r.Method == "POST" {
                 w.Header().Set("Content-Type", "application/json")
                 buf := bytes.NewBuffer(make([]byte, 0, MAX_TRY_SIZE))
                 n, err := buf.ReadFrom(r.Body)
                 if err != nil {
                         reportTryError(w, r, err, "Failed to read a request body.", "")
                         return
                 }
@@ skipping 75 matching lines @@
         http.HandleFunc("/w/", workspaceHandler)
         http.HandleFunc("/recent/", recentHandler)
         http.HandleFunc("/iframe/", iframeHandler)
         http.HandleFunc("/json/", tryInfoHandler)
         http.HandleFunc("/css/", cssHandler)
         http.HandleFunc("/js/", jsHandler)
         // TODO Break out /c/ as it's own handler.
         http.HandleFunc("/", mainHandler)
         log.Fatal(http.ListenAndServe(*port, nil))
 }