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

grpc/grpcutil/errors.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 grpcutil
 
 import (
-        "github.com/luci/luci-go/common/errors"
-
         "google.golang.org/grpc"
         "google.golang.org/grpc/codes"
+
+        "github.com/luci/luci-go/common/errors"
+        "github.com/luci/luci-go/common/retry/transient"
 )
 
 var (
         // Errf falls through to grpc.Errorf, with the notable exception that it isn't
         // named "Errorf" and, consequently, won't trigger "go vet" misuse errors.
         Errf = grpc.Errorf
 
         // OK is an empty grpc.OK status error.
         OK = Errf(codes.OK, "")
 
@@ skipping 52 matching lines @@
 // If the supplied error is nil, nil will be returned.
 //
 // Note that non-gRPC errors will have code grpc.Unknown, which is considered
 // transient, and be wrapped. This function should only be used on gRPC errors.
 func WrapIfTransient(err error) error {
         if err == nil {
                 return nil
         }
 
         if IsTransientCode(Code(err)) {
-                err = errors.WrapTransient(err)
+                err = transient.Tag.Apply(err)
         }
         return err
 }
 
-const grpcCodeKey = "__grpcutil.Code"
+type grpcCodeTag struct{ Key errors.TagKey }

[dnj, 2017/06/27 03:57:03]

QQ: why is "Key" named here (and elsewhere)?

[iannucci, 2017/06/27 18:14:27]

Because TagKey is a pointer type, it can't be embedded. Not that it matters,
because it can't have any methods on it anyway...

+
+func (g grpcCodeTag) With(code codes.Code) errors.TagValue { return errors.MkTagValue(g.Key, code) }
+func (g grpcCodeTag) In(err error) (v codes.Code, ok bool) {
+        d, ok := errors.TagValueIn(g.Key, err)
+        if ok {
+                v = d.(codes.Code)
+        }
+        return
+}
+
+// Tag may be used to associate a gRPC status code with this error.
+//
+// The tag value MUST be a "google.golang.org/grpc/codes".Code.
+var Tag = grpcCodeTag{errors.NewTagKey("gRPC Code")}
 
 // Code returns the gRPC code for a given error.
 //
 // In addition to the functionality of grpc.Code, this will unwrap any wrapped
 // errors before asking for its code.
 func Code(err error) codes.Code {
-        if code := errors.ExtractData(err, grpcCodeKey); code != nil {
-                return code.(codes.Code)
+        if code, ok := Tag.In(err); ok {
+                return code
         }
         return grpc.Code(errors.Unwrap(err))
 }
 
-// Annotate begins annotating the error, and adds the given gRPC code.
-// This code may be extracted with the Code function in this package.
-func Annotate(err error, code codes.Code) *errors.Annotator {
-        return errors.Annotate(err).D(grpcCodeKey, code)
-}
-
 // ToGRPCErr is a shorthand for Errf(Code(err), "%s", err)
 func ToGRPCErr(err error) error {
         return Errf(Code(err), "%s", err)
 }
 
 // IsTransientCode returns true if a given gRPC code is associated with a
 // transient gRPC error type.
 func IsTransientCode(code codes.Code) bool {
         switch code {
         case codes.Internal, codes.Unknown, codes.Unavailable:
                 return true
 
         default:
                 return false
         }
 }