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

dm/appengine/distributor/jobsim/distributor.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 jobsim
 
 import (
         "encoding/json"
         "fmt"
         "io/ioutil"
@@ skipping 23 matching lines @@
 func (j *jobsimDist) jsConfig() *jobsim.Config {
         return j.cfg.Content.(*jobsim.Config)
 }
 
 func (j *jobsimDist) parsePayload(payload string) (*jobsimExecution, error) {
         ret := &jobsimExecution{}
         err := jsonpb.UnmarshalString(payload, &ret.Calculation)
         return ret, err
 }
 
-func (j *jobsimDist) Run(tsk *distributor.TaskDescription) (tok distributor.Token, _ time.Duration, err error) {
+func (j *jobsimDist) Run(desc *dm.Quest_Desc, exAuth *dm.Execution_Auth, prev *dm.JsonResult) (tok distributor.Token, _ time.Duration, err error) {
         // TODO(riannucci): Fix luci-gae so we can truly escape the transaction when
         // we build the jobsimDist instance. See luci/gae#23.
         ds := txnBuf.GetNoTxn(j.c)
 
         logging.Fields{
-                "eid": tsk.ExecutionAuth().Id,
+                "eid": exAuth.Id,
         }.Infof(j.c, "jobsim: running new task")
 
-        jtsk, err := j.parsePayload(tsk.Payload().Parameters)
+        jtsk, err := j.parsePayload(desc.Parameters)
         if err != nil {
                 return
         }
-        jtsk.ExAuth = *tsk.ExecutionAuth()
+        jtsk.ExAuth = *exAuth
         jtsk.Status = jobsimRunnable
-        jtsk.StateOrReason = tsk.PreviousResult().Object
+        if prev != nil {
+                jtsk.StateOrReason = prev.Object
+        }
         jtsk.CfgName = j.cfg.Name
 
         key := []*datastore.Key{
                 ds.MakeKey(datastore.GetMetaDefault(datastore.GetPLS(jtsk), "kind", ""), 0)}
         if err = ds.AllocateIDs(key); err != nil {
                 return
         }
 
         // transactionally commit the job and a taskqueue task to execute it
         jtsk.ID = fmt.Sprintf("%s|%d", j.jsConfig().Pool, key[0].IntID())
@@ skipping 18 matching lines @@
                         return err
                 }
                 logging.Infof(j.c, "jobsim: EnqueueTask'd")
                 return nil
         }, nil)
 
         tok = distributor.Token(jtsk.ID)
         return
 }
 
-func (j *jobsimDist) Cancel(tok distributor.Token) error {
+func (j *jobsimDist) Cancel(_ *dm.Quest_Desc, tok distributor.Token) error {
         jtsk := &jobsimExecution{ID: string(tok)}
 
         cancelBody := func(ds datastore.Interface) (needWrite bool, err error) {
                 if err = ds.Get(jtsk); err != nil {
                         return
                 }
                 if jtsk.Status != jobsimRunnable {
                         return
                 }
                 needWrite = true
                 return
         }
 
         ds := datastore.Get(j.c)
         if needWrite, err := cancelBody(ds); err != nil || !needWrite {
                 return err
         }
 
         return ds.RunInTransaction(func(c context.Context) error {
                 ds := datastore.Get(c)
                 if needWrite, err := cancelBody(ds); err != nil || !needWrite {
                         return err
                 }
                 jtsk.Status = jobsimCancelled
                 return ds.Put(jtsk)
         }, nil)
 }
 
-func (j *jobsimDist) GetStatus(tok distributor.Token) (*dm.Result, error) {
+func (j *jobsimDist) GetStatus(_ *dm.Quest_Desc, tok distributor.Token) (*dm.Result, error) {
         jtsk, err := loadTask(j.c, string(tok))
         if err != nil {
                 return nil, err
         }
 
         return getAttemptResult(jtsk.Status, jtsk.StateOrReason), nil
 }
 
 func (j *jobsimDist) InfoURL(tok distributor.Token) string {
         return fmt.Sprintf("jobsim://%s/ver/%s/tok/%s", j.cfg.Name, j.cfg.Version, tok)
 }
 
-func (j *jobsimDist) HandleNotification(note *distributor.Notification) (*dm.Result, error) {
+func (j *jobsimDist) HandleNotification(_ *dm.Quest_Desc, note *distributor.Notification) (*dm.Result, error) {
         n := &notification{}
         err := json.Unmarshal(note.Data, n)
         if err != nil {
                 return nil, err
         }
 
         return getAttemptResult(n.Status, n.StateOrReason), nil
 }
 
 func loadTask(c context.Context, rawTok string) (*jobsimExecution, error) {
@@ skipping 84 matching lines @@
         return err
 }
 
 // AddFactory adds this distributor implementation into the distributor
 // Registry.
 func AddFactory(m distributor.FactoryMap) {
         m[(*jobsim.Config)(nil)] = func(c context.Context, cfg *distributor.Config) (distributor.D, error) {
                 return &jobsimDist{c, cfg}, nil
         }
 }