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")
@@ skipping 10 matching lines @@
                 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 += stdErr.String()

[mtklein, 2014/04/28 13:27:36]

Perhaps we should use the same buffer for stdout and stderr so the messages are
interlaced?

[jcgregorio, 2014/04/28 13:39:36]

Done.

+        log.Printf("StdOut + StdErr: %s\n", 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 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)
 }
@@ skipping 358 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))
 }