[errors] Greatly simplify common/errors package.

deploytool/cmd/luci_deploy/manage.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 (
         "fmt"
         "strconv"
         "strings"
@@ skipping 68 matching lines @@
         switch dep, comp, err := a.layout.getDeploymentComponent(name); {
         case err != nil:
                 return nil, err
 
         case comp != nil:
                 mApp.dp.addProjectComponent(comp)
                 err := a.runWork(c, func(w *work) error {
                         return mApp.dp.initialize(w, &a.layout)
                 })
                 if err != nil {
-                        return nil, errors.Annotate(err).Reason("failed to initialize deployment plan").Err()
+                        return nil, errors.Annotate(err, "failed to initialize deployment plan").Err()
                 }
 
                 switch comp.GetComponent().(type) {
                 case *deploy.Component_AppengineModule:
                         break
                 case *deploy.Component_GkePod:
                         mApp.subcommands = append(mApp.subcommands, []*subcommands.Command{
                                 {
                                         UsageLine: "kubectl <args...>",
                                         ShortDesc: "run a kubectl command",
@@ skipping 29 matching lines @@
                 default:
                         break
                 }
 
         default:
                 mApp.dp.addDeployment(dep)
                 err := a.runWork(c, func(w *work) error {
                         return mApp.dp.initialize(w, &a.layout)
                 })
                 if err != nil {
-                        return nil, errors.Annotate(err).Reason("failed to initialize deployment plan").Err()
+                        return nil, errors.Annotate(err, "failed to initialize deployment plan").Err()
                 }
 
                 if cp := dep.cloudProject; cp != nil {
                         mApp.subcommands = append(mApp.subcommands, &subcommands.Command{
                                 UsageLine: "update_appengine",
                                 ShortDesc: "update AppEngine parameters",
                                 LongDesc:  "Update AppEngine cron, dispatch, index, and queue configurations.",
                                 CommandRun: func() subcommands.CommandRun {
                                         return &updateGAECommandRun{
                                                 project: cp,
@@ skipping 25 matching lines @@
         bp, err := getPodBindingForCluster(cmd.comp, cmd.cluster)
         if err != nil {
                 logError(c, err, "Failed to identify cluster.")
                 return 1
         }
 
         var rv int
         err = a.runWork(c, func(w *work) error {
                 kubeCtx, err := getContainerEngineKubernetesContext(w, bp.cluster)
                 if err != nil {
-                        return errors.Annotate(err).Err()
+                        return errors.Annotate(err, "").Err()
                 }
 
                 kubectl, err := w.tools.kubectl(kubeCtx)
                 if err != nil {
-                        return errors.Annotate(err).Err()
+                        return errors.Annotate(err, "").Err()
                 }
 
                 rv, err = kubectl.exec(args...).forwardOutput().run(w)
                 return err
         })
         if err != nil {
                 logError(c, err, "Failed to run kubectl command.")
                 if rv == 0 {
                         rv = 1
                 }
@@ skipping 44 matching lines @@
         if cmd.dryRun {
                 log.Infof(c, "(Dry run) Generated 'gcloud' command: gcloud %s", strings.Join(gcloudArgs, " "))
                 return 0
         }
 
         var rv int
         err = a.runWork(c, func(w *work) (err error) {
                 cloudProjectName := bp.pod.comp.dep.cloudProject.Name
                 gcloud, err := w.tools.gcloud(cloudProjectName)
                 if err != nil {
-                        return errors.Annotate(err).Err()
+                        return errors.Annotate(err, "").Err()
                 }
 
                 if rv, err = gcloud.exec(gcloudArgs[0], gcloudArgs[1:]...).run(w); err != nil {
-                        return errors.Annotate(err).Reason("failed to run 'gcloud' command").Err()
+                        return errors.Annotate(err, "failed to run 'gcloud' command").Err()
                 }
                 return nil
         })
         if err != nil {
                 logError(c, err, "Failed to run gcloud command.")
                 if rv == 0 {
                         rv = 1
                 }
         }
         return rv
 }
 
 func getPodBindingForCluster(comp *layoutDeploymentComponent, cluster string) (*layoutDeploymentGKEPodBinding, error) {
         var bp *layoutDeploymentGKEPodBinding
         switch {
         case cluster != "":
                 cluster := comp.dep.cloudProject.gkeClusters[cluster]
                 if cluster == nil {
-                        return nil, errors.Reason("invalid GKE cluster name: %(name)q").
-                                D("name", cluster).
-                                Err()
+                        return nil, errors.Reason("invalid GKE cluster name: %q", cluster).Err()
                 }
                 for _, gkeBP := range comp.gkePods {
                         if gkeBP.cluster == cluster {
                                 bp = gkeBP
                                 break
                         }
                 }
 
         case len(comp.gkePods) == 0:
                 return nil, errors.New("pod is not bound to any clusters")
 
         case len(comp.gkePods) == 1:
                 bp = comp.gkePods[0]
 
         default:
                 clusters := make([]string, len(comp.gkePods))
                 for i, cluster := range comp.gkePods {
                         clusters[i] = fmt.Sprintf("- %s", cluster.cluster.Name)
                 }
 
                 return nil, errors.Reason("the Kubernetes pod is bound to multiple clusters. Specify one with -cluster").
-                        D("clusters", clusters).
-                        Err()
+                        InternalReason("clusters(%v)", clusters).Err()
         }
         if bp == nil {
                 return nil, errors.New("Could not identify cluster for pod.")
         }
         return bp, nil
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Manage / GAE
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 21 matching lines @@
         err := a.runWork(c, func(w *work) error {
                 a.dp.params.stage = deployCommit
                 return a.dp.deploy(w)
         })
         if err != nil {
                 logError(c, err, "Failed to update GAE parameters.")
                 return 1
         }
         return rv
 }