[errors] Greatly simplify common/errors package.

vpython/venv/venv_resources_test.go

 // Copyright 2017 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package venv
 
 import (
         "archive/zip"
         "crypto/sha256"
         "encoding/hex"
@@ skipping 73 matching lines @@
 //
 // This online setup is preferred to actually checking these binary files into
 // Git, as it offers more versatility and doesn't clutter Git with binary junk.
 //
 // To optimize repeated test re-executions, withTestEnvironment will also cache
 // the downloaded artifacts in a cache directory. All artifacts will be verified
 // by their SHA256 hashes, which will be baked into the source here.
 func loadTestEnvironment(ctx context.Context, t *testing.T) (*testingLoader, error) {
         wd, err := os.Getwd()
         if err != nil {
-                return nil, errors.Annotate(err).Reason("failed to get working directory").Err()
+                return nil, errors.Annotate(err, "failed to get working directory").Err()
         }
 
         cacheDir := filepath.Join(wd, ".venv_test_cache")
         if err := filesystem.MakeDirs(cacheDir); err != nil {
-                return nil, errors.Annotate(err).Reason("failed to create cache dir").Err()
+                return nil, errors.Annotate(err, "failed to create cache dir").Err()
         }
 
         tl := testingLoader{
                 cacheDir: cacheDir,
         }
         return &tl, tl.withCacheLock(t, func() error {
                 return tl.ensureRemoteFilesLocked(ctx, t)
         })
 }
 
@@ skipping 41 matching lines @@
 func (tl *testingLoader) installPackage(name, root string) error {
         switch name {
         case "foo/bar/virtualenv":
                 return unzip(tl.virtualEnvZIP, root)
         case "foo/bar/shirt":
                 return copyFileIntoDir(tl.shirtWheelPath, root)
         case "foo/bar/pants":
                 return copyFileIntoDir(tl.pantsWheelPath, root)
 
         default:
-                return errors.Reason("don't know how to install %(package)q").
-                        D("package", name).
-                        Err()
+                return errors.Reason("don't know how to install %q", name).Err()
         }
 }
 
 func (tl *testingLoader) buildWheelLocked(t *testing.T, py *python.Interpreter, name, outDir string) (string, error) {
         ctx := context.Background()
         w, err := wheel.ParseName(name)
         if err != nil {
-                return "", errors.Annotate(err).Reason("failed to parse wheel name %(name)q").
-                        D("name", name).
-                        Err()
+                return "", errors.Annotate(err, "failed to parse wheel name %q", name).Err()
         }
 
         outWheelPath := filepath.Join(outDir, w.String())
         switch _, err := os.Stat(outWheelPath); {
         case err == nil:
                 t.Logf("Using cached wheel for %q: %s", name, outWheelPath)
                 return outWheelPath, nil
 
         case os.IsNotExist(err):
                 // Will build a new wheel.
                 break
 
         default:
-                return "", errors.Annotate(err).Reason("failed to stat wheel path [%(path)s]").
-                        D("path", outWheelPath).
-                        Err()
+                return "", errors.Annotate(err, "failed to stat wheel path [%s]", outWheelPath).Err()
         }
 
         srcDir := filepath.Join(testDataDir, w.Distribution+".src")
 
         // Create a bootstrap wheel-generating VirtualEnv!
         cfg := Config{
                 MaxHashLen: 1, // Only going to be 1 enviroment.
                 BaseDir:    filepath.Join(outDir, ".env"),
                 Python:     py.Python,
                 Package: vpython.Spec_Package{
@@ skipping 27 matching lines @@
                 // expected forms on all systems.
                 err := With(ctx, cfg, true, func(ctx context.Context, env *Env) error {
                         cmd := env.Interpreter().IsolatedCommand(ctx,
                                 "setup.py",
                                 "--no-user-cfg",
                                 "bdist_wheel",
                                 "--bdist-dir", buildDir,
                                 "--dist-dir", distDir)
                         cmd.Dir = srcDir
                         if err := cmd.Run(); err != nil {
-                                return errors.Annotate(err).Reason("failed to build wheel").Err()
+                                return errors.Annotate(err, "failed to build wheel").Err()
                         }
                         return nil
                 })
                 if err != nil {
-                        return errors.Annotate(err).Reason("failed to build wheel").Err()
+                        return errors.Annotate(err, "failed to build wheel").Err()
                 }
 
                 // Assert that the expected wheel file was generated, and copy it into
                 // outDir.
                 wheelPath := filepath.Join(distDir, w.String())
                 if _, err := os.Stat(wheelPath); err != nil {
-                        return errors.Annotate(err).Reason("failed to generate wheel").Err()
+                        return errors.Annotate(err, "failed to generate wheel").Err()
                 }
                 if err := copyFileIntoDir(wheelPath, outDir); err != nil {
-                        return errors.Annotate(err).Reason("failed to install wheel").Err()
+                        return errors.Annotate(err, "failed to install wheel").Err()
                 }
 
                 return nil
         })
         if err != nil {
                 return "", err
         }
 
         t.Logf("Generated wheel file %q: %s", name, outWheelPath)
         return outWheelPath, nil
@@ skipping 28 matching lines @@
                 for _, url := range rf.urls {
                         err := cacheFromURLLocked(t, cachePath, rf.contentHash, url)
                         if err == nil {
                                 t.Logf("Cached remote file [%s] from URL [%s]: [%s]", rf.name, url, cachePath)
                                 rf.install(tl, cachePath)
                                 continue MainLoop
                         }
                         t.Logf("Failed to load from URL %q: %s", url, err)
                 }
 
-                return errors.Reason("failed to acquire remote file %(name)q").
-                        D("name", rf.name).
-                        Err()
+                return errors.Reason("failed to acquire remote file %q", rf.name).Err()
         }
 
         return nil
 }
 
 func getCachedFileLocked(t *testing.T, cachePath, hash string) error {
         return validateHash(t, cachePath, hash, true)
 }
 
 func validateHash(t *testing.T, path, hash string, deleteIfInvalid bool) error {
         fd, err := os.Open(path)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to open file").Err()
+                return errors.Annotate(err, "failed to open file").Err()
         }
         defer fd.Close()
 
         h := sha256.New()
         if _, err := io.Copy(h, fd); err != nil {
-                return errors.Annotate(err).Reason("failed to hash file").Err()
+                return errors.Annotate(err, "failed to hash file").Err()
         }
 
         if err := hashesEqual(h, hash); err != nil {
                 t.Logf("File [%s] has invalid hash: %s", path, err)
 
                 if deleteIfInvalid {
                         if err := os.Remove(path); err != nil {
                                 t.Logf("Failed to delete invalid hash file [%s]: %s", path, err)
                         }
                 }
                 return err
         }
 
         return nil
 }
 
 func hashesEqual(h hash.Hash, expected string) error {
         if v := hex.EncodeToString(h.Sum(nil)); v != expected {
-                return errors.Reason("hash %(actual)q doesn't match expected %(expected)q").
-                        D("actual", v).
-                        D("expected", expected).
-                        Err()
+                return errors.Reason("hash %q doesn't match expected %q", v, expected).Err()
         }
         return nil
 }
 
 var testCIPDClientOptions = cipd.ClientOptions{
         ServiceURL: chromeinfra.CIPDServiceURL,
         UserAgent:  "vpython venv tests",
 }
 
 func cacheFromCIPDLocked(ctx context.Context, t *testing.T, cachePath, name, hash, pkg, version string) error {
         return testfs.WithTempDir(t, "vpython_venv_cipd", func(tdir string) error {
                 opts := testCIPDClientOptions
                 opts.Root = tdir
 
                 client, err := cipd.NewClient(opts)
                 if err != nil {
-                        return errors.Annotate(err).Reason("failed to create CIPD client").Err()
+                        return errors.Annotate(err, "failed to create CIPD client").Err()
                 }
 
                 pin, err := client.ResolveVersion(ctx, pkg, version)
                 if err != nil {
-                        return errors.Annotate(err).Reason("failed to resolve CIPD version for %(pkg)s @%(version)s").
-                                D("pkg", pkg).
-                                D("version", version).
-                                Err()
+                        return errors.Annotate(err, "failed to resolve CIPD version for %s @%s", pkg, version).Err()
                 }
 
                 if err := client.FetchAndDeployInstance(ctx, "", pin); err != nil {
-                        return errors.Annotate(err).Reason("failed to fetch/deploy CIPD package").Err()
+                        return errors.Annotate(err, "failed to fetch/deploy CIPD package").Err()
                 }
 
                 path := filepath.Join(opts.Root, name)
                 if err := validateHash(t, path, hash, false); err != nil {
                         // Do not export the invalid path.
                         return err
                 }
 
                 if err := copyFile(path, cachePath, nil); err != nil {
-                        return errors.Annotate(err).Reason("failed to install CIPD package file").Err()
+                        return errors.Annotate(err, "failed to install CIPD package file").Err()
                 }
 
                 return nil
         })
 }
 
 func cacheFromURLLocked(t *testing.T, cachePath, hash, url string) (err error) {
         resp, err := http.Get(url)
         if err != nil {
                 t.Logf("Failed to GET file from URL [%s]: %s", url, err)
         }
         defer resp.Body.Close()
 
         fd, err := os.Create(cachePath)
         if err != nil {
                 t.Logf("Failed to create output file [%s]: %s", cachePath, err)
         }
         defer func() {
                 if closeErr := fd.Close(); closeErr != nil && err == nil {
-                        err = errors.Annotate(closeErr).Reason("failed to close file").Err()
+                        err = errors.Annotate(closeErr, "failed to close file").Err()
                 }
         }()
 
         h := sha256.New()
         tr := io.TeeReader(resp.Body, h)
         if _, err := io.Copy(fd, tr); err != nil {
-                return errors.Annotate(err).Reason("failed to download").Err()
+                return errors.Annotate(err, "failed to download").Err()
         }
 
         if err = hashesEqual(h, hash); err != nil {
                 return
         }
         return nil
 }
 
 func unzip(src, dst string) error {
         fd, err := zip.OpenReader(src)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to open ZIP reader").Err()
+                return errors.Annotate(err, "failed to open ZIP reader").Err()
         }
         defer fd.Close()
 
         for _, f := range fd.File {
                 path := filepath.Join(dst, filepath.FromSlash(f.Name))
                 fi := f.FileInfo()
 
                 // Unzip this entry.
                 if fi.IsDir() {
                         if err := os.MkdirAll(path, 0755); err != nil {
-                                return errors.Annotate(err).Reason("failed to mkdir").Err()
+                                return errors.Annotate(err, "failed to mkdir").Err()
                         }
                 } else {
                         if err := copyFileOpener(f.Open, path, fi); err != nil {
                                 return err
                         }
                 }
         }
         return nil
 }
 
 func copyFileIntoDir(src, dstDir string) error {
         return copyFile(src, filepath.Join(dstDir, filepath.Base(src)), nil)
 }
 
 func copyFile(src, dst string, fi os.FileInfo) error {
         opener := func() (io.ReadCloser, error) { return os.Open(src) }
         return copyFileOpener(opener, dst, fi)
 }
 
 func copyFileOpener(opener func() (io.ReadCloser, error), dst string, fi os.FileInfo) (err error) {
         sfd, err := opener()
         if err != nil {
-                return errors.Annotate(err).Reason("failed to open source").Err()
+                return errors.Annotate(err, "failed to open source").Err()
         }
         defer sfd.Close()
 
         dfd, err := os.Create(dst)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to create destination").Err()
+                return errors.Annotate(err, "failed to create destination").Err()
         }
         defer func() {
                 if closeErr := dfd.Close(); closeErr != nil && err == nil {
-                        err = errors.Annotate(closeErr).Reason("failed to close destination").Err()
+                        err = errors.Annotate(closeErr, "failed to close destination").Err()
                 }
         }()
 
         if _, err := io.Copy(dfd, sfd); err != nil {
-                return errors.Annotate(err).Reason("failed to copy file").Err()
+                return errors.Annotate(err, "failed to copy file").Err()
         }
         if fi != nil {
                 if err := os.Chmod(dst, fi.Mode()); err != nil {
-                        return errors.Annotate(err).Reason("failed to chmod").Err()
+                        return errors.Annotate(err, "failed to chmod").Err()
                 }
         }
         return nil
 }