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

appengine/gaesecrets/gaesecrets.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 gaesecrets implements storage of secret blobs on top of datastore.
 //
 // It is not super secure, but we have what we have: there's no other better
 // mechanism to persistently store non-static secrets on GAE.
 //
 // All secrets are global (live in default GAE namespace).
 package gaesecrets
 
 import (
         "crypto/rand"
         "fmt"
         "io"
         "strings"
         "time"
 
         "golang.org/x/net/context"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
         "github.com/luci/luci-go/common/clock"
         "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/server/secrets"
 )
 
 // TODO(vadimsh): Add secrets rotation.
 
 // procCacheExp is how long to cache secrets in the process memory.
 const procCacheExp = time.Minute * 5
 
 // Config can be used to tweak parameters of the store. It is fine to use
 // default values.
@@ skipping 54 matching lines @@
         c, err := info.Namespace(s.ctx, "")
         if err != nil {
                 panic(err) // should not happen, Namespace errors only on bad namespace name
         }
         c = ds.WithoutTransaction(c)
 
         // Grab existing.
         ent := secretEntity{ID: s.cfg.Prefix + ":" + string(k)}
         err = ds.Get(c, &ent)
         if err != nil && err != ds.ErrNoSuchEntity {
-                return secrets.Secret{}, errors.WrapTransient(err)
+                return secrets.Secret{}, retry.Tag.Apply(err)
         }
 
         // Autogenerate and put into the datastore.
         if err == ds.ErrNoSuchEntity {
                 if s.cfg.NoAutogenerate {
                         return secrets.Secret{}, secrets.ErrNoSuchSecret
                 }
                 ent.Created = clock.Now(s.ctx).UTC()
                 if ent.Secret, err = s.generateSecret(); err != nil {
-                        return secrets.Secret{}, errors.WrapTransient(err)
+                        return secrets.Secret{}, retry.Tag.Apply(err)
                 }
                 if ent.SecretID, err = s.generateSecretID(ent.Created); err != nil {
-                        return secrets.Secret{}, errors.WrapTransient(err)
+                        return secrets.Secret{}, retry.Tag.Apply(err)
                 }
                 err = ds.RunInTransaction(c, func(c context.Context) error {
                         newOne := secretEntity{ID: ent.ID}
                         switch err := ds.Get(c, &newOne); err {
                         case nil:
                                 ent = newOne
                                 return nil
                         case ds.ErrNoSuchEntity:
                                 return ds.Put(c, &ent)
                         default:
                                 return err
                         }
                 }, nil)
                 if err != nil {
-                        return secrets.Secret{}, errors.WrapTransient(err)
+                        return secrets.Secret{}, retry.Tag.Apply(err)
                 }
         }
 
         return secrets.Secret{
                 Current: secrets.NamedBlob{
                         ID:   ent.SecretID,
                         Blob: ent.Secret,
                 },
         }, nil
 }
@@ skipping 21 matching lines @@
 
 type secretEntity struct {
         _kind string `gae:"$kind,gaesecrets.Secret"`
 
         ID string `gae:"$id"`
 
         Secret   []byte `gae:",noindex"` // blob with the secret
         SecretID string `gae:",noindex"` // ID of the Secret blob
         Created  time.Time
 }