[errors] Greatly simplify common/errors package.

vpython/cipd/cipd.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 cipd
 
 import (
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/vpython/api/vpython"
@@ skipping 43 matching lines @@
         }
 
         // Build our aggregate template parameters. We prefer our template parameters
         // over the local system parameters. This allows us to override CIPD template
         // parameters elsewhere, and in the production case we will not override
         // any CIPD template parameters.
         template := common.TemplateArgs()
         if pl.Template != nil {
                 loaderTemplate, err := pl.Template(c, e)
                 if err != nil {
-                        return errors.Annotate(err).Reason("failed to get CIPD template arguments").Err()
+                        return errors.Annotate(err, "failed to get CIPD template arguments").Err()
                 }
                 for k, v := range loaderTemplate {
                         template[k] = v
                 }
         }
 
         // Create a single package list. Our VirtualEnv will be index 0 (need
         // this so we can back-port it into its VirtualEnv property).
         //
         // These will be updated to their resolved values in-place.
@@ skipping 33 matching lines @@
                 }
 
                 logging.Debugf(c, "\tUnresolved package: %s", pkg)
         }
         ef := ensure.File{
                 PackagesBySubdir: map[string]ensure.PackageSlice{"": pslice},
         }
 
         client, err := cipd.NewClient(opts)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to generate CIPD client").Err()
+                return errors.Annotate(err, "failed to generate CIPD client").Err()
         }
 
         // Start a CIPD client batch.
         client.BeginBatch(c)
         defer client.EndBatch(c)
 
         // Resolve our ensure file.
         resolved, err := ef.ResolveWith(func(pkg, vers string) (common.Pin, error) {
                 pin, err := client.ResolveVersion(c, pkg, vers)
                 if err != nil {
-                        return pin, errors.Annotate(err).Reason("failed to resolve package %(package)q at version %(version)q").
-                                D("package", pkg).
-                                D("version", vers).
-                                Err()
+                        return pin, errors.Annotate(err, "failed to resolve package %q at version %q", pkg, vers).Err()
                 }
 
                 logging.Fields{
                         "package": pkg,
                         "version": vers,
                 }.Debugf(c, "Resolved package to: %s", pin)
                 return pin, nil
         }, template)
         if err != nil {
                 return err
@@ skipping 11 matching lines @@
 // Ensure implement venv.PackageLoader.
 //
 // The packages must be valid (PackageIsComplete). If they aren't, Ensure will
 // panic.
 //
 // The CIPD client that is used for the operation is generated from the supplied
 // options, opts.
 func (pl *PackageLoader) Ensure(c context.Context, root string, packages []*vpython.Spec_Package) error {
         pins, err := packagesToPins(packages)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to convert packages to CIPD pins").Err()
+                return errors.Annotate(err, "failed to convert packages to CIPD pins").Err()
         }
         pinSlice := common.PinSliceBySubdir{
                 "": pins,
         }
 
         // Generate a CIPD client. Use the supplied root.
         opts := pl.Options
         opts.Root = root
         client, err := cipd.NewClient(opts)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to generate CIPD client").Err()
+                return errors.Annotate(err, "failed to generate CIPD client").Err()
         }
 
         // Start a CIPD client batch.
         client.BeginBatch(c)
         defer client.EndBatch(c)
 
         actionMap, err := client.EnsurePackages(c, pinSlice, false)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to install CIPD packages").Err()
+                return errors.Annotate(err, "failed to install CIPD packages").Err()
         }
         if len(actionMap) > 0 {
                 errorCount := 0
                 for root, action := range actionMap {
                         errorCount += len(action.Errors)
                         for _, err := range action.Errors {
                                 logging.Errorf(c, "CIPD root %q action %q for pin %q encountered error: %s", root, err.Action, err.Pin, err)
                         }
                 }
                 if errorCount > 0 {
-                        return errors.Reason("CIPD package installation encountered %(count)d error(s)").
-                                D("count", errorCount).
-                                Err()
+                        return errors.Reason("CIPD package installation encountered %d error(s)", errorCount).Err()
                 }
         }
         return nil
 }
 
 func packagesToPins(packages []*vpython.Spec_Package) ([]common.Pin, error) {
         pins := make([]common.Pin, len(packages))
         for i, pkg := range packages {
                 pins[i] = common.Pin{
                         PackageName: pkg.Name,
                         InstanceID:  pkg.Version,
                 }
         }
         return pins, nil
 }