Refactor distributor API so that methods always get the Quest_Desc too.

dm/appengine/mutate/timeout_execution.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 mutate
 
 import (
         "fmt"
         "time"
 
         "golang.org/x/net/context"
 
+        "github.com/luci/gae/filter/txnBuf"
         "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/common/clock"
+        "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
         dm "github.com/luci/luci-go/dm/api/service/v1"
         "github.com/luci/luci-go/dm/appengine/distributor"
         "github.com/luci/luci-go/dm/appengine/model"
         "github.com/luci/luci-go/tumble"
 )
 
 // TimeoutExecution is a named mutation which triggers on a delay. If the
 // execution is in the noted state when the trigger hits, this sets the
 // Execution to have an AbnormalFinish status of TIMED_OUT.
@@ skipping 53 matching lines @@
                 // TODO(iannucci): make this set the REJECTED state if we loaded the config,
                 // but the distributor no longer exists.
                 if err != nil {
                         logging.Fields{
                                 logging.ErrorKey: err,
                                 "cfgName":        e.DistributorConfigName,
                         }.Errorf(c, "Could not MakeDistributor")
                         return
                 }
                 var realRslt *dm.Result
-                realRslt, err = dist.GetStatus(distributor.Token(e.DistributorToken))
+                q := model.QuestFromID(t.For.Quest)
+                if err = txnBuf.GetNoTxn(c).Get(q); err != nil {
+                        err = errors.Annotate(err).Reason("loading quest").Err()
+                        return
+                }
+                realRslt, err = dist.GetStatus(&q.Desc, distributor.Token(e.DistributorToken))
                 if (err != nil || realRslt == nil) && t.TimeoutAttempt < maxTimeoutAttempts {
                         logging.Fields{
                                 logging.ErrorKey:  err,
                                 "task_result":     realRslt,
                                 "timeout_attempt": t.TimeoutAttempt,
                         }.Infof(c, "GetStatus failed/nop'd while timing out STOPPING execution")
                         // TODO(riannucci): do randomized exponential backoff instead of constant
                         // backoff? Kinda don't really want to spend more than 1.5m waiting
                         // anyway, and the actual GetStatus call does local retries already, so
                         // hopefully this is fine. If this is wrong, the distributor should adjust
@@ skipping 43 matching lines @@
                 return tumble.CancelNamedMutations(c, key, "timeout")
         }
         return tumble.PutNamedMutations(c, key, map[string]tumble.Mutation{
                 "timeout": &TimeoutExecution{eid, e.State, 0, clock.Now(c).UTC().Add(howLong)},
         })
 }
 
 func init() {
         tumble.Register((*TimeoutExecution)(nil))
 }