bug_chomper: Cleanup template initialization.

tools/bug_chomper/src/server/server.go

 // Copyright (c) 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /*
         Serves a webpage for easy management of Skia bugs.
 
         WARNING: This server is NOT secure and should not be made publicly
         accessible.
 */
 
 package main
 
 import (
         "encoding/json"
         "flag"
         "fmt"
         "html/template"
         "issue_tracker"
         "log"
         "net/http"
         "net/url"
-        "path"
+        "os"
         "path/filepath"
+        "runtime"
         "strconv"
         "strings"
         "time"
 )
 
 import "github.com/gorilla/securecookie"
 
 const (
         certFile          = "certs/cert.pem"
         keyFile           = "certs/key.pem"
         issueComment      = "Edited by BugChomper"
         oauthCallbackPath = "/oauth2callback"
         oauthConfigFile   = "oauth_client_secret.json"
         localHost         = "127.0.0.1"
         maxSessionLen     = time.Duration(3600 * time.Second)
         priorityPrefix    = "Priority-"
         project           = "skia"
         cookieName        = "BugChomperCookie"
 )
 
 // Flags:
 var (
         port   = flag.String("port", ":8000", "HTTP service address (e.g., ':8000')")
         public = flag.Bool("public", false, "Make this server publicly accessible.")
 )
 
 var (
-        scheme = "http"
+        // templates is the list of html templates used by bug_chomper.
+        templates *template.Template = nil
 
-        curdir, _       = filepath.Abs(".")
-        templatePath, _ = filepath.Abs("templates")
-        templates       = template.Must(template.ParseFiles(
-                path.Join(templatePath, "bug_chomper.html"),
-                path.Join(templatePath, "submitted.html"),
-                path.Join(templatePath, "error.html")))
-
+        scheme       = "http"
         hashKey      = securecookie.GenerateRandomKey(32)
         blockKey     = securecookie.GenerateRandomKey(32)
         secureCookie = securecookie.New(hashKey, blockKey)
 )
 
+func init() {
+        // Change the current working directory to two directories up from this
+        // source file so that we can read templates.
+        _, filename, _, _ := runtime.Caller(0)
+        cwd := filepath.Join(filepath.Dir(filename), "../..")
+        if err := os.Chdir(cwd); err != nil {
+                log.Fatal(err)
+        }
+
+        templates = template.Must(template.ParseFiles(
+                filepath.Join(cwd, "templates/bug_chomper.html"),

[tfarina, 2014/10/15 22:18:14]

cwd results in the abs path where running ./run_server.sh, so this works
correctly.

+                filepath.Join(cwd, "templates/submitted.html"),
+                filepath.Join(cwd, "templates/error.html"),
+        ))
+}
+
 // SessionState contains data for a given session.
 type SessionState struct {
         IssueTracker   *issue_tracker.IssueTracker
         OrigRequestURL string
         SessionStart   time.Time
 }
 
 // getAbsoluteURL returns the absolute URL of the given Request.
 func getAbsoluteURL(r *http.Request) string {
         return scheme + "://" + r.Host + r.URL.Path
@@ skipping 280 matching lines @@
         }
         http.NotFound(w, r)
 }
 
 // Run the BugChomper server.
 func main() {
         flag.Parse()
 
         http.HandleFunc("/", handleRoot)
         http.HandleFunc(oauthCallbackPath, handleOAuth2Callback)
-        http.Handle("/res/", http.FileServer(http.Dir(curdir)))
+        http.Handle("/res/", http.FileServer(http.Dir("./")))
         log.Println("Server is running at " + scheme + "://" + localHost + *port)
         var err error
         if *public {
                 log.Println("WARNING: This server is not secure and should not be made " +
                         "publicly accessible.")
                 scheme = "https"
                 err = http.ListenAndServeTLS(*port, certFile, keyFile, nil)
         } else {
                 scheme = "http"
                 err = http.ListenAndServe(localHost+*port, nil)
         }
         if err != nil {
                 log.Println(err.Error())
         }
 }