environs: upload juju tools to cloud.

environs/tools.go

 package environs
 
 import (
         "archive/tar"
         "compress/gzip"
         "fmt"
         "io"
         "io/ioutil"
         "launchpad.net/juju/go/log"
         "launchpad.net/juju/go/version"
         "os"
         "os/exec"
         "path/filepath"
         "regexp"
         "runtime"
         "strings"
 )
 
-var CurrentUbuntuRelease = "precise"                // TODO find out actual version.
-var CurrentArch = ubuntuArch(runtime.GOARCH) // TODO better than this
+// TODO find out actual architecture and Ubuntu release.
+var CurrentSeries = "precise" // current Ubuntu release name.·····
+var CurrentArch = ubuntuArch(runtime.GOARCH)
 
 func ubuntuArch(arch string) string {
         if arch == "386" {
                 arch = "i386"
         }
         return arch
 }
 
 var toolPrefix = "tools/juju-"
 
-var toolFilePat = regexp.MustCompile(`^`+toolPrefix+`(\d+\.\d+\.\d+)-([^-]+)-([^-]+)\.tgz$`)
+var toolFilePat = regexp.MustCompile(`^` + toolPrefix + `(\d+\.\d+\.\d+)-([^-]+)-([^-]+)\.tgz$`)
 
 // toolsPathForVersion returns a path for the juju tools with the
 // given version, OS and architecture.
 func toolsPathForVersion(v version.Version, series, arch string) string {
         return fmt.Sprintf(toolPrefix+"%v-%s-%s.tgz", v, series, arch)
 }
 
 // ToolsPath gives the path for the current juju tools, as expected
 // by environs.Environ.PutFile, for example.
-var toolsPath = toolsPathForVersion(version.Current, CurrentUbuntuRelease, CurrentArch)
+var toolsPath = toolsPathForVersion(version.Current, CurrentSeries, CurrentArch)
 
 // 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.
+// TODO find binaries from $PATH when not using a development
+// version of juju within a $GOPATH.
 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())
@@ skipping 32 matching lines @@
                 if !isExecutable(ent) {
                         return fmt.Errorf("archive: found non-executable file %q", filepath.Join(dir, ent.Name()))
                 }
                 h := tarHeader(ent)
                 // ignore local umask
                 h.Mode = 0755
                 err := tarw.WriteHeader(h)
                 if err != nil {
                         return err
                 }
-                if err := readFile(tarw, filepath.Join(dir, ent.Name())); err != nil {
+                if err := copyFile(tarw, filepath.Join(dir, ent.Name())); err != nil {
                         return err
                 }
         }
         return nil
 }
 
-// readFile writes the contents of the given file to w.
-func readFile(w io.Writer, file string) error {
+// copyFile writes the contents of the given file to w.
+func copyFile(w io.Writer, file string) error {
         f, err := os.Open(file)
         if err != nil {
                 return err
         }
         defer f.Close()
         _, err = io.Copy(w, f)
         return err
 }
 
 // tarHeader returns a tar file header given the file's stat
@@ skipping 20 matching lines @@
 
 // closeErrorCheck means that we can ensure that
 // Close errors do not get lost even when we defer them,
 func closeErrorCheck(errp *error, c io.Closer) {
         err := c.Close()
         if *errp == nil {
                 *errp = err
         }
 }
 
-// FindTools tries to find a set of tools appropriate for the current
-// version and platform and returns a URL that can be used to access
-// them in gzipped tar archive format.
-func FindTools(env Environ) (url string, err error) {
-        storage, path, err := findTools(env)
+type toolsSpec struct {
+        vers   version.Version
+        series string
+        arch   string
+}
+
+// FindTools tries to find a set of tools appropriate for the given
+// version, Ubuntu series and architecture, and returns a URL that can
+// be used to access them in gzipped tar archive format.
+func FindTools(env Environ, vers version.Version, series, arch string) (url string, err error) {
+        storage, path, err := findTools(env, toolsSpec{vers, series, arch})
         if err != nil {
                 return "", err
         }
         return storage.URL(path)
 }
 
 // GetTools finds the latest compatible version of the juju tools
 // and downloads them into the given directory.
 func GetTools(env Environ, dir string) error {
-        storage, path, err := findTools(env)
+        storage, path, err := findTools(env, toolsSpec{version.Current, CurrentSeries, CurrentArch})
         if err != nil {
                 return err
         }
         r, err := storage.Get(path)
         if err != nil {
                 return err
         }
         defer r.Close()
 
         r, err = gzip.NewReader(r)
@@ skipping 17 matching lines @@
 
                 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")
 }
 
 // findToolsPath is an internal version of FindTools that returns the
-// found StorageReader and the path within that storage.
-func findTools(env Environ) (storage StorageReader, path string, err error) {
+// storage in which the tools have been found, and the path within that storage.
+func findTools(env Environ, spec toolsSpec) (storage StorageReader, path string, err error) {
         storage = env.Storage()
-        path, err = findToolsPath(storage)
+        path, err = findToolsPath(storage, spec)
         if _, ok := err.(*NotFoundError); ok {
                 storage = env.PublicStorage()
-                path, err = findToolsPath(storage)
+                path, err = findToolsPath(storage, spec)
         }
         if err != nil {
                 return nil, "", err
         }
         return
 }
 
 // findToolsPath looks for the tools in the given storage.
-func findToolsPath(store StorageReader) (path string, err error) {
-        names, err := store.List(fmt.Sprintf("%s%d.", toolPrefix, version.Current.Major))
+func findToolsPath(store StorageReader, spec toolsSpec) (path string, err error) {
+        names, err := store.List(fmt.Sprintf("%s%d.", toolPrefix, spec.vers.Major))
         if err != nil {
                 return "", err
         }
         if len(names) == 0 {
                 return "", &NotFoundError{fmt.Errorf("no compatible tools found")}
         }
         bestVersion := version.Version{Major: -1}
         bestName := ""
         for _, name := range names {
                 m := toolFilePat.FindStringSubmatch(name)
                 if m == nil {
                         log.Printf("unexpected tools file found %q", name)
                         continue
                 }
                 vers, err := version.Parse(m[1])
                 if err != nil {
                         log.Printf("failed to parse version %q: %v", name, err)
                         continue
                 }
-                if m[2] != CurrentUbuntuRelease {
+                if m[2] != spec.series {
                         continue
                 }
                 // TODO allow different architectures.
-                if m[3] != CurrentArch {
-                        continue
-                }
-                if vers.Major != version.Current.Major {
+                if m[3] != spec.arch {
+                        continue
+                }
+                if vers.Major != spec.vers.Major {
                         continue
                 }
                 if bestVersion.Less(vers) {
                         bestVersion = vers
                         bestName = name
                 }
         }
         if bestVersion.Major < 0 {
                 return "", &NotFoundError{fmt.Errorf("no compatible tools found")}
         }
@@ skipping 24 matching lines @@
 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.
+// 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) URL(string) (string, error) {
         return "", fmt.Errorf("empty storage has no URLs")
 }
 
 func (s emptyStorage) List(prefix string) ([]string, error) {
         return nil, nil
 }