Add /recent

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
         "encoding/json"
         "flag"
         "fmt"
         _ "github.com/go-sql-driver/mysql"
         _ "github.com/mattn/go-sqlite3"
         htemplate "html/template"
         "io/ioutil"
         "log"
         "net/http"
         "os"
         "os/exec"
         "path/filepath"
         "regexp"
         "strings"
         "text/template"
+        "time"
 )
 
 const (
         RESULT_COMPILE = `c++ -DSK_GAMMA_SRGB -DSK_GAMMA_APPLY_TO_A8 -DSK_SCALAR_TO_FLOAT_EXCLUDED -DSK_ALLOW_STATIC_GLOBAL_INITIALIZERS=1 -DSK_SUPPORT_GPU=0 -DSK_SUPPORT_OPENCL=0 -DSK_FORCE_DISTANCEFIELD_FONTS=0 -DSK_SCALAR_IS_FLOAT -DSK_CAN_USE_FLOAT -DSK_SAMPLES_FOR_X -DSK_BUILD_FOR_UNIX -DSK_USE_POSIX_THREADS -DSK_SYSTEM_ZLIB=1 -DSK_DEBUG -DSK_DEVELOPER=1 -I../../src/core -I../../src/images -I../../tools/flags -I../../include/config -I../../include/core -I../../include/pathops -I../../include/pipe -I../../include/effects -I../../include/ports -I../../src/sfnt -I../../include/utils -I../../src/utils -I../../include/images -g -fno-exceptions -fstrict-aliasing -Wall -Wextra -Winit-self -Wpointer-arith -Wno-unused-parameter -Wno-c++11-extensions -Werror -m64 -fno-rtti -Wnon-virtual-dtor -c ../../../cache/%s.cpp -o ../../../cache/%s.o`
         LINK           = `c++ -m64 -lstdc++ -lm -o ../../../inout/%s -Wl,--start-group ../../../cache/%s.o obj/experimental/webtry/webtry.main.o obj/gyp/libflags.a libskia_images.a libskia_core.a libskia_effects.a obj/gyp/libjpeg.a obj/gyp/libwebp_dec.a obj/gyp/libwebp_demux.a obj/gyp/libwebp_dsp.a obj/gyp/libwebp_enc.a obj/gyp/libwebp_utils.a libskia_utils.a libskia_opts.a libskia_opts_ssse3.a libskia_ports.a libskia_sfnt.a -Wl,--end-group -lpng -lz -lgif -lpthread -lfontconfig -ldl -lfreetype`
         DEFAULT_SAMPLE = `SkPaint p;
 p.setColor(SK_ColorRED);
 p.setAntiAlias(true);
 p.setStyle(SkPaint::kStroke_Style);
 p.setStrokeWidth(10);
 
 canvas->drawLine(20, 20, 100, 100, p);
 `
 )
 
 var (
         // codeTemplate is the cpp code template the user's code is copied into.
         codeTemplate *template.Template = nil
 
-        // index is the main index.html page we serve.
-        index *htemplate.Template = nil
+        // indexTemplate is the main index.html page we serve.
+        indexTemplate *htemplate.Template = nil
+
+        // recentTemplate is a list of recent  images.
+        recentTemplate *htemplate.Template = nil
 
         // 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-a0-9]+)$")
+        directLink = regexp.MustCompile("^/c/([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)$")
 )
 
 // 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 14 matching lines @@
         if err != nil {
                 log.Fatal(err)
         }
         os.Chdir(cwd)
 
         codeTemplate, err = template.ParseFiles(filepath.Join(cwd, "templates/template.cpp"))
         if err != nil {
                 panic(err)
         }
         // Convert index.html into a template, which is expanded with the code.
-        index, err = htemplate.ParseFiles(filepath.Join(cwd, "templates/index.html"))
+        indexTemplate, err = htemplate.ParseFiles(filepath.Join(cwd, "templates/index.html"))
         if err != nil {
                 panic(err)
         }
+
+        recentTemplate, err = htemplate.ParseFiles(filepath.Join(cwd, "templates/recent.html"))
+        if err != nil {
+                panic(err)
+        }
 
         // 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 {
@@ skipping 121 matching lines @@
 
 func writeToDatabase(hash string, code string) {
         if db == nil {
                 return
         }
         if _, err := db.Exec("INSERT INTO webtry (code, hash) VALUES(?, ?)", code, hash); err != nil {
                 log.Printf("ERROR: Failed to insert code into database: %q\n", err)
         }
 }
 
+func cssHandler(w http.ResponseWriter, r *http.Request) {
+        http.ServeFile(w, r, "css/webtry.css")
+}
+
+// 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]
+        http.ServeFile(w, r, fmt.Sprintf("../../../inout/%s", filename))

[mtklein, 2014/04/14 18:27:53]

Doesn't this make you sort of wish the images were in the DB too?

[jcgregorio, 2014/04/14 18:43:46]

Yeah yeah, I'm coming around to that idea :-)

+}
+
+type Try struct {
+        Hash     string
+        CreateTS string
+}
+
+type Recent struct {
+        Tries []Try
+}
+
+// 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")})

[mtklein, 2014/04/14 18:27:53]

I've never seen this .Format method before.  Cute!

[jcgregorio, 2014/04/14 18:43:46]

Yeah, makes for very readable code.

On 2014/04/14 18:27:53, mtklein wrote:

+        }
+        if err := recentTemplate.Execute(w, Recent{Tries: recent}); err != nil {
+                log.Printf("ERROR: Failed to expand template: %q\n", err)
+        }
+}
+
 // 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)

[mtklein, 2014/04/14 18:27:53]

Leftover?

[jcgregorio, 2014/04/14 18:43:46]

Actually useful to have in the logs.

On 2014/04/14 18:27:53, mtklein wrote:

         if r.Method == "GET" {
                 code := DEFAULT_SAMPLE
-                directLink := regexp.MustCompile("^/c/([a-f0-9]+)$")
                 match := directLink.FindStringSubmatch(r.URL.Path)
-                if len(match) == 2 {
+                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 {
                                 http.NotFound(w, r)
                                 return
                         }
                 }
                 // Expand the template.
-                if err := index.Execute(w, userCode{UserCode: code}); err != nil {
+                if err := indexTemplate.Execute(w, userCode{UserCode: code}); err != nil {
                         log.Printf("ERROR: Failed to expand template: %q\n", err)
                 }
         } else if r.Method == "POST" {
                 w.Header().Set("Content-Type", "application/json")
                 b, err := ioutil.ReadAll(r.Body)
                 if err != nil {
                         reportError(w, r, err, "Failed to read a request body.")
                         return
                 }
                 code := string(b)
@@ skipping 46 matching lines @@
                 if err != nil {
                         reportError(w, r, err, "Failed to serialize a response.")
                         return
                 }
                 w.Write(resp)
         }
 }
 
 func main() {
         flag.Parse()
-
+        http.HandleFunc("/i/", imageHandler)
+        http.HandleFunc("/recent/", recentHandler)
+        http.HandleFunc("/css/", cssHandler)
         http.HandleFunc("/", mainHandler)
         log.Fatal(http.ListenAndServe(*port, nil))
 }