[errors] Greatly simplify common/errors package.

deploytool/cmd/luci_deploy/checkout.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 (
         "crypto/sha256"
         "encoding/hex"
         "fmt"
@@ skipping 58 matching lines @@
         if err != nil {
                 logError(c, err, "Failed to checkout.")
                 return 1
         }
         return 0
 }
 
 func checkout(w *work, l *deployLayout, applyOverrides bool) error {
         frozen, err := l.initFrozenCheckout(w)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to initialize checkout").Err()
+                return errors.Annotate(err, "failed to initialize checkout").Err()
         }
 
         // reg is our internal checkout registry. This represents the actual
         // repository checkouts that we perform. Duplicate sources to the same
         // repository will be deduplicated here.
         fs, err := l.workingFilesystem()
         if err != nil {
-                return errors.Annotate(err).Err()
+                return errors.Annotate(err, "").Err()
         }
         checkoutDir, err := fs.Base().EnsureDirectory(checkoutsSubdir)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to create checkout directory").Err()
+                return errors.Annotate(err, "failed to create checkout directory").Err()
         }
 
         repoDir, err := checkoutDir.EnsureDirectory("repository")
         if err != nil {
-                return errors.Annotate(err).Reason("failed to create repository directory %(dir)q").
-                        D("dir", repoDir).Err()
+                return errors.Annotate(err, "failed to create repository directory %q", repoDir).Err()
         }
 
         reg := checkoutRegistry{
                 repoDir: repoDir,
         }
 
         // Do a central checkout of registry repositories. We will project this using
         // sorted keys so that checkout failures happen consistently.
         var (
                 scs       []*sourceCheckout
@@ skipping 17 matching lines @@
                 sort.Strings(srcKeys)
 
                 for i, srcKey := range srcKeys {
                         sc := sourceCheckout{
                                 FrozenLayout_Source: sg.Source[srcKey],
                                 group:               sgKey,
                                 name:                srcKey,
                         }
 
                         if err := sc.addRegistryRepos(&reg); err != nil {
-                                return errors.Annotate(err).Reason("failed to add [%(sourceCheckout)s] to registry").
-                                        D("sourceCheckout", sc).Err()
+                                return errors.Annotate(err, "failed to add [%s] to registry", sc).Err()
                         }
 
                         // If we're overriding sources, and this source is overridden, then apply
                         // this and add the overriding source to the registry as well.
                         //
                         // We will still keep the original source in the registry so it doesn't
                         // get deleted during cleanup.
                         if applyOverrides {
                                 if override, ok := l.userSourceOverrides[sc.overrideURL]; ok {
                                         log.Infof(w, "Applying user repository override: [%+v] => [%+v]", sc.Source, override)
 
                                         // Any local overrides cause the source group to be considered
                                         // tainted.
                                         sc.FrozenLayout_Source.Source = override
                                         sc.FrozenLayout_Source.Source.Tainted = true
 
                                         if err := sc.addRegistryRepos(&reg); err != nil {
-                                                return errors.Annotate(err).Reason("failed to add (overridden) [%(sourceCheckout)s] to registry").
-                                                        D("sourceCheckout", sc).Err()
+                                                return errors.Annotate(err, "failed to add (overridden) [%s] to registry", sc).Err()
                                         }
                                 }
                         }
 
                         groupSrcs[i] = &sc
                         scs = append(scs, &sc)
                 }
 
                 sgSources[sgKey] = groupSrcs
         }
         if err := reg.checkout(w); err != nil {
-                return errors.Annotate(err).Reason("failed to checkout sources").Err()
+                return errors.Annotate(err, "failed to checkout sources").Err()
         }
 
         // Execute each source checkout in parallel.
         sourcesDir, err := checkoutDir.EnsureDirectory("sources")
         if err != nil {
-                return errors.Annotate(err).Reason("failed to create sources directory").Err()
+                return errors.Annotate(err, "failed to create sources directory").Err()
         }
 
         err = w.RunMulti(func(workC chan<- func() error) {
                 for _, sc := range scs {
                         sc := sc
                         workC <- func() error {
                                 root, err := sourcesDir.EnsureDirectory(sc.group, sc.name)
                                 if err != nil {
-                                        return errors.Annotate(err).Reason("failed to create checkout directory").Err()
+                                        return errors.Annotate(err, "failed to create checkout directory").Err()
                                 }
 
                                 if err := sc.checkout(w, root); err != nil {
-                                        return errors.Annotate(err).Reason("failed to checkout %(sourceCheckout)s").
-                                                D("sourceCheckout", sc).Err()
+                                        return errors.Annotate(err, "failed to checkout %s", sc).Err()
                                 }
                                 return nil
                         }
                 }
         })
         if err != nil {
                 return err
         }
 
         // Build our source groups' checkout revision hashes.
         for _, sgKey := range sgKeys {
                 sg := frozen.SourceGroup[sgKey]
                 if sg.RevisionHash != "" {
                         // Already calculated.
                         continue
                 }
 
                 hash := sha256.New()
                 for _, sc := range sgSources[sgKey] {
                         if sc.Revision == "" {
-                                return errors.Reason("source %(sourceCheckout)q has an empty revision").
-                                        D("sourceCheckout", sc.String()).Err()
+                                return errors.Reason("source %q has an empty revision", sc).Err()
                         }
                         fmt.Fprintf(hash, "%s@%s\x00", sc.name, sc.Revision)
 
                         // If any of our sources was determined to be tainted, taint the source
                         // group too.
                         if sc.cs.tainted || sc.Source.Tainted {
                                 sg.Tainted = true
                         }
                 }
 
                 sg.RevisionHash = hex.EncodeToString(hash.Sum(nil))
                 log.Fields{
                         "sourceGroup": sgKey,
                         "revision":    sg.RevisionHash,
                         "tainted":     sg.Tainted,
                 }.Debugf(w, "Checked out source group.")
         }
 
         // Create the frozen checkout file.
         frozenFile := checkoutDir.File(frozenCheckoutName)
         if err := frozenFile.GenerateTextProto(w, frozen); err != nil {
-                return errors.Annotate(err).Reason("failed to create frozen checkout protobuf").Err()
+                return errors.Annotate(err, "failed to create frozen checkout protobuf").Err()
         }
 
         if err := checkoutDir.CleanUp(); err != nil {
-                return errors.Annotate(err).Reason("failed to do full cleanup of cleanup sources filesystem").Err()
+                return errors.Annotate(err, "failed to do full cleanup of cleanup sources filesystem").Err()
         }
 
         return nil
 }
 
 func checkoutFrozen(l *deployLayout) (*deploy.FrozenLayout, error) {
         path := filepath.Join(l.WorkingPath, checkoutsSubdir, frozenCheckoutName)
 
         var frozen deploy.FrozenLayout
         if err := unmarshalTextProtobuf(path, &frozen); err != nil {
-                return nil, errors.Annotate(err).Err()
+                return nil, errors.Annotate(err, "").Err()
         }
         return &frozen, nil
 }
 
 // sourceCheckout manages the operation of checking out the specified layout
 // source.
 type sourceCheckout struct {
         *deploy.FrozenLayout_Source
 
         // group is the name of the source group.
@@ skipping 13 matching lines @@
         return fmt.Sprintf("%s.%s", sc.group, sc.name)
 }
 
 func (sc *sourceCheckout) addRegistryRepos(reg *checkoutRegistry) error {
         switch t := sc.Source.GetSource().(type) {
         case *deploy.Source_Git:
                 g := t.Git
 
                 u, err := url.Parse(g.Url)
                 if err != nil {
-                        return errors.Annotate(err).Reason("failed to parse Git URL [%(url)s]").D("url", g.Url).Err()
+                        return errors.Annotate(err, "failed to parse Git URL [%s]", g.Url).Err()
                 }
 
                 // Add a Git checkout operation for this source to the registry.
                 sc.cs = reg.add(&gitCheckoutOperation{
                         url: u,
                         ref: g.Ref,
                 }, sc.Source.RunScripts)
                 sc.overrideURL = g.Url
         }
 
         return nil
 }
 
 func (sc *sourceCheckout) checkout(w *work, root *managedfs.Dir) error {
         checkoutPath := root.File("c")
 
         switch t := sc.Source.GetSource().(type) {
         case *deploy.Source_Git:
                 if sc.cs.path == "" {
                         panic("registry repo path is not set")
                 }
 
                 // Add a symlink between our raw checkout and our current checkout.
                 if err := checkoutPath.SymlinkFrom(sc.cs.path, true); err != nil {
-                        return errors.Annotate(err).Err()
+                        return errors.Annotate(err, "").Err()
                 }
                 sc.Relpath = checkoutPath.RelPath()
 
         default:
-                return errors.Reason("don't know how to checkout %(type)T").D("type", t).Err()
+                return errors.Reason("don't know how to checkout %T", t).Err()
         }
 
         sc.Revision = sc.cs.revision
         sc.MajorVersion = sc.cs.majorVersion
         sc.MinorVersion = sc.cs.minorVersion
         sc.InitResult = &deploy.SourceInitResult{
                 GoPath: append(sc.Source.GoPath, sc.cs.sir.GoPath...),
         }
         return nil
 }
