environs: remove VarDir global

environs/tools.go

 package environs
 
 import (
         "archive/tar"
         "compress/gzip"
         "fmt"
         "io"
         "io/ioutil"
         "launchpad.net/juju-core/log"
         "launchpad.net/juju-core/state"
@@ skipping 217 matching lines @@
                 if bestTools == nil || bestTools.Number.Less(t.Number) {
                         bestTools = t
                 }
         }
         return bestTools
 }
 
 const urlFile = "downloaded-url.txt"
 
 // toolsParentDir returns the tools parent directory.
-func toolsParentDir(varDir string) string {
-        return path.Join(varDir, "tools")
+func toolsParentDir(dataDir string) string {
+        return path.Join(dataDir, "tools")
 }
 
 // UnpackTools reads a set of juju tools in gzipped tar-archive
 // format and unpacks them into the appropriate tools directory
-// within varDir. If a valid tools directory already exists,
+// within dataDir. If a valid tools directory already exists,
 // UnpackTools returns without error.
-func UnpackTools(varDir string, tools *state.Tools, r io.Reader) (err error) {
+func UnpackTools(dataDir string, tools *state.Tools, r io.Reader) (err error) {
         zr, err := gzip.NewReader(r)
         if err != nil {
                 return err
         }
         defer zr.Close()
 
         // Make a temporary directory in the tools directory,
         // first ensuring that the tools directory exists.
-        err = os.MkdirAll(toolsParentDir(varDir), 0755)
-        if err != nil {
-                return err
-        }
-        dir, err := ioutil.TempDir(toolsParentDir(varDir), "unpacking-")
+        err = os.MkdirAll(toolsParentDir(dataDir), 0755)
+        if err != nil {
+                return err
+        }
+        dir, err := ioutil.TempDir(toolsParentDir(dataDir), "unpacking-")
         if err != nil {
                 return err
         }
         defer removeAll(dir)
 
         tr := tar.NewReader(zr)
         for {
                 hdr, err := tr.Next()
                 if err == io.EOF {
                         break
@@ skipping 10 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)
                 }
         }
         err = ioutil.WriteFile(filepath.Join(dir, urlFile), []byte(tools.URL), 0644)
         if err != nil {
                 return err
         }
 
-        err = os.Rename(dir, ToolsDir(varDir, tools.Binary))
+        err = os.Rename(dir, ToolsDir(dataDir, tools.Binary))
         // If we've failed to rename the directory, it may be because
         // the directory already exists - if ReadTools succeeds, we
         // assume all's ok.
         if err != nil {
-                _, err := ReadTools(varDir, tools.Binary)
+                _, err := ReadTools(dataDir, tools.Binary)
                 if err == nil {
                         return nil
                 }
         }
         return nil
 }
 
 func removeAll(dir string) {
         err := os.RemoveAll(dir)
         if err == nil || os.IsNotExist(err) {
                 return
         }
         log.Printf("environs: cannot remove %q: %v", dir, err)
 }
 
 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
 }
 
 // ReadTools checks that the tools for the given version exist
-// in the varDir directory, and returns a Tools instance describing them.
-func ReadTools(varDir string, vers version.Binary) (*state.Tools, error) {
-        dir := ToolsDir(varDir, vers)
+// in the dataDir directory, and returns a Tools instance describing them.
+func ReadTools(dataDir string, vers version.Binary) (*state.Tools, error) {
+        dir := ToolsDir(dataDir, vers)
         urlData, err := ioutil.ReadFile(filepath.Join(dir, urlFile))
         if err != nil {
                 return nil, fmt.Errorf("cannot read URL in tools directory: %v", err)
         }
         url := strings.TrimSpace(string(urlData))
         if len(url) == 0 {
                 return nil, fmt.Errorf("empty URL in tools directory %q", dir)
         }
         // TODO(rog): do more verification here too, such as checking
         // for the existence of certain files.
         return &state.Tools{
                 URL:    url,
                 Binary: vers,
         }, nil
 }
 
 // ChangeAgentTools atomically replaces the agent-specific symlink
-// under varDir so it points to the previously unpacked
+// under dataDir so it points to the previously unpacked
 // version vers. It returns the new tools read.
-func ChangeAgentTools(varDir string, agentName string, vers version.Binary) (*state.Tools, error) {
-        tools, err := ReadTools(varDir, vers)
-        if err != nil {
-                return nil, err
-        }
-        tmpName := AgentToolsDir(varDir, "tmplink-"+agentName)
+func ChangeAgentTools(dataDir string, agentName string, vers version.Binary) (*state.Tools, error) {
+        tools, err := ReadTools(dataDir, vers)
+        if err != nil {
+                return nil, err
+        }
+        tmpName := AgentToolsDir(dataDir, "tmplink-"+agentName)
         err = os.Symlink(tools.Binary.String(), tmpName)
         if err != nil {
                 return nil, fmt.Errorf("cannot create tools symlink: %v", err)
         }
-        err = os.Rename(tmpName, AgentToolsDir(varDir, agentName))
+        err = os.Rename(tmpName, AgentToolsDir(dataDir, agentName))
         if err != nil {
                 return nil, fmt.Errorf("cannot update tools symlink: %v", err)
         }
         return tools, nil
 }
 
 // ToolsStoragePath returns the slash-separated path that is used to store and
 // retrieve the given version of the juju tools in a Storage.
 func ToolsStoragePath(vers version.Binary) string {
         return toolPrefix + vers.String() + ".tgz"
 }
 
 // ToolsDir returns the slash-separated directory name that is used to
 // store binaries for the given version of the juju tools
-// within the varDir directory.
-func ToolsDir(varDir string, vers version.Binary) string {
-        return path.Join(varDir, "tools", vers.String())
+// within the dataDir directory.
+func ToolsDir(dataDir string, vers version.Binary) string {
+        return path.Join(dataDir, "tools", vers.String())
 }
 
 // AgentToolsDir returns the slash-separated directory name that is used
 // to store binaries for the tools used by the given agent
-// within the given varDir directory.
+// within the given dataDir directory.
 // Conventionally it is a symbolic link to the actual tools directory.
-func AgentToolsDir(varDir, agentName string) string {
-        return path.Join(varDir, "tools", agentName)
+func AgentToolsDir(dataDir, agentName string) string {
+        return path.Join(dataDir, "tools", agentName)
 }
 
 // ToolsSearchFlags gives options when searching
 // for tools.
 type ToolsSearchFlags int
 
 const (
         // HighestVersion indicates that versions above the version being
         // searched for may be included in the search. The default behavior
         // is to search for versions <= the one provided.
@@ skipping 84 matching lines @@
         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
 }