Add pathops and capture stderr so we can get SkDebugf output.

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
         "encoding/json"
         "flag"
         "fmt"
@@ skipping 240 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 in the case
-// of a non-zero exit code.
+// directory or the inout directory. Returns the stdout and stderr.
 func doCmd(commandLine string, moveToDebug bool) (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)
-        var stdOut bytes.Buffer
-        cmd.Stdout = &stdOut
-        var stdErr bytes.Buffer
-        cmd.Stderr = &stdErr
-        cmd.Start()
-        err = cmd.Wait()
-        message := stdOut.String()
-        log.Printf("StdOut: %s\n", message)
+        message, err := cmd.CombinedOutput()
+        log.Printf("StdOut + StdErr: %s\n", string(message))
         if err != nil {
                 log.Printf("Exit status: %s\n", err.Error())
-                log.Printf("StdErr: %s\n", stdErr.String())
-                message += stdErr.String()
-                return message, fmt.Errorf("Failed to run command.")
+                return string(message), fmt.Errorf("Failed to run command.")
         }
-        return message, nil
+        return string(message), nil
 }
 
 // reportError formats an HTTP error response and also logs the detailed error message.
 func reportError(w http.ResponseWriter, r *http.Request, err error, message string) {
         log.Printf("Error: %s\n%s", message, err.Error())
         http.Error(w, message, 500)
 }
 
 // reportTryError formats an HTTP error response in JSON and also logs the detailed error message.
 func reportTryError(w http.ResponseWriter, r *http.Request, err error, message, hash string) {
@@ skipping 355 matching lines @@
         http.HandleFunc("/w/", workspaceHandler)
         http.HandleFunc("/recent/", recentHandler)
         http.HandleFunc("/iframe/", iframeHandler)
         http.HandleFunc("/json/", tryInfoHandler)
         http.HandleFunc("/css/", cssHandler)
         http.HandleFunc("/js/", jsHandler)
         // TODO Break out /c/ as it's own handler.
         http.HandleFunc("/", mainHandler)
         log.Fatal(http.ListenAndServe(*port, nil))
 }