[errors] de-specialize Transient in favor of Tags.

tokenserver/appengine/impl/certconfig/ca.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 certconfig
 
 import (
         "bytes"
         "crypto/x509"
         "encoding/gob"
         "time"
 
         "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/data/caching/lazyslot"
         "github.com/luci/luci-go/common/data/caching/proccache"
-        "github.com/luci/luci-go/common/errors"
+        "github.com/luci/luci-go/common/retry"
 
         "github.com/luci/luci-go/tokenserver/api/admin/v1"
 )
 
 // CA defines one trusted Certificate Authority (imported from config).
 //
 // Entity key is CA Common Name (that must match what's is in the certificate).
 // Certificate issuer (and the certificate signature) is ignored. Usually, the
 // certificates here will be self-signed.
 //
@@ skipping 38 matching lines @@
                 return nil, err
         }
         return msg, nil
 }
 
 // ListCAs returns names of all currently active CAs, in no particular order.
 func ListCAs(c context.Context) ([]string, error) {
         keys := []*ds.Key{}
         q := ds.NewQuery("CA").Eq("Removed", false).KeysOnly(true)
         if err := ds.GetAll(c, q, &keys); err != nil {
-                return nil, errors.WrapTransient(err)
+                return nil, retry.Tag.Apply(err)
         }
         names := make([]string, len(keys))
         for i, key := range keys {
                 names[i] = key.StringID()
         }
         return names, nil
 }
 
 // CAUniqueIDToCNMap is a singleton entity that stores a mapping between CA's
 // unique_id (specified in config) and its Common Name.
 //
 // It's loaded in memory in full and kept cached there (for 1 min).
 // See GetCAByUniqueID below.
 type CAUniqueIDToCNMap struct {
         _id int64 `gae:"$id,1"`
 
         GobEncodedMap []byte `gae:",noindex"` // gob-encoded map[int64]string
 }
 
 // StoreCAUniqueIDToCNMap overwrites CAUniqueIDToCNMap with new content.
 func StoreCAUniqueIDToCNMap(c context.Context, mapping map[int64]string) error {
         buf := bytes.Buffer{}
         enc := gob.NewEncoder(&buf)
         if err := enc.Encode(mapping); err != nil {
                 return err
         }
         // Note that in practice 'mapping' is usually very small, so we are not
         // concerned about 1MB entity size limit.
-        return errors.WrapTransient(ds.Put(c, &CAUniqueIDToCNMap{
+        return retry.Tag.Apply(ds.Put(c, &CAUniqueIDToCNMap{
                 GobEncodedMap: buf.Bytes(),
         }))
 }
 
 // LoadCAUniqueIDToCNMap loads CAUniqueIDToCNMap from the datastore.
 func LoadCAUniqueIDToCNMap(c context.Context) (map[int64]string, error) {
         ent := CAUniqueIDToCNMap{}
         switch err := ds.Get(c, &ent); {
         case err == ds.ErrNoSuchEntity:
                 return nil, nil
         case err != nil:
-                return nil, errors.WrapTransient(err)
+                return nil, retry.Tag.Apply(err)
         }
         dec := gob.NewDecoder(bytes.NewReader(ent.GobEncodedMap))
         out := map[int64]string{}
         if err := dec.Decode(&out); err != nil {
                 return nil, err
         }
         return out, nil
 }
 
 // GetCAByUniqueID returns CN name that corresponds to given unique ID.
@@ skipping 34 matching lines @@
 }
 
 func (m *idToCNmapper) getCAByUniqueID(c context.Context, id int64) (string, error) {
         val, err := m.mapping.Get(c)
         if err != nil {
                 return "", err
         }
         mapping := val.Value.(map[int64]string)
         return mapping[id], nil
 }