@@ skipping 72 matching lines @@
                 for _, key := range opKeys {
                         key, cs := key, reg.singletons[key]
                         workC <- func() error {
                                 // Generate the path of this checkout. We do this by hashing the checkout's
                                 // key.
                                 pathHash := sha256.Sum256([]byte(key))
 
                                 // Perform the actual checkout operation.
                                 checkoutDir, err := reg.repoDir.EnsureDirectory(hex.EncodeToString(pathHash[:]))
                                 if err != nil {
-                                        return errors.Annotate(err).Reason("failed to create checkout directory for %(key)q").D("key", key).Err()
+                                        return errors.Annotate(err, "failed to create checkout directory for %q", key).Err()
                                 }
 
                                 log.Fields{
                                         "key":          key,
                                         "checkoutPath": checkoutDir,
                                 }.Debugf(w, "Creating checkout directory.")
                                 if err := cs.op.checkout(w, cs, checkoutDir); err != nil {
                                         return err
                                 }
 
                                 // Make sure "checkout" did what it was supposed to.
                                 if cs.path == "" {
                                         return errors.New("checkout did not populate path")
                                 }
 
                                 // If there is a deployment configuration, load/parse/execute it.
                                 sl, err := loadSourceLayout(cs.path)
                                 if err != nil {
-                                        return errors.Annotate(err).Reason("failed to load source layout").Err()
+                                        return errors.Annotate(err, "failed to load source layout").Err()
                                 }
 
                                 var sir deploy.SourceInitResult
                                 if sl != nil {
                                         sir.GoPath = sl.GoPath
 
                                         if len(sl.Init) > 0 {
                                                 if cs.runInit {
                                                         for i, in := range sl.Init {
                                                                 inResult, err := sourceInit(w, cs.path, in)
                                                                 if err != nil {
-                                                                        return errors.Annotate(err).Reason("failed to run source init #%(index)d").
-                                                                                D("index", i).Err()
+                                                                        return errors.Annotate(err, "failed to run source init #%d", i).Err()
                                                                 }
 
                                                                 // Merge this SourceInitResult into the common repository
                                                                 // result.
                                                                 sir.GoPath = append(sir.GoPath, inResult.GoPath...)
                                                         }
                                                 } else {
                                                         log.Fields{
                                                                 "key":  key,
                                                                 "path": cs.path,
@@ skipping 67 matching lines @@
                 path = dir.String()
                 ref := g.ref
                 if ref == "" {
                         ref = "master"
                 }
                 gitDir := filepath.Join(path, ".git")
                 needsFetch, resetRef := true, "refs/deploytool/checkout"
                 switch st, err := os.Stat(gitDir); {
                 case err == nil:
                         if !st.IsDir() {
-                                return errors.Reason("checkout Git path [%(path)s] exists, and is not a directory").D("path", gitDir).Err()
+                                return errors.Reason("checkout Git path [%s] exists, and is not a directory", gitDir).Err()
                         }
 
                 case isNotExist(err):
                         // If the target directory doesn't exist, run "git clone".
                         log.Fields{
                                 "source":      g.url,
                                 "destination": path,
                         }.Infof(w, "No current checkout; cloning...")
                         if err := git.clone(w, g.url.String(), path); err != nil {
                                 return err
                         }
                         if err = git.exec(path, "update-ref", resetRef, ref).check(w); err != nil {
-                                return errors.Annotate(err).Reason("failed to checkout %(ref)q from %(url)q").D("ref", ref).D("url", g.url).Err()
+                                return errors.Annotate(err, "failed to checkout %q from %q", ref, g.url).Err()
                         }
                         needsFetch = false
 
                 default:
-                        return errors.Annotate(err).Reason("failed to stat checkout Git directory [%(dir)s]").D("dir", gitDir).Err()
+                        return errors.Annotate(err, "failed to stat checkout Git directory [%s]", gitDir).Err()
                 }
 
                 // Check out the desired commit/ref by resetting the repository.
                 //
                 // Check if the referenced ref is a commit that is already present in the
                 // repository.
                 x := git.exec(path, "rev-parse", ref)
                 switch rc, err := x.run(w); {
                 case err != nil:
-                        return errors.Annotate(err).Reason("failed to check for commit %(ref)q").D("ref", ref).Err()
+                        return errors.Annotate(err, "failed to check for commit %q", ref).Err()
 
                 case rc == 0:
                         // If the ref resolved to itself, then it's a commit and it's already in the
                         // repository, so no need to fetch.
                         if strings.TrimSpace(x.stdout.String()) == ref {
                                 resetRef = ref
                                 needsFetch = false
                         }
                         fallthrough
 
                 default:
                         // If our checkout isn't ready, fetch the ref remotely.
                         if needsFetch {
                                 if err := git.exec(path, "fetch", "origin", fmt.Sprintf("%s:%s", ref, resetRef)).check(w); err != nil {
-                                        return errors.Annotate(err).Reason("failed to fetch %(ref)q from remote").D("ref", ref).Err()
+                                        return errors.Annotate(err, "failed to fetch %q from remote", ref).Err()
                                 }
                         }
 
                         // Reset to "resetRef".
                         if err := git.exec(path, "reset", "--hard", resetRef).check(w); err != nil {
-                                return errors.Annotate(err).Reason("failed to checkout %(ref)q (%(localRef)q) from %(url)q").
-                                        D("ref", ref).D("localRef", resetRef).D("url", g.url).Err()
+                                return errors.Annotate(err, "failed to checkout %q (%q) from %q", ref, resetRef, g.url).Err()
                         }
                 }
         }
 
         // Get the current Git repository parameters.
         var (
                 revision, mergeBase string
                 revCount            int
         )
         err = w.RunMulti(func(workC chan<- func() error) {
                 // Get HEAD revision.
                 workC <- func() (err error) {
                         revision, err = git.getHEAD(w, path)
                         return
                 }
 
                 // Get merge base revision.
                 workC <- func() (err error) {
                         mergeBase, err = git.getMergeBase(w, path, "origin/master")
                         return
                 }
 
                 // Get commit depth.
                 workC <- func() (err error) {
                         revCount, err = git.getRevListCount(w, path)
                         return
                 }
         })
         if err != nil {
-                return errors.Annotate(err).Reason("failed to get Git repository properties").Err()
+                return errors.Annotate(err, "failed to get Git repository properties").Err()
         }
 
         // We're tainted if our merge base doesn't equal our current revision.
         if mergeBase != revision {
                 cs.tainted = true
         }
 
         log.Fields{
                 "url":       g.url,
                 "ref":       g.ref,
@@ skipping 38 matching lines @@
                         return nil, err
                 }
 
                 // Create a temporary directory for the SourceInitResult.
                 var r deploy.SourceInitResult
                 err = withTempDir(func(tdir string) error {
                         resultPath := filepath.Join(tdir, "source_init_result.cfg")
 
                         scriptPath := deployToNative(path, ps.Path)
                         if err := python.exec(scriptPath, path, resultPath).cwd(path).check(w); err != nil {
-                                return errors.Annotate(err).Reason("failed to execute [%(scriptPath)s]").D("scriptPath", scriptPath).Err()
+                                return errors.Annotate(err, "failed to execute [%s]", scriptPath).Err()
                         }
 
                         switch err := unmarshalTextProtobuf(resultPath, &r); {
                         case err == nil, isNotExist(err):
                                 return nil
 
                         default:
-                                return errors.Annotate(err).Reason("failed to stat SourceInitResult [%(resultPath)s]").
-                                        D("resultPath", resultPath).Err()
+                                return errors.Annotate(err, "failed to stat SourceInitResult [%s]", resultPath).Err()
                         }
                 })
                 return &r, err
 
         default:
-                return nil, errors.Reason("unknown source init type %(type)T").D("type", t).Err()
+                return nil, errors.Reason("unknown source init type %T", t).Err()
         }
 }