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

logdog/server/collector/coordinator/cache.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 coordinator
 
 import (
         "sync"
         "time"
 
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/data/caching/lru"
-        "github.com/luci/luci-go/common/errors"
         log "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/common/retry"
         "github.com/luci/luci-go/common/sync/promise"
         "github.com/luci/luci-go/common/tsmon/field"
         "github.com/luci/luci-go/common/tsmon/metric"
         "github.com/luci/luci-go/logdog/common/types"
         "github.com/luci/luci-go/luci_config/common/cfgtypes"
 
         "golang.org/x/net/context"
 )
 
 const (
@@ skipping 168 matching lines @@
 
                 p, tidx = ce.registerP, ce.terminalIndex
         })
 
         // Resolve our registration Promise.
         remoteStateIface, err := p.Get(ctx)
         if err != nil {
                 // If the promise failed transiently, clear it so that subsequent callers
                 // will regenerate a new promise. ONLY clear it if it it is the same
                 // promise, as different callers may have already cleared/rengerated it.
-                if errors.IsTransient(err) {
+                if retry.Tag.In(err) {
                         ce.withLock(func() {
                                 if ce.registerP == p {
                                         ce.registerP = nil
                                 }
                         })
                 }
                 return nil, err
         }
         remoteState := remoteStateIface.(*LogStreamState)
 
@@ skipping 46 matching lines @@
                                 "cachedIndex":  tidx,
                         }.Warningf(ctx, "Request terminal index doesn't match cached value.")
                 }
                 return nil
         }
 
         // Resolve our termination Promise.
         if _, err := p.Get(ctx); err != nil {
                 // If this is a transient error, delete this Promise so future termination
                 // attempts will retry for this stream.
-                if errors.IsTransient(err) {
+                if retry.Tag.In(err) {
                         ce.withLock(func() {
                                 if ce.terminateP == p {
                                         ce.terminateP = nil
                                 }
                         })
                 }
                 return err
         }
         return nil
 }
@@ skipping 15 matching lines @@
                         ce.terminalIndex = tidx
                 }
         })
 }
 
 func (ce *cacheEntry) withLock(f func()) {
         ce.Lock()
         defer ce.Unlock()
         f()
 }