cmd/juju: add --upload-tools flag to bootstrap command

environs/tools.go

 package environs
 
 import (
         "archive/tar"
         "compress/gzip"
         "fmt"
         "io"
         "io/ioutil"
         "launchpad.net/juju/go/version"
         "os"
         "os/exec"
         "path/filepath"
+        "runtime"
+        "strings"
 )
+
+// toolsPath is the storage path for the juju tools with the
+// same version, OS, and arch as the currently running client.
+var toolsPath = fmt.Sprintf("tools/juju-%v-%s-%s.tgz", version.Current, runtime.GOOS, runtime.GOARCH)
 
 // tarHeader returns a tar file header given the file's stat
 // information.
 func tarHeader(i os.FileInfo) *tar.Header {
         return &tar.Header{
                 Typeflag:   tar.TypeReg,
                 Name:       i.Name(),
                 Size:       i.Size(),
                 Mode:       int64(i.Mode() & 0777),
                 ModTime:    i.ModTime(),
@@ skipping 77 matching lines @@
                 "GOBIN=" + dir,
                 "PATH=" + os.Getenv("PATH"),
         }
         out, err := cmd.CombinedOutput()
         if err != nil {
                 return fmt.Errorf("build failed: %v; %s", err, out)
         }
         return archive(w, dir)
 }
 
-// UploadTools uploads the current version of the juju tools
-// executables to the given environment.
+// PutTools uploads the current version of the juju tools
+// executables to the given storage.
 // TODO find binaries from $PATH when go dev environment not available.
-func UploadTools(env Environ) error {
+func PutTools(storage StorageWriter) error {
         // We create the entire archive before asking the environment to
         // start uploading so that we can be sure we have archived
         // correctly.
         f, err := ioutil.TempFile("", "juju-tgz")
         if err != nil {
                 return err
         }
         defer f.Close()
         defer os.Remove(f.Name())
         err = bundleTools(f)
         if err != nil {
                 return err
         }
         _, err = f.Seek(0, 0)
         if err != nil {
                 return err
         }
         fi, err := f.Stat()
         if err != nil {
                 return err
         }
-        return env.PutFile(version.ToolsPath, f, fi.Size())
-}
+        return storage.Put(toolsPath, f, fi.Size())
+}
+
+// GetTools finds the latest compatible version of the juju tools
+// and downloads and extracts them into the given directory.
+func GetTools(storage StorageReader, dir string) error {
+        // TODO search the storage for the right tools version.
+        r, err := storage.Get(toolsPath)
+        if err != nil {
+                return err
+        }
+        defer r.Close()
+
+        r, err = gzip.NewReader(r)
+        if err != nil {
+                return err
+        }
+        defer r.Close()
+
+        tr := tar.NewReader(r)
+        for {
+                hdr, err := tr.Next()
+                if err != nil {
+                        if err == io.EOF {
+                                err = nil
+                        }
+                        return err
+                }
+                if strings.Contains(hdr.Name, "/\\") {
+                        return fmt.Errorf("bad name %q in tools archive", hdr.Name)
+                }
+
+                name := filepath.Join(dir, hdr.Name)
+                if err := writeFile(name, os.FileMode(hdr.Mode&0777), tr); err != nil {
+                        return fmt.Errorf("tar extract %q failed: %v", name, err)
+                }
+        }
+        panic("not reached")
+}
+
+func writeFile(name string, mode os.FileMode, r io.Reader) error {
+        f, err := os.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, mode)
+        if err != nil {
+                return err
+        }
+        defer f.Close()
+        _, err = io.Copy(f, r)
+        return err
+}
+
+// EmptyStorage holds a StorageReader object
+// that contains nothing.
+var EmptyStorage StorageReader = emptyStorage{}
+
+type emptyStorage struct{}
+
+func (s emptyStorage) Get(name string) (io.ReadCloser, error) {
+        return nil, &NotFoundError{fmt.Errorf("file %q not found in empty storage", name)}
+}
+
+func (s emptyStorage) List(prefix string) ([]string, error) {
+        return nil, nil
+}