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

scheduler/appengine/task/swarming/swarming.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 swarming implements tasks that run Swarming jobs.
 package swarming
 
 import (
         "encoding/json"
         "fmt"
         "net/url"
         "time"
 
         "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
         "google.golang.org/api/pubsub/v1"
 
         "github.com/luci/gae/service/info"
         "github.com/luci/luci-go/common/api/swarming/swarming/v1"
         "github.com/luci/luci-go/common/errors"
+        "github.com/luci/luci-go/common/retry/transient"
         "github.com/luci/luci-go/scheduler/appengine/messages"
         "github.com/luci/luci-go/scheduler/appengine/task"
         "github.com/luci/luci-go/scheduler/appengine/task/utils"
 )
 
 const (
         statusCheckTimerName     = "check-swarming-task-status"
         statusCheckTimerInterval = time.Minute
 )
 
@@ skipping 318 matching lines @@
 // invocation status based on it.
 //
 // Called on PubSub notifications and also periodically by timer.
 func (m TaskManager) checkTaskStatus(c context.Context, ctl task.Controller) error {
         switch status := ctl.State().Status; {
         // This can happen if Swarming manages to send PubSub message before
         // LaunchTask finishes. Do not touch State or DebugLog to avoid collision with
         // still running LaunchTask when saving the invocation, it will only make the
         // matters worse.
         case status == task.StatusStarting:
-                return errors.WrapTransient(errors.New("invocation is still starting, try again later"))
+                return errors.New("invocation is still starting, try again later", transient.Tag)
         case status != task.StatusRunning:
                 return fmt.Errorf("unexpected invocation status %q, expecting %q", status, task.StatusRunning)
         }
 
         // Grab task ID from the blob generated in LaunchTask.
         taskData := taskData{}
         if err := json.Unmarshal(ctl.State().TaskData, &taskData); err != nil {
                 ctl.State().Status = task.StatusFailed
                 return fmt.Errorf("could not parse TaskData - %s", err)
         }
 
         // Fetch task result from Swarming.
         service, err := m.createSwarmingService(c, ctl)
         if err != nil {
                 return err
         }
         resp, err := service.Task.Result(taskData.SwarmingTaskID).Do()
         if err != nil {
                 ctl.DebugLog("Failed to fetch task results - %s", err)
                 err = utils.WrapAPIError(err)
-                if !errors.IsTransient(err) {
+                if !transient.Tag.In(err) {
                         ctl.State().Status = task.StatusFailed
                 }
                 return err
         }
 
         blob, err := json.MarshalIndent(resp, "", "  ")
         if err != nil {
                 return err
         }
         m.handleTaskResult(c, ctl, resp)
@@ skipping 14 matching lines @@
                 r.State, r.Failure, r.InternalFailure)
         switch {
         case r.State == "PENDING" || r.State == "RUNNING":
                 return // do nothing
         case r.State == "COMPLETED" && !(r.Failure || r.InternalFailure):
                 ctl.State().Status = task.StatusSucceeded
         default:
                 ctl.State().Status = task.StatusFailed
         }
 }