[errors] Greatly simplify common/errors package.

luci_config/server/cfgclient/backend/caching/config.go

 // Copyright 2015 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 caching
 
 import (
         "fmt"
         "net/url"
         "strings"
@@ skipping 184 matching lines @@
         for i := range v.Items {
                 res[i] = v.Items[i].ConfigItem()
         }
         return res
 }
 
 // DecodeValue loads a Value from is encoded representation.
 func DecodeValue(d []byte) (*Value, error) {
         var v Value
         if err := Decode(d, &v); err != nil {
-                return nil, errors.Annotate(err).Err()
+                return nil, errors.Annotate(err, "").Err()
         }
         return &v, nil
 }
 
 // Encode encodes this Value.
 //
 // This is offered for convenience, but caches aren't required to use this
 // encoding.
 //
 // The format stores the Value as compressed JSON.
@@ skipping 67 matching lines @@
         }
         value, err := b.CacheGet(c, key, b.loader)
         if err != nil {
                 if b.FailOnError {
                         log.Fields{
                                 log.ErrorKey: err,
                                 "authority":  p.Authority,
                                 "configSet":  configSet,
                                 "path":       path,
                         }.Errorf(c, "(Hard Failure) failed to load cache value.")
-                        return nil, errors.Annotate(err).Err()
+                        return nil, errors.Annotate(err, "").Err()
                 }
 
                 log.Fields{
                         log.ErrorKey: err,
                         "authority":  p.Authority,
                         "configSet":  configSet,
                         "path":       path,
                 }.Warningf(c, "Failed to load cache value.")
                 return b.B.Get(c, configSet, path, p)
         }
@@ skipping 21 matching lines @@
         }
         value, err := b.CacheGet(c, key, b.loader)
         if err != nil {
                 if b.FailOnError {
                         log.Fields{
                                 log.ErrorKey: err,
                                 "authority":  p.Authority,
                                 "type":       t,
                                 "path":       path,
                         }.Errorf(c, "(Hard Failure) failed to load cache value.")
-                        return nil, errors.Annotate(err).Err()
+                        return nil, errors.Annotate(err, "").Err()
                 }
 
                 log.Fields{
                         log.ErrorKey: err,
                         "authority":  p.Authority,
                         "type":       t,
                         "path":       path,
                 }.Warningf(c, "Failed to load cache value.")
                 return b.B.GetAll(c, t, path, p)
         }
@@ skipping 11 matching lines @@
         }
 
         var value *Value
         if value, err = b.CacheGet(c, key, b.loader); err != nil {
                 if b.FailOnError {
                         log.Fields{
                                 log.ErrorKey: err,
                                 "authority":  p.Authority,
                                 "configSet":  configSet,
                         }.Errorf(c, "(Hard Failure) failed to load cache value.")
-                        err = errors.Annotate(err).Err()
+                        err = errors.Annotate(err, "").Err()
                         return
                 }
 
                 log.Fields{
                         log.ErrorKey: err,
                         "authority":  p.Authority,
                         "configSet":  configSet,
                 }.Warningf(c, "Failed to load cache value.")
                 return b.B.ConfigSetURL(c, configSet, p)
         }
 
         if value.URL == "" {
                 // Sentinel for no config.
                 err = cfgclient.ErrNoConfig
                 return
         }
 
         up, err := url.Parse(value.URL)
         if err != nil {
-                err = errors.Annotate(err).Reason("failed to parse cached URL: %(value)q").D("value", value.URL).Err()
+                err = errors.Annotate(err, "failed to parse cached URL: %q", value.URL).Err()
                 return
         }
 
         u = *up
         return
 }
 
 // loader runs a cache get against the configured Base backend.
 //
 // This should be used by caches that do not have the cached value.
@@ skipping 10 matching lines @@
 // instance.
 func CacheLoad(c context.Context, b backend.B, k Key, v *Value) (rv *Value, err error) {
         switch k.Op {
         case OpGet:
                 rv, err = doGet(c, b, k.ConfigSet, k.Path, v, k.Params())
         case OpGetAll:
                 rv, err = doGetAll(c, b, k.GetAllTarget, k.Path, v, k.Params())
         case OpConfigSetURL:
                 rv, err = doConfigSetURL(c, b, k.ConfigSet, k.Params())
         default:
-                return nil, errors.Reason("unknown operation: %(op)v").D("op", k.Op).Err()
+                return nil, errors.Reason("unknown operation: %v", k.Op).Err()
         }
         if err != nil {
                 return nil, err
         }
         return
 }
 
 func doGet(c context.Context, b backend.B, configSet, path string, v *Value, p backend.Params) (*Value, error) {
         hadItem := (v != nil && len(v.Items) > 0)
         if !hadItem {
@@ skipping 23 matching lines @@
 
                         // If we get here, we are requesting full-content and our hash check
                         // showed that the current content has a different hash.
                         break
 
                 case cfgclient.ErrNoConfig:
                         v.LoadItems()
                         return v, nil
 
                 default:
-                        return nil, errors.Annotate(err).Err()
+                        return nil, errors.Annotate(err, "").Err()
                 }
         }
 
         // Perform a full content request.
         switch item, err := b.Get(c, configSet, path, p); err {
         case nil:
                 v.LoadItems(item)
                 return v, nil
 
         case cfgclient.ErrNoConfig:
                 // Empty "config missing" item.
                 v.LoadItems()
                 return v, nil
 
         default:
-                return nil, errors.Annotate(err).Err()
+                return nil, errors.Annotate(err, "").Err()
         }
 }
 
 func doGetAll(c context.Context, b backend.B, t backend.GetAllTarget, path string, v *Value, p backend.Params) (
         *Value, error) {
 
         // If we already have a cached value, or if we're requesting no-content, do a
         // no-content refresh to see if anything has changed.
         //
         // Response values are in order, so this is a simple traversal.
         if v != nil || !p.Content {
                 noContentP := p
                 noContentP.Content = false
 
                 items, err := b.GetAll(c, t, path, noContentP)
                 if err != nil {
-                        return nil, errors.Annotate(err).Reason("failed RPC (hash-only)").Err()
+                        return nil, errors.Annotate(err, "failed RPC (hash-only)").Err()
                 }
 
                 // If we already have a cached item, validate it.
                 if v != nil && len(items) == len(v.Items) {
                         match := true
                         for i, other := range items {
                                 cur := v.Items[i]
                                 if cur.ConfigSet == other.ConfigSet && cur.Path == other.Path &&
                                         cur.ContentHash == other.ContentHash {
                                         continue
@@ skipping 13 matching lines @@
                 if !p.Content {
                         var retV Value
                         retV.LoadItems(items...)
                         return &retV, nil
                 }
         }
 
         // Perform a full-content request.
         items, err := b.GetAll(c, t, path, p)
         if err != nil {
-                return nil, errors.Annotate(err).Err()
+                return nil, errors.Annotate(err, "").Err()
         }
         var retV Value
         retV.LoadItems(items...)
         return &retV, nil
 }
 
 func doConfigSetURL(c context.Context, b backend.B, configSet string, p backend.Params) (*Value, error) {
         u, err := b.ConfigSetURL(c, configSet, p)
         switch err {
         case nil:
                 return &Value{
                         URL: u.String(),
                 }, nil
 
         case cfgclient.ErrNoConfig:
                 return &Value{}, nil
 
         default:
                 return nil, err
         }
 }