iframe

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
         "encoding/json"
         "flag"
         "fmt"
@@ skipping 28 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
 
+        // iframeTemplate is the main index.html page we serve.
+        iframeTemplate *htemplate.Template = nil
+
         // 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]+)$")
 
+        // 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)$")
 
         // 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",
                 "summer", "icy", "delicate", "quiet", "white", "cool", "spring", "winter",
@@ skipping 31 matching lines @@
         lines := strings.Split(c, "\n")
         ret := []string{}
         for i, line := range lines {
                 ret = append(ret, fmt.Sprintf("#line %d", i+1))
                 ret = append(ret, line)
         }
         return strings.Join(ret, "\n")
 }
 
 func init() {
+        rand.Seed(time.Now().UnixNano())

[mtklein, 2014/04/18 16:43:55]

Goes with the other CL?

[jcgregorio, 2014/04/18 17:00:11]

Yeah, caught this in this CL. Since their both going to land back to back I
didn't bother bringing it into the other CL.

On 2014/04/18 16:43:55, mtklein wrote:

[mtklein, 2014/04/18 17:03:01]

SGTM

 
         // Change the current working directory to the directory of the executable.
         var err error
         cwd, err := filepath.Abs(filepath.Dir(os.Args[0]))
         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.
         indexTemplate, err = htemplate.ParseFiles(
                 filepath.Join(cwd, "templates/index.html"),
                 filepath.Join(cwd, "templates/titlebar.html"),
         )
         if err != nil {
                 panic(err)
         }
+        iframeTemplate, err = htemplate.ParseFiles(
+                filepath.Join(cwd, "templates/iframe.html"),
+        )
+        if err != nil {
+                panic(err)
+        }
         recentTemplate, err = htemplate.ParseFiles(
                 filepath.Join(cwd, "templates/recent.html"),
                 filepath.Join(cwd, "templates/titlebar.html"),
         )
         if err != nil {
                 panic(err)
         }
         workspaceTemplate, err = htemplate.ParseFiles(
                 filepath.Join(cwd, "templates/workspace.html"),
                 filepath.Join(cwd, "templates/titlebar.html"),
@@ skipping 55 matching lines @@
           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
+        Hash     string
 }
 
 // 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{UserCode: code})
@@ skipping 229 matching lines @@
                 }
         }
         return false
 }
 
 type TryRequest struct {
         Code string `json:"code"`
         Name string `json:"name"`
 }
 
+// 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
+        // Load '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 := iframeTemplate.Execute(w, userCode{UserCode: code, Hash: hash}); 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)
         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 84 matching lines @@
                 }
                 w.Write(resp)
         }
 }
 
 func main() {
         flag.Parse()
         http.HandleFunc("/i/", imageHandler)
         http.HandleFunc("/w/", workspaceHandler)
         http.HandleFunc("/recent/", recentHandler)
+        http.HandleFunc("/iframe/", iframeHandler)
         http.HandleFunc("/css/", cssHandler)
         http.HandleFunc("/js/", jsHandler)
         http.HandleFunc("/", mainHandler)
         log.Fatal(http.ListenAndServe(*port, nil))
 }