Add the ability to select a source image to use in the code.

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
+        "encoding/binary"
         "encoding/json"
         "flag"
         "fmt"
         htemplate "html/template"
+        "image"
+        _ "image/gif"
+        _ "image/jpeg"
+        "image/png"
         "io/ioutil"
         "log"
         "math/rand"
         "net/http"
         "os"
         "os/exec"
         "path/filepath"
         "regexp"
         "strings"
         "text/template"
@@ skipping 41 matching lines @@
         // db is the database, nil if we don't have an SQL database to store data into.
         db *sql.DB = nil
 
         // directLink is the regex that matches URLs paths that are direct links.
         directLink = regexp.MustCompile("^/c/([a-f0-9]+)$")
 
         // iframeLink is the regex that matches URLs paths that are links to iframes.
         iframeLink = regexp.MustCompile("^/iframe/([a-f0-9]+)$")
 
         // imageLink is the regex that matches URLs paths that are direct links to PNGs.
-        imageLink = regexp.MustCompile("^/i/([a-f0-9]+.png)$")
+        imageLink = regexp.MustCompile("^/i/([a-z0-9-]+.png)$")
 
         // tryInfoLink is the regex that matches URLs paths that are direct links to data about a single try.
         tryInfoLink = regexp.MustCompile("^/json/([a-f0-9]+)$")
 
         // workspaceLink is the regex that matches URLs paths for workspaces.
         workspaceLink = regexp.MustCompile("^/w/([a-z0-9-]+)$")
 
         // workspaceNameAdj is a list of adjectives for building workspace names.
         workspaceNameAdj = []string{
                 "autumn", "hidden", "bitter", "misty", "silent", "empty", "dry", "dark",
@@ skipping 130 matching lines @@
                         panic(err)
                 }
         } else {
                 log.Printf("INFO: Failed to find metadata, unable to connect to MySQL server (Expected when running locally): %q\n", err)
                 // Fallback to sqlite for local use.
                 db, err = sql.Open("sqlite3", "./webtry.db")
                 if err != nil {
                         log.Printf("ERROR: Failed to open: %q\n", err)
                         panic(err)
                 }
-                sql := `CREATE TABLE webtry (
-             code      TEXT      DEFAULT ''                 NOT NULL,
-             create_ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP  NOT NULL,
-             hash      CHAR(64)  DEFAULT ''                 NOT NULL,
+                sql := `CREATE TABLE source_images (
+             id        INTEGER     PRIMARY KEY                NOT NULL,
+             image     MEDIUMBLOB  DEFAULT ''                 NOT NULL, -- formatted as a PNG.
+             width     INTEGER     DEFAULT 0                  NOT NULL,
+             height    INTEGER     DEFAULT 0                  NOT NULL,
+             create_ts TIMESTAMP   DEFAULT CURRENT_TIMESTAMP  NOT NULL,
+             hidden    INTEGER     DEFAULT 0                  NOT NULL
+             )`
+                _, err = db.Exec(sql)
+                log.Printf("Info: status creating sqlite table for sources: %q\n", err)
+
+                sql = `CREATE TABLE webtry (
+             code               TEXT      DEFAULT ''                 NOT NULL,
+             create_ts          TIMESTAMP DEFAULT CURRENT_TIMESTAMP  NOT NULL,
+             hash               CHAR(64)  DEFAULT ''                 NOT NULL,
+             source_image_id    INTEGER   DEFAULT 0                  NOT NULL,
+
              PRIMARY KEY(hash)
             )`
                 _, err = db.Exec(sql)
                 log.Printf("Info: status creating sqlite table for webtry: %q\n", err)
+
                 sql = `CREATE TABLE workspace (
           name      CHAR(64)  DEFAULT ''                 NOT NULL,
           create_ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP  NOT NULL,
           PRIMARY KEY(name)
         )`
                 _, err = db.Exec(sql)
                 log.Printf("Info: status creating sqlite table for workspace: %q\n", err)
+
                 sql = `CREATE TABLE workspacetry (
-          name      CHAR(64)  DEFAULT ''                 NOT NULL,
-          create_ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP  NOT NULL,
-          hash      CHAR(64)  DEFAULT ''                 NOT NULL,
-          hidden    INTEGER   DEFAULT 0                  NOT NULL,
+          name               CHAR(64)  DEFAULT ''                 NOT NULL,
+          create_ts          TIMESTAMP DEFAULT CURRENT_TIMESTAMP  NOT NULL,
+          hash               CHAR(64)  DEFAULT ''                 NOT NULL,
+          hidden             INTEGER   DEFAULT 0                  NOT NULL,
+          source_image_id    INTEGER   DEFAULT 0                  NOT NULL,
 
-          FOREIGN KEY (name) REFERENCES workspace(name)
+          FOREIGN KEY (name)   REFERENCES workspace(name)
         )`
                 _, err = db.Exec(sql)
                 log.Printf("Info: status creating sqlite table for workspace try: %q\n", err)
         }
 
         // Ping the database to keep the connection fresh.
         go func() {
                 c := time.Tick(1 * time.Minute)
                 for _ = range c {
                         if err := db.Ping(); err != nil {
                                 log.Printf("ERROR: Database failed to respond: %q\n", err)
                         }
                 }
         }()
 
+        writeOutAllSourceImages()
+}
+
+func writeOutAllSourceImages() {
+        // Pull all the source images from the db and write them out to inout.
+        rows, err := db.Query("SELECT id, image, create_ts FROM source_images ORDER BY create_ts DESC")
+
+        if err != nil {
+                log.Printf("ERROR: Failed to open connection to SQL server: %q\n", err)
+                panic(err)
+        }
+        for rows.Next() {
+                var id int
+                var image []byte
+                var create_ts time.Time
+                if err := rows.Scan(&id, &image, &create_ts); err != nil {
+                        log.Printf("Error: failed to fetch from database: %q", err)
+                        continue
+                }
+                filename := fmt.Sprintf("../../../inout/image-%d.png", id)
+                if _, err := os.Stat(filename); os.IsExist(err) {
+                        log.Printf("Skipping write since file exists: %q", filename)
+                        continue
+                }
+                if err := ioutil.WriteFile(filename, image, 0666); err != nil {
+                        log.Printf("Error: failed to write image file: %q", 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
+        Source   int
         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, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}})
 }
 
-// expandCode expands the template into a file and calculate the MD5 hash.
-func expandCode(code string) (string, error) {
+// expandCode expands the template into a file and calculates the MD5 hash.
+func expandCode(code string, source int) (string, error) {
         h := md5.New()
         h.Write([]byte(code))
+        binary.Write(h, binary.LittleEndian, int64(source))
         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.
         err := expandToFile(fmt.Sprintf("../../../cache/%s.cpp", hash), code, codeTemplate)
         return hash, err
 }
 
 // response is serialized to JSON as a response to POSTs.
 type response struct {
@@ skipping 53 matching lines @@
         log.Printf("Error: %s\n%s", message, err.Error())
         resp, err := json.Marshal(m)
         if err != nil {
                 http.Error(w, "Failed to serialize a response", 500)
                 return
         }
         w.Header().Set("Content-Type", "text/plain")
         w.Write(resp)
 }
 
-func writeToDatabase(hash string, code string, workspaceName string) {
+func writeToDatabase(hash string, code string, workspaceName string, source int) {
         if db == nil {
                 return
         }
-        if _, err := db.Exec("INSERT INTO webtry (code, hash) VALUES(?, ?)", code, hash); err != nil {
+        if _, err := db.Exec("INSERT INTO webtry (code, hash, source_image_id) VALUES(?, ?, ?)", code, hash, source); err != nil {
                 log.Printf("ERROR: Failed to insert code into database: %q\n", err)
         }
         if workspaceName != "" {
-                if _, err := db.Exec("INSERT INTO workspacetry (name, hash) VALUES(?, ?)", workspaceName, hash); err != nil {
+                if _, err := db.Exec("INSERT INTO workspacetry (name, hash, source_image_id) VALUES(?, ?, ?)", workspaceName, hash, source); err != nil {
                         log.Printf("ERROR: Failed to insert into workspacetry table: %q\n", err)
                 }
         }
 }
 
+type Sources struct {
+        Id int `json:"id"`
+}
+
+// sourcesHandler serves up the PNG of a specific try.
+func sourcesHandler(w http.ResponseWriter, r *http.Request) {
+        log.Printf("Sources Handler: %q\n", r.URL.Path)
+        if r.Method == "GET" {
+                rows, err := db.Query("SELECT id, create_ts FROM source_images WHERE hidden=0 ORDER BY create_ts DESC")
+
+                if err != nil {
+                        http.Error(w, fmt.Sprintf("Failed to query sources: %s.", err), 500)
+                }
+                sources := make([]Sources, 0, 0)
+                for rows.Next() {
+                        var id int
+                        var create_ts time.Time
+                        if err := rows.Scan(&id, &create_ts); err != nil {
+                                log.Printf("Error: failed to fetch from database: %q", err)
+                                continue
+                        }
+                        sources = append(sources, Sources{Id: id})
+                }
+
+                resp, err := json.Marshal(sources)
+                if err != nil {
+                        reportError(w, r, err, "Failed to serialize a response.")
+                        return
+                }
+                w.Header().Set("Content-Type", "application/json")
+                w.Write(resp)
+
+        } else if r.Method == "POST" {
+                if err := r.ParseMultipartForm(1000000); err != nil {
+                        http.Error(w, fmt.Sprintf("Failed to load image: %s.", err), 500)
+                        return
+                }
+                if _, ok := r.MultipartForm.File["upload"]; !ok {
+                        http.Error(w, "Invalid upload.", 500)
+                        return
+                }
+                if len(r.MultipartForm.File["upload"]) != 1 {
+                        http.Error(w, "Wrong number of uploads.", 500)
+                        return
+                }
+                f, err := r.MultipartForm.File["upload"][0].Open()
+                if err != nil {
+                        http.Error(w, fmt.Sprintf("Failed to load image: %s.", err), 500)
+                        return
+                }
+                defer f.Close()
+                m, _, err := image.Decode(f)
+                if err != nil {
+                        http.Error(w, fmt.Sprintf("Failed to decode image: %s.", err), 500)
+                        return
+                }
+                var b bytes.Buffer
+                png.Encode(&b, m)
+                bounds := m.Bounds()
+                width := bounds.Max.Y - bounds.Min.Y
+                height := bounds.Max.X - bounds.Min.X
+                if _, err := db.Exec("INSERT INTO source_images (image, width, height) VALUES(?, ?, ?)", b.Bytes(), width, height); err != nil {
+                        log.Printf("ERROR: Failed to insert sources into database: %q\n", err)
+                        http.Error(w, fmt.Sprintf("Failed to store image: %s.", err), 500)
+                        return
+                }
+                go writeOutAllSourceImages()
+
+                // Now redirect back to where we came from.
+                http.Redirect(w, r, r.Referer(), 302)
+        } else {
+                http.NotFound(w, r)
+                return
+        }
+}
+
 // imageHandler serves up the PNG of a specific try.
 func imageHandler(w http.ResponseWriter, r *http.Request) {
         log.Printf("Image Handler: %q\n", r.URL.Path)
         if r.Method != "GET" {
                 http.NotFound(w, r)
                 return
         }
         match := imageLink.FindStringSubmatch(r.URL.Path)
         if len(match) != 2 {
                 http.NotFound(w, r)
                 return
         }
         filename := match[1]
         w.Header().Set("Content-Type", "image/png")
         http.ServeFile(w, r, fmt.Sprintf("../../../inout/%s", filename))
 }
 
 type Try struct {
         Hash     string `json:"hash"`
+        Source   int
         CreateTS string `json:"create_ts"`
 }
 
 type Recent struct {
         Tries    []Try
         Titlebar Titlebar
 }
 
 // recentHandler shows the last 20 tries.
 func recentHandler(w http.ResponseWriter, r *http.Request) {
@@ skipping 18 matching lines @@
         w.Header().Set("Content-Type", "text/html")
         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
+        Source   int
         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 {
                         return name, nil
                 } else {
                         log.Printf("ERROR: Failed to insert workspace into database: %q\n", err)
                 }
         }
         return "", fmt.Errorf("Failed to create a new workspace")
 }
 
 // getCode returns the code for a given hash, or the empty string if not found.
-func getCode(hash string) (string, error) {
+func getCode(hash string) (string, int, error) {
         code := ""
-        if err := db.QueryRow("SELECT code FROM webtry WHERE hash=?", hash).Scan(&code); err != nil {
+        source := 0
+        if err := db.QueryRow("SELECT code, source_image_id FROM webtry WHERE hash=?", hash).Scan(&code, &source); err != nil {
                 log.Printf("ERROR: Code for hash is missing: %q\n", err)
-                return code, err
+                return code, source, err
         }
-        return code, nil
+        return code, source, nil
 }
 
 func workspaceHandler(w http.ResponseWriter, r *http.Request) {
         log.Printf("Workspace Handler: %q\n", r.URL.Path)
         if r.Method == "GET" {
                 tries := []Try{}
                 match := workspaceLink.FindStringSubmatch(r.URL.Path)
                 name := ""
                 if len(match) == 2 {
                         name = match[1]
-                        rows, err := db.Query("SELECT create_ts, hash FROM workspacetry WHERE name=? ORDER BY create_ts", name)
+                        rows, err := db.Query("SELECT create_ts, hash, source_image_id FROM workspacetry WHERE name=? ORDER BY create_ts", name)
                         if err != nil {
                                 reportError(w, r, err, "Failed to select.")
                                 return
                         }
                         for rows.Next() {
                                 var hash string
                                 var create_ts time.Time
-                                if err := rows.Scan(&create_ts, &hash); err != nil {
+                                var source int
+                                if err := rows.Scan(&create_ts, &hash, &source); err != nil {
                                         log.Printf("Error: failed to fetch from database: %q", err)
                                         continue
                                 }
-                                tries = append(tries, Try{Hash: hash, CreateTS: create_ts.Format("2006-02-01")})
+                                tries = append(tries, Try{Hash: hash, Source: source, CreateTS: create_ts.Format("2006-02-01")})
                         }
                 }
                 var code string
                 var hash string
+                source := 0
                 if len(tries) == 0 {
                         code = DEFAULT_SAMPLE
                 } else {
                         hash = tries[len(tries)-1].Hash
-                        code, _ = getCode(hash)
+                        code, source, _ = getCode(hash)
                 }
                 w.Header().Set("Content-Type", "text/html")
-                if err := workspaceTemplate.Execute(w, Workspace{Tries: tries, Code: code, Name: name, Hash: hash, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}}); err != nil {
+                if err := workspaceTemplate.Execute(w, Workspace{Tries: tries, Code: code, Name: name, Hash: hash, Source: source, 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)
         }
 }
 
 // hasPreProcessor returns true if any line in the code begins with a # char.
 func hasPreProcessor(code string) bool {
         lines := strings.Split(code, "\n")
         for _, s := range lines {
                 if strings.HasPrefix(strings.TrimSpace(s), "#") {
                         return true
                 }
         }
         return false
 }
 
 type TryRequest struct {
-        Code string `json:"code"`
-        Name string `json:"name"` // Optional name of the workspace the code is in.
+        Code   string `json:"code"`
+        Name   string `json:"name"`   // Optional name of the workspace the code is in.
+        Source int    `json:"source"` // ID of the source image, 0 if none.
 }
 
 // iframeHandler handles the GET and POST of the main page.
 func iframeHandler(w http.ResponseWriter, r *http.Request) {
         log.Printf("IFrame Handler: %q\n", r.URL.Path)
         if r.Method != "GET" {
                 http.NotFound(w, r)
                 return
         }
         match := iframeLink.FindStringSubmatch(r.URL.Path)
         if len(match) != 2 {
                 http.NotFound(w, r)
                 return
         }
         hash := match[1]
         if db == nil {
                 http.NotFound(w, r)
                 return
         }
         var code string
-        code, err := getCode(hash)
+        code, source, err := getCode(hash)
         if err != nil {
                 http.NotFound(w, r)
                 return
         }
         // Expand the template.
         w.Header().Set("Content-Type", "text/html")
-        if err := iframeTemplate.Execute(w, userCode{Code: code, Hash: hash}); err != nil {
+        if err := iframeTemplate.Execute(w, userCode{Code: code, Hash: hash, Source: source}); err != nil {
                 log.Printf("ERROR: Failed to expand template: %q\n", err)
         }
 }
 
 type TryInfo struct {
-        Hash string `json:"hash"`
-        Code string `json:"code"`
+        Hash   string `json:"hash"`
+        Code   string `json:"code"`
+        Source int    `json:"source"`
 }
 
 // tryInfoHandler returns information about a specific try.
 func tryInfoHandler(w http.ResponseWriter, r *http.Request) {
         log.Printf("Try Info Handler: %q\n", r.URL.Path)
         if r.Method != "GET" {
                 http.NotFound(w, r)
                 return
         }
         match := tryInfoLink.FindStringSubmatch(r.URL.Path)
         if len(match) != 2 {
                 http.NotFound(w, r)
                 return
         }
         hash := match[1]
-        code, err := getCode(hash)
+        code, source, err := getCode(hash)
         if err != nil {
                 http.NotFound(w, r)
                 return
         }
         m := TryInfo{
-                Hash: hash,
-                Code: code,
+                Hash:   hash,
+                Code:   code,
+                Source: source,
         }
         resp, err := json.Marshal(m)
         if err != nil {
                 reportError(w, r, err, "Failed to serialize a response.")
                 return
         }
         w.Header().Set("Content-Type", "application/json")
         w.Write(resp)
 }
 
 func cleanCompileOutput(s, hash string) string {
         old := "../../../cache/" + hash + ".cpp:"
         log.Printf("INFO: replacing %q\n", old)
         return strings.Replace(s, old, "usercode.cpp:", -1)
 }
 
 // mainHandler handles the GET and POST of the main page.
 func mainHandler(w http.ResponseWriter, r *http.Request) {
         log.Printf("Main Handler: %q\n", r.URL.Path)
         if r.Method == "GET" {
                 code := DEFAULT_SAMPLE
+                source := 0
                 match := directLink.FindStringSubmatch(r.URL.Path)
                 var hash string
                 if len(match) == 2 && r.URL.Path != "/" {
                         hash = match[1]
                         if db == nil {
                                 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 {
+                        if err := db.QueryRow("SELECT code, source_image_id FROM webtry WHERE hash=?", hash).Scan(&code, &source); err != nil {
                                 http.NotFound(w, r)
                                 return
                         }
                 }
                 // Expand the template.
                 w.Header().Set("Content-Type", "text/html")
-                if err := indexTemplate.Execute(w, userCode{Code: code, Hash: hash, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}}); err != nil {
+                if err := indexTemplate.Execute(w, userCode{Code: code, Hash: hash, Source: source, 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
                 }
                 if n == MAX_TRY_SIZE {
                         err := fmt.Errorf("Code length equal to, or exceeded, %d", MAX_TRY_SIZE)
                         reportTryError(w, r, err, "Code too large.", "")
                         return
                 }
                 request := TryRequest{}
                 if err := json.Unmarshal(buf.Bytes(), &request); err != nil {
                         reportTryError(w, r, err, "Coulnd't decode JSON.", "")
                         return
                 }
                 if hasPreProcessor(request.Code) {
                         err := fmt.Errorf("Found preprocessor macro in code.")
                         reportTryError(w, r, err, "Preprocessor macros aren't allowed.", "")
                         return
                 }
-                hash, err := expandCode(LineNumbers(request.Code))
+                hash, err := expandCode(LineNumbers(request.Code), request.Source)
                 if err != nil {
                         reportTryError(w, r, err, "Failed to write the code to compile.", hash)
                         return
                 }
-                writeToDatabase(hash, request.Code, request.Name)
+                writeToDatabase(hash, request.Code, request.Name, request.Source)
                 message, err := doCmd(fmt.Sprintf(RESULT_COMPILE, hash, hash), true)
                 if err != nil {
                         message = cleanCompileOutput(message, hash)
                         reportTryError(w, r, err, message, hash)
                         return
                 }
                 linkMessage, err := doCmd(fmt.Sprintf(LINK, hash, hash), true)
                 if err != nil {
                         linkMessage = cleanCompileOutput(linkMessage, hash)
                         reportTryError(w, r, err, linkMessage, hash)
                         return
                 }
                 message += linkMessage
                 cmd := hash + " --out " + hash + ".png"
+                if request.Source > 0 {
+                        cmd += fmt.Sprintf("  --source image-%d.png", request.Source)
+                }
                 if *useChroot {
                         cmd = "schroot -c webtry --directory=/inout -- /inout/" + cmd
                 } else {
                         abs, err := filepath.Abs("../../../inout")
                         if err != nil {
                                 reportTryError(w, r, err, "Failed to find executable directory.", hash)
                                 return
                         }
                         cmd = abs + "/" + cmd
                 }
@@ skipping 25 matching lines @@
         }
 }
 
 func main() {
         flag.Parse()
         http.HandleFunc("/i/", autogzip.HandleFunc(imageHandler))
         http.HandleFunc("/w/", autogzip.HandleFunc(workspaceHandler))
         http.HandleFunc("/recent/", autogzip.HandleFunc(recentHandler))
         http.HandleFunc("/iframe/", autogzip.HandleFunc(iframeHandler))
         http.HandleFunc("/json/", autogzip.HandleFunc(tryInfoHandler))
+        http.HandleFunc("/sources/", autogzip.HandleFunc(sourcesHandler))
 
         // Resources are served directly
         // TODO add support for caching/etags/gzip
         http.Handle("/res/", autogzip.Handle(http.FileServer(http.Dir("./"))))
 
         // TODO Break out /c/ as it's own handler.
         http.HandleFunc("/", autogzip.HandleFunc(mainHandler))
         log.Fatal(http.ListenAndServe(*port, nil))
 }