complete overhaul of webtry work partition between jail and host

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
         "encoding/binary"
         "encoding/json"
         "flag"
@@ skipping 18 matching lines @@
 )
 
 import (
         "github.com/fiorix/go-web/autogzip"
         _ "github.com/go-sql-driver/mysql"
         _ "github.com/mattn/go-sqlite3"
         "github.com/rcrowley/go-metrics"
 )
 
 const (
-        RUN_GYP   = `../../experimental/webtry/gyp_for_webtry %s -Dskia_gpu=0`
-        RUN_NINJA = `ninja -C ../../../inout/Release %s`
 
         DEFAULT_SAMPLE = `void draw(SkCanvas* canvas) {
     SkPaint p;
     p.setColor(SK_ColorRED);
     p.setAntiAlias(true);
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(10);
 
     canvas->drawLine(20, 20, 100, 100, p);
 }`
@@ skipping 142 matching lines @@
                 filepath.Join(cwd, "templates/footercommon.html"),
         )
         if err != nil {
                 panic(err)
         }
 
         // The git command returns output of the format:
         //
         //   f672cead70404080a991ebfb86c38316a4589b23 2014-04-27 19:21:51 +0000
         //
-        logOutput, err := doCmd(`git log --format=%H%x20%ai HEAD^..HEAD`, true)
+        logOutput, err := doCmd(`git log --format=%H%x20%ai HEAD^..HEAD`)
         if err != nil {
                 panic(err)
         }
         logInfo := strings.Split(logOutput, " ")
         gitHash = logInfo[0]
         gitInfo = logInfo[1] + " " + logInfo[2] + " " + logInfo[0][0:6]
 
         // 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)
@@ skipping 173 matching lines @@
 }
 
 // response is serialized to JSON as a response to POSTs.
 type response struct {
         Message string `json:"message"`
         StdOut  string `json:"stdout"`
         Img     string `json:"img"`
         Hash    string `json:"hash"`
 }
 
-// doCmd executes the given command line string in either the out/Debug
-// directory or the inout directory. Returns the stdout and stderr.
-func doCmd(commandLine string, moveToDebug bool) (string, error) {
+// doCmd executes the given command line string; the command being
+// run is expected to not care what its current working directory is.
+// Returns the stdout and stderr.
+func doCmd(commandLine string) (string, error) {
         log.Printf("Command: %q\n", commandLine)
         programAndArgs := strings.SplitN(commandLine, " ", 2)
         program := programAndArgs[0]
         args := []string{}
         if len(programAndArgs) > 1 {
                 args = strings.Split(programAndArgs[1], " ")
         }
         cmd := exec.Command(program, args...)
-        abs, err := filepath.Abs("../../out/Debug")
-        if err != nil {
-                return "", fmt.Errorf("Failed to find absolute path to Debug directory.")
-        }
-        if moveToDebug {
-                cmd.Dir = abs
-        } else if !*useChroot { // Don't set cmd.Dir when using chroot.
-                abs, err := filepath.Abs("../../../inout")
-                if err != nil {
-                        return "", fmt.Errorf("Failed to find absolute path to inout directory.")
-                }
-                cmd.Dir = abs
-        }
-        log.Printf("Run in directory: %q\n", cmd.Dir)
         message, err := cmd.CombinedOutput()
         log.Printf("StdOut + StdErr: %s\n", string(message))
         if err != nil {
                 log.Printf("Exit status: %s\n", err.Error())
                 return string(message), fmt.Errorf("Failed to run command.")
         }
         return string(message), nil
 }
 
 // reportError formats an HTTP error response and also logs the detailed error message.
@@ skipping 390 matching lines @@
                 if err != nil {
                         reportTryError(w, r, err, "Failed to write the code to compile.", hash)
                         return
                 }
                 writeToDatabase(hash, request.Code, request.Name, request.Source)
                 err = expandGyp(hash)
                 if err != nil {
                         reportTryError(w, r, err, "Failed to write the gyp file.", hash)
                         return
                 }
-                message, err := doCmd(fmt.Sprintf(RUN_GYP, hash), true)
-                if err != nil {
-                        message = cleanCompileOutput(message, hash)
-                        reportTryError(w, r, err, message, hash)
-                        return
-                }
-                linkMessage, err := doCmd(fmt.Sprintf(RUN_NINJA, hash), true)
-                if err != nil {
-                        linkMessage = cleanCompileOutput(linkMessage, hash)
-                        reportTryError(w, r, err, linkMessage, hash)
-                        return
-                }
-                message += linkMessage
-                cmd := hash + " --out " + hash + ".png"
+                cmd := "scripts/fiddle_wrapper " + hash
+                if *useChroot {
+                        cmd = "schroot -c webtry --directory=/ -- /skia_build/skia/experimental/webtry/" + cmd
+                } 
                 if request.Source > 0 {
-                        cmd += fmt.Sprintf("  --source image-%d.png", request.Source)
-                }
-                if *useChroot {
-                        cmd = "schroot -c webtry --directory=/inout -- /inout/Release/" + cmd
-                } else {
-                        abs, err := filepath.Abs("../../../inout/Release")
-                        if err != nil {
-                                reportTryError(w, r, err, "Failed to find executable directory.", hash)
-                                return
-                        }
-                        cmd = abs + "/" + cmd
+                        cmd += fmt.Sprintf(" image-%d.png", request.Source)
                 }
 
-                execMessage, err := doCmd(cmd, false)
+                message, err := doCmd(cmd)
                 if err != nil {
-                        reportTryError(w, r, err, "Failed to run the code:\n"+execMessage, hash)
+                        reportTryError(w, r, err, "Failed to run the code:\n"+message, hash)
                         return
                 }
                 png, err := ioutil.ReadFile("../../../inout/" + hash + ".png")
                 if err != nil {
                         reportTryError(w, r, err, "Failed to open the generated PNG.", hash)
                         return
                 }
 
                 m := response{
                         Message: message,
-                        StdOut:  execMessage,
                         Img:     base64.StdEncoding.EncodeToString([]byte(png)),
                         Hash:    hash,
                 }
                 resp, err := json.Marshal(m)
                 if err != nil {
                         reportTryError(w, r, err, "Failed to serialize a response.", hash)
                         return
                 }
                 w.Header().Set("Content-Type", "application/json")
                 w.Write(resp)
@@ skipping 10 matching lines @@
         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))
 }