code review 5697050: misc/dist: implement binary distribution scripts in go

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 currently supports FreeBSD, Linux, and OS X.
+// It supports FreeBSD, Linux, and OS X.
 package main
 
 import (
         "bytes"
         "encoding/base64"
         "errors"
         "flag"
         "fmt"
         "io"
         "io/ioutil"
         "log"
         "mime/multipart"
         "net/http"
         "os"
         "os/exec"
         "path/filepath"
         "strings"
 )
 
 var (
-        tag      = flag.String("tag", "weekly", "mercurial tag to check out")
-        repo     = flag.String("repo", "https://code.google.com/p/go", "repo URL")
-        user     = flag.String("user", "builder@golang.org", "Google Code upload username")
-        password = flag.String("password", "", "Google Code upload password")
+        tag  = flag.String("tag", "weekly", "mercurial tag to check out")
+        repo = flag.String("repo", "https://code.google.com/p/go", "repo URL")
+
+        username, password string // for Google Code upload
 )
 
 const (
         packageMaker = "/Applications/Utilities/PackageMaker.app/Contents/MacOS/PackageMaker"
         uploadURL    = "https://go.googlecode.com/files"
 )
 
 var cleanFiles = []string{
         ".hg",
         ".hgtags",
         ".hgignore",
         "VERSION.cache",
 }
 
 func main() {
         flag.Usage = func() {
                 fmt.Fprintf(os.Stderr, "usage: %s [flags] targets...\n", os.Args[0])
                 flag.PrintDefaults()
                 os.Exit(2)
         }
         flag.Parse()
-
-        log.Println((&Build{OS: "darwin", Arch: "amd64"}).upload("weekly.2012-02-22", "go.weekly.2012-02-22.darwin-amd64.pkg"))
-        os.Exit(0)
-
         if flag.NArg() == 0 {
                 flag.Usage()
         }
+        readCredentials()
         for _, targ := range flag.Args() {
                 p := strings.SplitN(targ, "-", 2)
                 if len(p) != 2 {
+                        log.Println("Ignoring unrecognized target:", targ)
                         continue
                 }
-                err := (&Build{OS: p[0], Arch: p[1]}).Do()
-                if err != nil {
+                b := Build{OS: p[0], Arch: p[1]}
+                if err := b.Do(); err != nil {
                         log.Printf("%s: %v", targ, err)
                 }
         }
 }
 
 type Build struct {
-        OS, Arch string
-        root     string
+        OS   string
+        Arch string
+        root 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")
 
@@ skipping 70 matching lines @@
                 scripts := filepath.Join(work, "usr/local/go/misc/dist/darwin/scripts")
                 _, err = b.run("", pm, "-v",
                         "-r", work,
                         "-o", targ,
                         "--scripts", scripts,
                         "--id", "com.googlecode.go",
                         "--title", "Go",
                         "--version", "1.0",
                         "--target", "10.5")
         }
-        if err == nil {
-                log.Println("built", targ)
-                if *password != "" {
-                        err = b.upload(string(v[2]), targ)
-                }
+        if err == nil && password != "" {
+                err = b.upload(string(v[2]), targ)
         }
         return err
 }
 
 func (b *Build) run(dir, name string, args ...string) ([]byte, error) {
         buf := new(bytes.Buffer)
         cmd := exec.Command(name, args...)
         cmd.Stdout = buf
         cmd.Stderr = buf
         cmd.Dir = dir
         cmd.Env = b.env()
         if err := cmd.Run(); err != nil {
                 fmt.Fprintf(os.Stderr, "%s", buf.Bytes())
                 return nil, fmt.Errorf("%s %s: %v", name, strings.Join(args, " "), err)
         }
         return buf.Bytes(), nil
 }
 
+var cleanEnv = []string{
+        "GOARCH",
+        "GOBIN",
+        "GOHOSTARCH",
+        "GOHOSTOS",
+        "GOOS",
+        "GOROOT",
+        "GOROOT_FINAL",
+}
+
 func (b *Build) env() []string {
         env := os.Environ()
         for i := 0; i < len(env); i++ {
-                e := env[i]
-                if strings.HasPrefix(e, "GOROOT=") ||
-                        strings.HasPrefix(e, "GOOS=") ||
-                        strings.HasPrefix(e, "GOARCH=") {
-                        env = append(env[:i], env[i+1:]...)
+                for _, c := range cleanEnv {
+                        if strings.HasPrefix(env[i], c+"=") {
+                                env = append(env[:i], env[i+1:]...)
+                        }
                 }
         }
         env = append(env,
                 "GOARCH="+b.Arch,
                 "GOHOSTARCH="+b.Arch,
                 "GOHOSTOS="+b.OS,
                 "GOOS="+b.OS,
                 "GOROOT="+b.root,
                 "GOROOT_FINAL=/usr/local/go",
         )
         return env
-}
-
-func exists(path string) bool {
-        _, err := os.Stat(path)
-        return err == nil
 }
 
 func (b *Build) upload(version string, filename string) error {
         // Prepare upload metadata.
         labels := []string{"Arch-" + b.Arch}
         os_, arch := b.OS, b.Arch
         switch b.Arch {
         case "386":
                 arch = "32-bit"
         case "amd64":
@@ skipping 39 matching lines @@
         }
         if err := w.Close(); err != nil {
                 return err
         }
 
         // Send the file to Google Code.
         req, err := http.NewRequest("POST", uploadURL, body)
         if err != nil {
                 return err
         }
-        token := fmt.Sprintf("%s:%s", *user, *password)
+        token := fmt.Sprintf("%s:%s", username, password)
         token = base64.StdEncoding.EncodeToString([]byte(token))
         req.Header.Set("Authorization", "Basic "+token)
         req.Header.Set("Content-type", w.FormDataContentType())
 
         resp, err := http.DefaultTransport.RoundTrip(req)
         if err != nil {
                 return err
         }
         if resp.StatusCode/100 != 2 {
                 fmt.Fprintln(os.Stderr, "upload failed")
                 defer resp.Body.Close()
                 io.Copy(os.Stderr, resp.Body)
                 return fmt.Errorf("upload: %s", resp.Status)
         }
         return nil
 }
+
+func exists(path string) bool {
+        _, err := os.Stat(path)
+        return err == nil
+}
+
+func readCredentials() {
+        name := filepath.Join(os.Getenv("HOME"), ".gobuildkey")
+        c, err := ioutil.ReadFile(name)
+        if err != nil {
+                log.Println("readCredentials:", err)
+                return
+        }
+        v := bytes.Split(c, []byte("\n"))
+        if len(v) >= 3 {
+                username, password = string(v[1]), string(v[2])
+        }
+}