Cleaned up the start page, added wait cursor, disabled Run button while waiting for results.

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"
+        "math/rand"
         "net/http"
         "os"
         "os/exec"
         "path/filepath"
         "regexp"
         "strings"
         "text/template"
         "time"
 )
 
@@ skipping 12 matching lines @@
         MAX_TRY_SIZE = 64000
 )
 
 var (
         // codeTemplate is the cpp code template the user's code is copied into.
         codeTemplate *template.Template = nil
 
         // indexTemplate is the main index.html page we serve.
         indexTemplate *htemplate.Template = nil
 
-        // recentTemplate is a list of recent  images.
+        // recentTemplate is a list of recent images.
         recentTemplate *htemplate.Template = nil
 
+        // workspaceTemplate is the page for workspaces, a series of webtrys.
+        workspaceTemplate *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-f0-9]+)$")
 
         // imageLink is the regex that matches URLs paths that are direct links to PNGs.
         imageLink = regexp.MustCompile("^/i/([a-f0-9]+.png)$")
+
+        // workspaceLink is the regex that matches URLs paths for workspaces.
+        workspaceLink = regexp.MustCompile("^/w/([a-z0-9-]+)$")
+
+        workspaceNameAdj = []string{
+                "autumn", "hidden", "bitter", "misty", "silent", "empty", "dry", "dark",
+                "summer", "icy", "delicate", "quiet", "white", "cool", "spring", "winter",
+                "patient", "twilight", "dawn", "crimson", "wispy", "weathered", "blue",
+                "billowing", "broken", "cold", "damp", "falling", "frosty", "green",
+                "long", "late", "lingering", "bold", "little", "morning", "muddy", "old",
+                "red", "rough", "still", "small", "sparkling", "throbbing", "shy",
+                "wandering", "withered", "wild", "black", "young", "holy", "solitary",
+                "fragrant", "aged", "snowy", "proud", "floral", "restless", "divine",
+                "polished", "ancient", "purple", "lively", "nameless",
+        }
+
+        workspaceNameNoun = []string{
+                "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",
+        }
 )
 
 // 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 24 matching lines @@
         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)
         }
 
+        workspaceTemplate, err = htemplate.ParseFiles(filepath.Join(cwd, "templates/workspace.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 {
                 password, err := ioutil.ReadAll(resp.Body)
                 if err != nil {
                         log.Printf("ERROR: Failed to read password from metadata server: %q\n", err)
                         panic(err)
                 }
                 // The IP address of the database is found here:
                 //    https://console.developers.google.com/project/31977622648/sql/instances/webtry/overview
                 // And 3306 is the default port for MySQL.
                 db, err = sql.Open("mysql", fmt.Sprintf("webtry:%s@tcp(173.194.83.52:3306)/webtry?parseTime=true", password))
                 if err != nil {
                         log.Printf("ERROR: Failed to open connection to SQL server: %q\n", err)
                         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,
              PRIMARY KEY(hash)
             )`
-                db.Exec(sql)
-                log.Printf("INFO: Failed to find metadata, unable to connect to MySQL server (Expected when running locally): %q\n", err)
+                _, err = db.Exec(sql)
+                log.Printf("Info: status creating sqlite table for webtry: %q\n", err)
+                sql = `CREATE TABLE workspace (
+          name      TEXT      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      TEXT      DEFAULT ''                 NOT NULL,
+          create_ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP  NOT NULL,
+          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)
         }
 }
 
 // userCode is used in template expansion.
 type userCode struct {
         UserCode string
 }
 
 // expandToFile expands the template and writes the result to the file.
 func expandToFile(filename string, code string, t *template.Template) error {
@@ skipping 74 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.Write(resp)
 }
 
-func writeToDatabase(hash string, code string) {
+func writeToDatabase(hash string, code string, workspaceName 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)
         }
