all: use errgo instead of fmt.Errorf

agent/tools/toolsdir.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package tools
 
 import (
         "archive/tar"
         "compress/gzip"
         "crypto/sha256"
         "encoding/json"
         "fmt"
         "io"
         "io/ioutil"
         "os"
         "path"
         "strings"
 
-        "github.com/errgo/errgo"
+        "github.com/juju/errgo/errors"
 
         coretools "launchpad.net/juju-core/tools"
         "launchpad.net/juju-core/version"
 )
 
 const toolsFile = "downloaded-tools.txt"
 
 // SharedToolsDir returns the directory that is used to
 // store binaries for the given version of the juju tools
 // within the dataDir directory.
@@ skipping 27 matching lines @@
         _, err = io.Copy(f, zr)
         if err != nil {
                 return err
         }
         defer os.Remove(f.Name())
         // TODO(wallyworld) - 2013-09-24 bug=1229512
         // When we can ensure all tools records have valid checksums recorded,
         // we can remove this test short circuit.
         gzipSHA256 := fmt.Sprintf("%x", sha256hash.Sum(nil))
         if tools.SHA256 != "" && tools.SHA256 != gzipSHA256 {
-                return fmt.Errorf("tarball sha256 mismatch, expected %s, got %s", tools.SHA256, gzipSHA256)
+                return errors.Newf("tarball sha256 mismatch, expected %s, got %s", tools.SHA256, gzipSHA256)
         }
 
         // Make a temporary directory in the tools directory,
         // first ensuring that the tools directory exists.
         toolsDir := path.Join(dataDir, "tools")
         err = os.MkdirAll(toolsDir, 0755)
         if err != nil {
                 return err
         }
         dir, err := ioutil.TempDir(toolsDir, "unpacking-")
@@ skipping 10 matching lines @@
         tr := tar.NewReader(f)
         for {
                 hdr, err := tr.Next()
                 if err == io.EOF {
                         break
                 }
                 if err != nil {
                         return err
                 }
                 if strings.ContainsAny(hdr.Name, "/\\") {
-                        return fmt.Errorf("bad name %q in tools archive", hdr.Name)
+                        return errors.Newf("bad name %q in tools archive", hdr.Name)
                 }
                 if hdr.Typeflag != tar.TypeReg {
-                        return fmt.Errorf("bad file type %c in file %q in tools archive", hdr.Typeflag, hdr.Name)
+                        return errors.Newf("bad file type %c in file %q in tools archive", hdr.Typeflag, hdr.Name)
                 }
                 name := path.Join(dir, hdr.Name)
                 if err := writeFile(name, os.FileMode(hdr.Mode&0777), tr); err != nil {
-                        return errgo.Annotatef(err, "tar extract %q failed", name)
+                        return errors.Notef(err, "tar extract %q failed", name)
                 }
         }
         toolsMetadataData, err := json.Marshal(tools)
         if err != nil {
                 return err
         }
         err = ioutil.WriteFile(path.Join(dir, toolsFile), []byte(toolsMetadataData), 0644)
         if err != nil {
                 return err
         }
@@ skipping 28 matching lines @@
         return err
 }
 
 // ReadTools checks that the tools information for the given version exists
 // in the dataDir directory, and returns a Tools instance.
 // The tools information is json encoded in a text file, "downloaded-tools.txt".
 func ReadTools(dataDir string, vers version.Binary) (*coretools.Tools, error) {
         dir := SharedToolsDir(dataDir, vers)
         toolsData, err := ioutil.ReadFile(path.Join(dir, toolsFile))
         if err != nil {
-                return nil, fmt.Errorf("cannot read tools metadata in tools directory: %v", err)
+                return nil, errors.Notef(err, "cannot read tools metadata in tools directory")
         }
         var tools coretools.Tools
         if err := json.Unmarshal(toolsData, &tools); err != nil {
-                return nil, fmt.Errorf("invalid tools metadata in tools directory %q: %v", dir, err)
+                return nil, errors.Notef(err, "invalid tools metadata in tools directory %q", dir)
         }
         return &tools, nil
 }
 
 // ChangeAgentTools atomically replaces the agent-specific symlink
 // under dataDir so it points to the previously unpacked
 // version vers. It returns the new tools read.
 func ChangeAgentTools(dataDir string, agentName string, vers version.Binary) (*coretools.Tools, error) {
         tools, err := ReadTools(dataDir, vers)
         if err != nil {
                 return nil, err
         }
         tmpName := ToolsDir(dataDir, "tmplink-"+agentName)
         err = os.Symlink(tools.Version.String(), tmpName)
         if err != nil {
-                return nil, fmt.Errorf("cannot create tools symlink: %v", err)
+                return nil, errors.Notef(err, "cannot create tools symlink")
         }
         err = os.Rename(tmpName, ToolsDir(dataDir, agentName))
         if err != nil {
-                return nil, fmt.Errorf("cannot update tools symlink: %v", err)
+                return nil, errors.Notef(err, "cannot update tools symlink")
         }
         return tools, nil
 }