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

appengine/gaeauth/server/session.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 server
 
 import (
         "fmt"
         "strconv"
         "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/errors"
         "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/common/retry"
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/auth/identity"
 )
 
 // SessionStore stores auth sessions in the datastore (always in the default
 // namespace). It implements auth.SessionStore.
 type SessionStore struct {
         Prefix string // used as prefix for datastore keys
 }
 
@@ skipping 50 matching lines @@
                 }
                 if err = ds.Put(c, &userEnt, &sessionEnt); err != nil {
                         return err
                 }
 
                 sessionID = fmt.Sprintf("%s/%s/%d", s.Prefix, userID, sessionEnt.ID)
                 return nil
         }, nil)
 
         if err != nil {
-                return "", errors.WrapTransient(err)
+                return "", retry.Tag.Apply(err)
         }
         return sessionID, nil
 }
 
 // CloseSession closes a session given its ID. Does nothing if session is
 // already closed or doesn't exist. Returns only transient errors.
 func (s *SessionStore) CloseSession(c context.Context, sessionID string) error {
         c = defaultNS(c)
         ent, err := s.fetchSession(c, sessionID)
         switch {
         case err != nil:
                 return err
         case ent == nil:
                 return nil
         default:
                 ent.IsClosed = true
                 ent.Closed = clock.Now(c).UTC()
-                return errors.WrapTransient(ds.Put(ds.WithoutTransaction(c), ent))
+                return retry.Tag.Apply(ds.Put(ds.WithoutTransaction(c), ent))
         }
 }
 
 // GetSession returns existing non-expired session given its ID. Returns nil
 // if session doesn't exist, closed or expired. Returns only transient errors.
 func (s *SessionStore) GetSession(c context.Context, sessionID string) (*auth.Session, error) {
         c = defaultNS(c)
         ent, err := s.fetchSession(c, sessionID)
         if ent == nil {
                 return nil, err
@@ skipping 35 matching lines @@
         }
         switch err = ds.Get(c, &sessionEnt); err {
         case nil:
                 if sessionEnt.IsClosed || clock.Now(c).After(sessionEnt.Expiration) {
                         return nil, nil
                 }
                 return &sessionEnt, nil
         case ds.ErrNoSuchEntity:
                 return nil, nil
         default:
-                return nil, errors.WrapTransient(err)
+                return nil, retry.Tag.Apply(err)
         }
 }
 
 ////
 
 // profile is used in both userEntity and sessionEntity. It holds information
 // about a user extracted from user.User struct.
 type profile struct {
         Identity  string
         Superuser bool   `gae:",noindex"`
@@ skipping 28 matching lines @@
         ID     int64   `gae:"$id"`
         Parent *ds.Key `gae:"$parent"`
 
         Profile    profile
         Created    time.Time // when this session was created
         Expiration time.Time // when this session expires
 
         IsClosed bool      // if true, the session was closed by CloseSession()
         Closed   time.Time // when the session was closed by CloseSession()
 }