code review 13652043: cmd/api/run: make api check directory per-user

src/cmd/api/run.go

 // Copyright 2013 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // +build ignore
 
 // The run program is invoked via "go run" from src/run.bash or
 // src/run.bat conditionally builds and runs the cmd/api tool.
 //
 // TODO(bradfitz): the "conditional" condition is always true.
 // We should only do this if the user has the hg codereview extension
 // enabled and verifies that the go.tools subrepo is checked out with
 // a suitably recently version. In prep for the cmd/api rewrite.
 package main
 
 import (
         "fmt"
         "log"
         "net/http"
         "os"
         "os/exec"
+        "os/user"
         "path/filepath"
         "strconv"
         "strings"
 )
 
 // goToolsVersion is the hg revision of the go.tools subrepo we need
 // to build cmd/api.  This only needs to be updated whenever a go/types
 // bug fix is needed by the cmd/api tool.
 const goToolsVersion = "6698ca2900e2"
 
@@ skipping 60 matching lines @@
         v, _ := strconv.ParseBool(os.Getenv("GO_FORCE_API_CHECK"))
         return v
 }
 
 // prepGoPath returns a GOPATH for the "go" tool to compile the API tool with.
 // It tries to re-use a go.tools checkout from a previous run if possible,
 // else it hg clones it.
 func prepGoPath() string {
         const tempBase = "go.tools.TMP"
 
+        u, err := user.Current()
+        if err != nil {
+                log.Fatalf("Error getting current user: %v", err)
+        }
+
         // The GOPATH we'll return
-        gopath := filepath.Join(os.TempDir(), "gopath-api", goToolsVersion)
+        gopath := filepath.Join(os.TempDir(), "gopath-api-"+cleanUsername(u.Username), goToolsVersion)
 
         // cloneDir is where we run "hg clone".
         cloneDir := filepath.Join(gopath, "src", "code.google.com", "p")
 
         // The dir we clone into. We only atomically rename it to finalDir on
         // clone success.
         tmpDir := filepath.Join(cloneDir, tempBase)
 
         // finalDir is where the checkout will live once it's complete.
         finalDir := filepath.Join(cloneDir, "go.tools")
@@ skipping 19 matching lines @@
                         os.Exit(0)
                 }
                 log.Fatalf("Error running hg clone on go.tools: %v\n%s", err, out)
         }
         if err := os.Rename(tmpDir, finalDir); err != nil {
                 log.Fatal(err)
         }
         return gopath
 }
 
+func cleanUsername(n string) string {

[brainman, 2013/09/11 00:24:24]

I think you code will read simpler if you just do 3 single line replaces like
this:

https://github.com/golang/glog/blob/master/glog_file.go#L69

for '\\', '/' and ':'.

+        b := make([]rune, len(n))
+        for i, r := range n {
+                if r == '\\' || r == '/' {
+                        b[i] = '_'
+                } else {
+                        b[i] = r
+                }
+        }
+        return string(b)
+}
+
 func goToolsCheckoutGood(dir string) bool {
         if _, err := os.Stat(dir); err != nil {
                 return false
         }
 
         cmd := exec.Command("hg", "id", "--id")
         cmd.Dir = dir
         out, err := cmd.Output()
         if err != nil {
                 return false
         }
         id := strings.TrimSpace(string(out))
         if id != goToolsVersion {
                 return false
         }
 
         cmd = exec.Command("hg", "status")
         cmd.Dir = dir
         out, err = cmd.Output()
         if err != nil || len(out) > 0 {
                 return false
         }
 
         return true
 }