[errors] Greatly simplify common/errors package.

tokenserver/appengine/impl/utils/policy/policy.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 policy
 
 import (
         "crypto/sha256"
         "encoding/hex"
         "sync"
@@ skipping 105 matching lines @@
         c = logging.SetField(c, "policy", p.Name)
 
         // Fetch and parse text protos stored in LUCI config. The fetcher will also
         // record the revision of the fetched files.
         fetcher := luciConfigFetcher{}
         bundle, err := p.Fetch(c, &fetcher)
         if err == nil && len(bundle) == 0 {
                 err = errors.New("no configs fetched by the callback")
         }
         if err != nil {
-                return "", errors.Annotate(err).Reason("failed to fetch policy configs").Err()
+                return "", errors.Annotate(err, "failed to fetch policy configs").Err()
         }
         rev = fetcher.Revision()
 
         // Convert configs into a form appropriate for the datastore. We'll skip the
         // rest of the import if this exact blob is already in the datastore (based on
         // SHA256 digest).
         cfgBlob, err := serializeBundle(bundle)
         if err != nil {
-                return "", errors.Annotate(err).Reason("failed to serialize the configs").Err()
+                return "", errors.Annotate(err, "failed to serialize the configs").Err()
         }
         digest := sha256.Sum256(cfgBlob)
         digestHex := hex.EncodeToString(digest[:])
         logging.Infof(c, "Got %d bytes of configs (SHA256 %s)", len(cfgBlob), digestHex)
 
         // Do we have it already?
         existingHdr, err := getImportedPolicyHeader(c, p.Name)
         if err != nil {
-                return "", errors.Annotate(err).Reason("failed to grab ImportedPolicyHeader").Err()
+                return "", errors.Annotate(err, "failed to grab ImportedPolicyHeader").Err()
         }
         if existingHdr != nil && digestHex == existingHdr.SHA256 {
                 logging.Infof(
                         c, "Configs are up-to-date. Last changed at rev %s, last checked rev is %s.",
                         existingHdr.Revision, rev)
                 return existingHdr.Revision, nil
         }
 
         existingRev := "(nil)"
         if existingHdr != nil {
                 existingRev = existingHdr.Revision
         }
         logging.Infof(c, "Policy config changed: %s -> %s", existingRev, rev)
 
         if p.Validate != nil {
                 v := validation.Context{Logger: logging.Get(c)}
                 p.Validate(bundle, &v)
                 if err := v.Finalize(); err != nil {
-                        return "", errors.Annotate(err).
-                                Reason("configs at rev %(rev)s are invalid").
-                                D("rev", rev).Err()
+                        return "", errors.Annotate(err, "configs at rev %s are invalid", rev).Err()
                 }
         }
 
         // Double check that they actually can be parsed into a queryable form. If
         // not, the Policy callbacks are buggy.
         queriable, err := p.Prepare(bundle, rev)
         if err == nil && queriable.ConfigRevision() != rev {
                 err = errors.New("wrong revision in result of Prepare callback")
         }
         if err != nil {
-                return "", errors.Annotate(err).Reason("failed to convert configs into a queryable form").Err()
+                return "", errors.Annotate(err, "failed to convert configs into a queryable form").Err()
         }
 
         logging.Infof(c, "Storing new configs")
         if err := updateImportedPolicy(c, p.Name, rev, digestHex, cfgBlob); err != nil {
                 return "", err
         }
 
         return rev, nil
 }
 
@@ skipping 16 matching lines @@
 }
 
 // grabQueryable is called whenever cached Queryable in p.cache expires.
 func (p *Policy) grabQueryable(c context.Context, prev lazyslot.Value) (val lazyslot.Value, err error) {
         c = logging.SetField(c, "policy", p.Name)
 
         logging.Infof(c, "Checking version of the policy in the datastore")
         hdr, err := getImportedPolicyHeader(c, p.Name)
         switch {
         case err != nil:
-                err = errors.Annotate(err).Reason("failed to fetch importedPolicyHeader entity").Err()
+                err = errors.Annotate(err, "failed to fetch importedPolicyHeader entity").Err()
                 return
         case hdr == nil:
                 err = ErrNoPolicy
                 return
         }
 
         // Reuse existing Queryable object if configs didn't change.
         prevQ, _ := prev.Value.(Queryable)
         if prevQ != nil && prevQ.ConfigRevision() == hdr.Revision {
                 return lazyslot.Value{
                         Value:      prevQ,
                         Expiration: nextCheckTime(c),
                 }, nil
         }
 
         // Fetch new configs.
         logging.Infof(c, "Fetching policy configs from the datastore")
         body, err := getImportedPolicyBody(c, p.Name)
         switch {
         case err != nil:
-                err = errors.Annotate(err).Reason("failed to fetch importedPolicyBody entity").Err()
+                err = errors.Annotate(err, "failed to fetch importedPolicyBody entity").Err()
                 return
         case body == nil: // this is rare, the body shouldn't disappear
                 logging.Errorf(c, "The policy body is unexpectedly gone")
                 err = ErrNoPolicy
                 return
         }
 
         // An error here and below can happen if previously validated config is no
         // longer valid (e.g. if the service code is updated and new code doesn't like
         // the stored config anymore).
         //
         // If this check fails, the service is effectively offline until configs are
         // updated. Presumably, it is better than silently using no longer valid
         // config.
         logging.Infof(c, "Using configs at rev %s", body.Revision)
         configs, unknown, err := deserializeBundle(body.Data)
         if err != nil {
-                err = errors.Annotate(err).Reason("failed to deserialize cached configs").Err()
+                err = errors.Annotate(err, "failed to deserialize cached configs").Err()
                 return
         }
         if len(unknown) != 0 {
                 for _, cfg := range unknown {
                         logging.Errorf(c, "Unknown proto type %q in cached config %q", cfg.Kind, cfg.Path)
                 }
                 err = errors.New("failed to deserialize some cached configs")
                 return
         }
         queryable, err := p.Prepare(configs, body.Revision)
         if err != nil {
-                err = errors.Annotate(err).Reason("failed to process cached configs").Err()
+                err = errors.Annotate(err, "failed to process cached configs").Err()
                 return
         }
 
         return lazyslot.Value{
                 Value:      queryable,
                 Expiration: nextCheckTime(c),
         }, nil
 }
 
 // nextCheckTime returns a random time from [now+4 min, now+5 min).
 //
 // It's used to define when to refresh in-memory Queryable cache. We randomize
 // it to desynchronize cache updates of different Policy instances.
 func nextCheckTime(c context.Context) time.Time {
         rnd := time.Duration(mathrand.Int63n(c, int64(time.Minute)))
         return clock.Now(c).Add(4*time.Minute + rnd)
 }