code review 6976045: go/misc: Adding go-tour to the generated packages for e...

misc/dist/bindist.go

 // Copyright 2012 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.
 
 // This is a tool for packaging binary releases.
 // It supports FreeBSD, Linux, NetBSD, OS X, and Windows.
 package main
 
 import (
         "archive/tar"
@@ skipping 13 matching lines @@
         "os/exec"
         "path/filepath"
         "regexp"
         "runtime"
         "strings"
 )
 
 var (
         tag      = flag.String("tag", "release", "mercurial tag to check out")
         repo     = flag.String("repo", "https://code.google.com/p/go", "repo URL")
+        tourPath = flag.String("tour", "code.google.com/p/go-tour", "Go tour repo import path")
         verbose  = flag.Bool("v", false, "verbose output")
         upload   = flag.Bool("upload", true, "upload resulting files to Google Code")
         wxsFile  = flag.String("wxs", "", "path to custom installer.wxs")
         addLabel = flag.String("label", "", "additional label to apply to file when uploading")
-        tourRepo = flag.String("tour", "http://code.google.com/p/go-tour", "Go tour repo URL")
 
         username, password string // for Google Code upload
 )
 
 const (
         uploadURL = "https://go.googlecode.com/files"
 )
 
 var preBuildCleanFiles = []string{
         "lib/codereview",
         "misc/dashboard/godashboard",
         "src/cmd/cov",
         "src/cmd/prof",
         "src/pkg/exp",
         "src/pkg/old",
 }
 
 var cleanFiles = []string{
         ".hg",
         ".hgtags",
         ".hgignore",
         "VERSION.cache",
 }
 
 var sourceCleanFiles = []string{
         "bin",
         "pkg",
+}
+
+var tourPackages = []string{
+        "pic",
+        "tree",
+        "wc",
+}
+
+var tourContent = []string{
+        "prog",
+        "solutions",
+        "static",
+        "template",
+        "tour.article",
 }
 
 var fileRe = regexp.MustCompile(`^go\.([a-z0-9-.]+)\.(src|([a-z0-9]+)-([a-z0-9]+))\.`)
 
 func main() {
         flag.Usage = func() {
                 fmt.Fprintf(os.Stderr, "usage: %s [flags] targets...\n", os.Args[0])
                 flag.PrintDefaults()
                 os.Exit(2)
         }
@@ skipping 45 matching lines @@
                         log.Printf("%s: %v", targ, err)
                 }
         }
 }
 
 type Build struct {
         Source bool // if true, OS and Arch must be empty
         OS     string
         Arch   string
         root   string
+        gopath string
 }
 
 func (b *Build) Do() error {
         work, err := ioutil.TempDir("", "bindist")
         if err != nil {
                 return err
         }
         defer os.RemoveAll(work)
         b.root = filepath.Join(work, "go")
+        b.gopath = work
 
         // Clone Go distribution and update to tag.
         _, err = b.run(work, "hg", "clone", "-q", *repo, b.root)
         if err != nil {
                 return err
         }
         _, err = b.run(b.root, "hg", "update", *tag)
         if err != nil {
                 return err
         }
@@ skipping 193 matching lines @@
                         err = b.Upload(version, targ)
                         if err != nil {
                                 return err
                         }
                 }
         }
         return err
 }
 
 func (b *Build) tour() error {
-        tmp, err := ioutil.TempDir("", "gotour")
-        if err != nil {
-                return err
-        }
-        defer os.RemoveAll(tmp)
-        var (
-                tourRoot = filepath.Join(tmp, "go-tour")
-                tourPkg  = filepath.Join(tourRoot, "gotour")
-                toolPath = filepath.Join(b.root, "pkg", "tool", b.OS+"_"+b.Arch)
-                pkgDir   = filepath.Join(b.root, "src", "pkg")
-                miscDir  = filepath.Join(b.root, "misc", "tour")
+        // go get the gotour package.
+        _, err := b.run(b.gopath, filepath.Join(b.root, "bin", "go"), "get", *tourPath+"/gotour")
+        if err != nil {
+                return err
+        }
+
+        // Copy all the tour content to $GOROOT/misc/tour.
+        importPath := filepath.FromSlash(*tourPath)
+        tourSrc := filepath.Join(b.gopath, "src", importPath)
+        contentDir := filepath.Join(b.root, "misc", "tour")
+        if err = cpAllDir(contentDir, tourSrc, tourContent...); err != nil {
+                return err
+        }
+
+        // Copy the tour source code so it's accessible with $GOPATH pointing to $GOROOT/misc/tour.
+        if err = cpAllDir(filepath.Join(contentDir, "src", importPath), tourSrc, tourPackages...); err != nil {
+                return err
+        }
+
+        // Copy gotour binary to tool directory as "tour"; invoked as "go tool tour".
+        return cp(
+                filepath.Join(b.root, "pkg", "tool", b.OS+"_"+b.Arch, "tour"),
+                filepath.Join(b.gopath, "bin", "gotour"),
         )
-        if err := os.MkdirAll(miscDir, 0755); err != nil {
-                return err
-        }
-
-        cmds := [][]string{
-                {tmp, "hg", "clone", "-q", tourRepoURL, tourRoot},
-                {tourRoot, "hg", "update"},
-                {tourPkg, "go", "build", "-o", "tour"},
-                {tourPkg, "mv", "tour", toolPath},
-                {tourRoot, "mv", "tree", "pic", "wc", pkgDir},
-                {tourRoot, "mv", "static", miscDir},
-        }
-
-        for _, cmd := range cmds {
-                if _, err := b.run(cmd[0], cmd[1], cmd[2:]...); err != nil {
-                        return err
-                }
-        }
-        return nil
 }
 
 func (b *Build) run(dir, name string, args ...string) ([]byte, error) {
         buf := new(bytes.Buffer)
         absName, err := lookPath(name)
         if err != nil {
                 return nil, err
         }
         cmd := exec.Command(absName, args...)
         var output io.Writer = buf
@@ skipping 13 matching lines @@
 }
 
 var cleanEnv = []string{
         "GOARCH",
         "GOBIN",
         "GOHOSTARCH",
         "GOHOSTOS",
         "GOOS",
         "GOROOT",
         "GOROOT_FINAL",
+        "GOPATH",
 }
 
 func (b *Build) env() []string {
         env := os.Environ()
         for i := 0; i < len(env); i++ {
                 for _, c := range cleanEnv {
                         if strings.HasPrefix(env[i], c+"=") {
                                 env = append(env[:i], env[i+1:]...)
                         }
                 }
         }
         final := "/usr/local/go"
         if b.OS == "windows" {
                 final = `c:\go`
         }
         env = append(env,
                 "GOARCH="+b.Arch,
                 "GOHOSTARCH="+b.Arch,
                 "GOHOSTOS="+b.OS,
                 "GOOS="+b.OS,
                 "GOROOT="+b.root,
                 "GOROOT_FINAL="+final,
+                "GOPATH="+b.gopath,
         )
         return env
 }
 
 func (b *Build) Upload(version string, filename string) error {
         // Prepare upload metadata.
         var labels []string
         os_, arch := b.OS, b.Arch
         switch b.Arch {
         case "386":
@@ skipping 153 matching lines @@
         defer sf.Close()
         df, err := os.Create(dst)
         if err != nil {
                 return err
         }
         defer df.Close()
         _, err = io.Copy(df, sf)
         return err
 }
 
+func cpDir(dst, src string) error {
+        walk := func(srcPath string, info os.FileInfo, err error) error {
+                if err != nil {
+                        return err
+                }
+                dstPath := filepath.Join(dst, srcPath[len(src):])
+                if info.IsDir() {
+                        return os.MkdirAll(dstPath, 0755)
+                }
+                return cp(dstPath, srcPath)
+        }
+        return filepath.Walk(src, walk)
+}
+
+func cpAllDir(dst, basePath string, dirs ...string) error {
+        for _, dir := range dirs {
+                if err := cpDir(filepath.Join(dst, dir), filepath.Join(basePath, dir)); err != nil {
+                        return err
+                }
+        }
+        return nil
+}
+
 func makeTar(targ, workdir string) error {
         f, err := os.Create(targ)
         if err != nil {
                 return err
         }
         zout := gzip.NewWriter(f)
         tw := tar.NewWriter(zout)
 
         err = filepath.Walk(workdir, func(path string, fi os.FileInfo, err error) error {
                 if !strings.HasPrefix(path, workdir) {
@@ skipping 178 matching lines @@
                         absPath = filepath.Join(dir, prog+"."+ext)
                         if _, err1 := os.Stat(absPath); err1 == nil {
                                 err = nil
                                 os.Setenv("PATH", os.Getenv("PATH")+";"+dir)
                                 return
                         }
                 }
         }
         return
 }