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

scheduler/appengine/engine/pubsub.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 engine
 
 import (
         "net/http"
         "sort"
         "strings"
 
         "golang.org/x/net/context"
         "google.golang.org/api/googleapi"
         "google.golang.org/api/pubsub/v1"
 
         "github.com/luci/luci-go/common/data/stringset"
         "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"
 )
 
 // createPubSubService returns configured instance of pubsub.Service.
 func createPubSubService(c context.Context, pubSubURL string) (*pubsub.Service, error) {
         // In real mode (not a unit test), use authenticated transport.
         var transport http.RoundTripper
         if pubSubURL == "" {
                 var err error
                 transport, err = auth.GetRPCTransport(c, auth.AsSelf, auth.WithScopes(pubsub.PubsubScope))
@@ skipping 24 matching lines @@
         service, err := createPubSubService(c, pubSubURL)
         if err != nil {
                 return err
         }
 
         // Create the topic. Ignore HTTP 409 (it means the topic already exists).
         logging.Infof(c, "Ensuring topic %q exists", topic)
         _, err = service.Projects.Topics.Create(topic, &pubsub.Topic{}).Context(c).Do()
         if err != nil && !isHTTP409(err) {
                 logging.Errorf(c, "Failed - %s", err)
-                return errors.WrapTransient(err)
+                return retry.Tag.Apply(err)
         }
 
         // Create the subscription to this topic. Ignore HTTP 409.
         logging.Infof(c, "Ensuring subscription %q exists", sub)
         _, err = service.Projects.Subscriptions.Create(sub, &pubsub.Subscription{
                 Topic:              topic,
                 AckDeadlineSeconds: 70, // GAE request timeout plus some spare time
                 PushConfig: &pubsub.PushConfig{
                         PushEndpoint: pushURL, // if "", the subscription will be pull based
                 },
         }).Context(c).Do()
         if err != nil && !isHTTP409(err) {
                 logging.Errorf(c, "Failed - %s", err)
-                return errors.WrapTransient(err)
+                return retry.Tag.Apply(err)
         }
 
         // Modify topic's IAM policy to allow publisher to publish.
         if strings.HasSuffix(publisher, ".gserviceaccount.com") {
                 publisher = "serviceAccount:" + publisher
         } else {
                 publisher = "user:" + publisher
         }
         logging.Infof(c, "Ensuring %q can publish to the topic", publisher)
 
         // Do two attempts, to account for possible race condition. Two attempts
         // should be enough to handle concurrent calls to 'configureTopic': second
         // attempt will read already correct IAM policy and will just end right away.
         for attempt := 0; attempt < 2; attempt++ {
                 err = modifyTopicIAMPolicy(c, service, topic, func(policy iamPolicy) error {
                         policy.grantRole("roles/pubsub.publisher", publisher)
                         return nil
                 })
                 if err == nil {
                         return nil
                 }
                 logging.Errorf(c, "Failed - %s", err)
         }
-        return errors.WrapTransient(err)
+        return retry.Tag.Apply(err)
 }
 
 // pullSubcription pulls one message from PubSub subscription.
 //
 // Used on dev server only. Returns the message and callback to call to
 // acknowledge the message.
 func pullSubcription(c context.Context, subscription, pubSubURL string) (*pubsub.PubsubMessage, func(), error) {
         service, err := createPubSubService(c, pubSubURL)
         if err != nil {
                 return nil, nil, err
@@ skipping 131 matching lines @@
 func (p iamPolicy) grantRole(role, principal string) {
         switch existing := p[role]; {
         case existing != nil && existing.Has(principal): // already there
                 return
         case existing != nil: // the role is there, but not the principal
                 existing.Add(principal)
         default:
                 p[role] = stringset.NewFromSlice(principal)
         }
 }