[errors] Greatly simplify common/errors package.

deploytool/cmd/luci_deploy/deploy.go

 // Copyright 2016 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 main
 
 import (
         "sort"
 
         "github.com/luci/luci-go/common/cli"
@@ skipping 91 matching lines @@
         // If a manual version was specified, use it.
         if cmd.manualVersion != "" {
                 cmd.dp.params.forceVersion = makeStringCloudProjectVersion(cmd.manualVersion)
         }
 
         err := a.runWork(c, func(w *work) error {
                 // Perform our planned checkout.
                 if cmd.checkout {
                         // Perform a full checkout.
                         if err := checkout(w, &a.layout, false); err != nil {
-                                return errors.Annotate(err).Reason("failed to checkout sources").Err()
+                                return errors.Annotate(err, "failed to checkout sources").Err()
                         }
                 }
 
                 // Load our frozen checkout.
                 if err := a.layout.loadFrozenLayout(w); err != nil {
-                        return errors.Annotate(err).Reason("failed to load frozen checkout").Err()
+                        return errors.Annotate(err, "failed to load frozen checkout").Err()
                 }
                 return nil
         })
         if err != nil {
                 logError(c, err, "Failed to perform checkout.")
                 return 1
         }
 
         // Figure out what we're going to deploy.
         for _, arg := range args {
@@ skipping 14 matching lines @@
                 if !matched {
                         log.Fields{
                                 "target": arg,
                         }.Errorf(c, "Deploy target did not match any configured deployments or components.")
                         return 1
                 }
         }
 
         err = a.runWork(c, func(w *work) error {
                 if err := cmd.dp.initialize(w, &a.layout); err != nil {
-                        return errors.Annotate(err).Reason("failed to initialize").Err()
+                        return errors.Annotate(err, "failed to initialize").Err()
                 }
 
                 return cmd.dp.deploy(w)
         })
         if err != nil {
                 logError(c, err, "Failed to perform deployment.")
                 return 1
         }
         return 0
 }
@@ skipping 60 matching lines @@
                 // order in which they are defined in the Application's protobuf.
                 for _, compName := range dep.componentNames {
                         comp := dep.components[compName]
 
                         // Only pass the registrar if this component is being deployed.
                         var pReg componentRegistrar
                         if _, ok := dp.comps[comp.String()]; ok {
                                 pReg = &dp.reg
                         }
                         if err := comp.loadSourceComponent(pReg); err != nil {
-                                return errors.Annotate(err).Reason("failed to load component %(comp)q").
-                                        D("comp", comp.String()).Err()
+                                return errors.Annotate(err, "failed to load component %q", comp).Err()
                         }
                 }
         }
 
         return nil
 }
 
 func (dp *deploymentPlan) deploy(w *work) error {
         // Create our working root and staging/build subdirectories.
         fs, err := dp.layout.workingFilesystem()
         if err != nil {
-                return errors.Annotate(err).Reason("failed to create working directory").Err()
+                return errors.Annotate(err, "failed to create working directory").Err()
         }
 
         stagingDir, err := fs.Base().EnsureDirectory("staging")
         if err != nil {
-                return errors.Annotate(err).Reason("failed to create staging directory").Err()
+                return errors.Annotate(err, "failed to create staging directory").Err()
         }
 
         // Stage: Staging
         if err := dp.reg.stage(w, stagingDir, &dp.params); err != nil {
-                return errors.Annotate(err).Reason("failed to stage").Err()
+                return errors.Annotate(err, "failed to stage").Err()
         }
         if dp.params.stage <= deployStaging {
                 return nil
         }
 
         // Stage: Local Build
         if err := dp.reg.localBuild(w); err != nil {
-                return errors.Annotate(err).Reason("failed to perform local build").Err()
+                return errors.Annotate(err, "failed to perform local build").Err()
         }
         if dp.params.stage <= deployLocalBuild {
                 return nil
         }
 
         // Stage: Push
         if err := dp.reg.push(w); err != nil {
-                return errors.Annotate(err).Reason("failed to push components").Err()
+                return errors.Annotate(err, "failed to push components").Err()
         }
         if dp.params.stage <= deployPush {
                 return nil
         }
 
         // Stage: Commit
         if err := dp.reg.commit(w); err != nil {
-                return errors.Annotate(err).Reason("failed to commit").Err()
+                return errors.Annotate(err, "failed to commit").Err()
         }
         return nil
 }
 
 // deploymentRegistry is the registry of all prepared deployments.
 //
 // While deployment is specified and staged at a component level, actual
 // deployment is allowed to happen at a practical level (e.g., a single
 // cloud project's AppEngine configuration, a single Google Container Engine
 // cluster, etc.).
@@ skipping 88 matching lines @@
         // All components can be independently staged in parallel.
         //
         // We will still enumerate over them in sorted order for determinism.
         return w.RunMulti(func(workC chan<- func() error) {
                 // AppEngine Projects
                 for _, name := range reg.gaeProjectNames {
                         proj := reg.gaeProjects[name]
                         workC <- func() error {
                                 depDir, err := stageDir.EnsureDirectory(string(proj.project.dep.title), "appengine")
                                 if err != nil {
-                                        return errors.Annotate(err).Reason("failed to create deployment directory for %(deployment)q").
-                                                D("deployment", proj.project.dep.title).Err()
+                                        return errors.Annotate(err, "failed to create deployment directory for %q", proj.project.dep.title).Err()
                                 }
                                 return proj.stage(w, depDir, params)
                         }
                 }
 
                 // Container Engine Projects
                 for _, name := range reg.gkeProjectNames {
                         proj := reg.gkeProjects[name]
                         workC <- func() error {
                                 depDir, err := stageDir.EnsureDirectory(string(proj.project.dep.title), "container_engine")
                                 if err != nil {
-                                        return errors.Annotate(err).Reason("failed to create deployment directory for %(deployment)q").
-                                                D("deployment", proj.project.dep.title).Err()
+                                        return errors.Annotate(err, "failed to create deployment directory for %q", proj.project.dep.title).Err()
                                 }
                                 return proj.stage(w, depDir, params)
                         }
                 }
         })
 }
 
 // build performs the build stage on staged components.
 func (reg *deploymentRegistry) localBuild(w *work) error {
         // Enumerate over them in sorted order for determinism.
@@ skipping 57 matching lines @@
 
                 // Container Engine Projects
                 for _, name := range reg.gkeProjectNames {
                         proj := reg.gkeProjects[name]
                         workC <- func() error {
                                 return proj.commit(w)
                         }
                 }
         })
 }