+        if workspaceName != "" {
+                if _, err := db.Exec("INSERT INTO workspacetry (name, hash) VALUES(?, ?)", workspaceName, hash); err != nil {
+                        log.Printf("ERROR: Failed to insert into workspacetry table: %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" {
@@ skipping 36 matching lines @@
                         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 {
                 log.Printf("ERROR: Failed to expand template: %q\n", err)
         }
 }
 
+type Workspace struct {
+        Name  string
+        Code  string
+        Tries []Try
+}
+
+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")
+}
+
+func getCode(hash string) string {
+        code := ""
+        if err := db.QueryRow("SELECT code FROM webtry WHERE hash=?", hash).Scan(&code); err != nil {
+                log.Printf("ERROR: Code for hash is missing: %q\n", err)
+        }
+        return code
+}
+
+func workspaceHandler(w http.ResponseWriter, r *http.Request) {
+        // POST creates a new workspace and redirect to the newly created workspace.
+        // GET w/o a namespace name just gets the 'create' page.
+        // GET w/name gets that workspace doc, which is just a list of tries.
+        // What's the difference? The 'create' flow has a 'Create' button
+        // and no code. A workspace has a 'Run' button
+        // and shows the code for the most recent try. Also includes a list
+        // of all the tries in this workspace with a fingernail for each one.
+        // Run is actually handled by a POST to /.
+        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 {
+                        log.Printf("Got a valid match %q\n", match)
+                        name = match[1]
+                        // Load all the tries for this workspace.
+                        rows, err := db.Query("SELECT create_ts, hash FROM workspacetry WHERE name=? ORDER BY create_ts DESC ", 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 {
+                                        log.Printf("Error: failed to fetch from database: %q", err)
+                                        continue
+                                }
+                                tries = append(tries, Try{Hash: hash, CreateTS: create_ts.Format("2006-02-01")})
+                        }
+                }
+                var code string
+                if len(tries) == 0 {
+                        code = DEFAULT_SAMPLE
+                } else {
+                        code = getCode(tries[len(tries)-1].Hash)
+                }
+                // If len(tries) == 0 then return the 'default code', otherwise include the most recent code.
+                // We don't worry about existence of a workspace with this name since trying to
+                // add a new try will fail.
+
+                if err := workspaceTemplate.Execute(w, Workspace{Tries: tries, Code: code, Name: name}); err != nil {
+                        log.Printf("ERROR: Failed to expand template: %q\n", err)
+                }
+                // Update POST to / so that it takes a JSON document that includes not only
+                // the code but an optional 'name' parameter. If the name is present the
+                // POST handler should also add a row to the workspacetry table.
+        } else if r.Method == "POST" {
+                // Create a name and try to insert it into the db.
+                // Redirect to /w/<name>
+                if _, err := db.Exec("INSERT INTO workspace (name) VALUES(?)", "autumn-breeze-123"); err != nil {
+                        log.Printf("ERROR: Failed to insert workspace into database: %q\n", err)
+                }
+                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"`
+}
+
 // 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
                 match := directLink.FindStringSubmatch(r.URL.Path)
                 if len(match) == 2 && r.URL.Path != "/" {
                         hash := match[1]
                         if db == nil {
                                 http.NotFound(w, r)
@@ skipping 15 matching lines @@
                 n, err := buf.ReadFrom(r.Body)
                 if err != nil {
                         reportError(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)
                         reportError(w, r, err, "Code too large.")
                         return
                 }
-                code := string(buf.Bytes())
-                if hasPreProcessor(code) {
+                request := TryRequest{}
+                if err := json.Unmarshal(buf.Bytes(), &request); err != nil {
+                        reportError(w, r, err, "Coulnd't decode JSON.")
+                        return
+                }
+                if hasPreProcessor(request.Code) {
                         err := fmt.Errorf("Found preprocessor macro in code.")
                         reportError(w, r, err, "Preprocessor macros aren't allowed.")
                         return
                 }
-                hash, err := expandCode(LineNumbers(code))
+                hash, err := expandCode(LineNumbers(request.Code))
                 if err != nil {
                         reportError(w, r, err, "Failed to write the code to compile.")
                         return
                 }
-                writeToDatabase(hash, code)
+                writeToDatabase(hash, request.Code, request.Name)
                 message, err := doCmd(fmt.Sprintf(RESULT_COMPILE, hash, hash), true)
                 if err != nil {
                         reportError(w, r, err, "Failed to compile the code:\n"+message)
                         return
                 }
                 linkMessage, err := doCmd(fmt.Sprintf(LINK, hash, hash), true)
                 if err != nil {
                         reportError(w, r, err, "Failed to link the code:\n"+linkMessage)
                         return
                 }
@@ skipping 31 matching lines @@
                         reportError(w, r, err, "Failed to serialize a response.")
                         return
                 }
                 w.Write(resp)
         }
 }
 
 func main() {
         flag.Parse()
         http.HandleFunc("/i/", imageHandler)
+        http.HandleFunc("/w/", workspaceHandler)
         http.HandleFunc("/recent/", recentHandler)
         http.HandleFunc("/css/", cssHandler)
         http.HandleFunc("/", mainHandler)
         log.Fatal(http.ListenAndServe(*port, nil))
 }