scheduler: add rpcs for actions on job and invocation.

scheduler/appengine/engine/engine.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 implements the core logic of the scheduler service.
 package engine
 
 import (
         "bytes"
         "encoding/json"
@@ skipping 25 matching lines @@
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/auth/identity"
         "github.com/luci/luci-go/server/auth/signing"
         "github.com/luci/luci-go/server/tokens"
 
         "github.com/luci/luci-go/scheduler/appengine/catalog"
         "github.com/luci/luci-go/scheduler/appengine/schedule"
         "github.com/luci/luci-go/scheduler/appengine/task"
 )
 
+var (
+        ErrNoSuchJob        = errors.New("no such job")
+        ErrNoSuchInvocation = errors.New("the invocation doesn't exist")
+)
+
 // Engine manages all scheduler jobs: keeps track of their state, runs state
 // machine transactions, starts new invocations, etc. A method returns
 // errors.Transient if the error is non-fatal and the call should be retried
 // later. Any other error means that retry won't help.
 type Engine interface {
         // GetAllProjects returns a list of all projects that have at least one
         // enabled scheduler job.
         GetAllProjects(c context.Context) ([]string, error)
 
         // GetAllJobs returns a list of all enabled scheduler jobs in no particular
@@ skipping 55 matching lines @@
         // start an invocation). Normally one nonce corresponds to one Invocation
         // entity, but there can be more if job fails to start with a transient error.
         TriggerInvocation(c context.Context, jobID string, triggeredBy identity.Identity) (int64, error)
 
         // PauseJob replaces job's schedule with "triggered", effectively preventing
         // it from running automatically (until it is resumed). Manual invocations are
         // still allowed. Does nothing if job is already paused. Any pending or
         // running invocations are still executed.
         PauseJob(c context.Context, jobID string, who identity.Identity) error
 
-        // ResumeJob resumed paused job. Doesn't nothing if the job is not paused.
+        // ResumeJob resumes paused job. Doesn't nothing if the job is not paused.
         ResumeJob(c context.Context, jobID string, who identity.Identity) error
 
         // AbortInvocation forcefully moves the invocation to failed state.
         //
         // It opportunistically tries to send "abort" signal to a job runner if it
         // supports cancellation, but it doesn't wait for reply. It proceeds to
         // modifying local state in the scheduler service datastore immediately.
         //
         // AbortInvocation can be used to manually "unstuck" jobs that got stuck due
         // to missing PubSub notifications or other kinds of unexpected conditions.
@@ skipping 902 matching lines @@
         default:
                 return fmt.Errorf("unexpected invocation action kind %q", payload)
         }
 }
 
 func (e *engineImpl) TriggerInvocation(c context.Context, jobID string, triggeredBy identity.Identity) (int64, error) {
         var err error
         var invNonce int64
         err2 := e.txn(c, jobID, func(c context.Context, job *Job, isNew bool) error {
                 if isNew {
-                        err = errors.New("no such job")
+                        err = ErrNoSuchJob
                         return errSkipPut
                 }
                 if !job.Enabled {
                         err = errors.New("the job is disabled")
                         return errSkipPut
                 }
                 invNonce = 0
                 return e.rollSM(c, job, func(sm *StateMachine) error {
                         if err := sm.OnManualInvocation(triggeredBy); err != nil {
                                 return err
@@ skipping 12 matching lines @@
         return e.setPausedFlag(c, jobID, true, who)
 }
 
 func (e *engineImpl) ResumeJob(c context.Context, jobID string, who identity.Identity) error {
         return e.setPausedFlag(c, jobID, false, who)
 }
 
 func (e *engineImpl) setPausedFlag(c context.Context, jobID string, paused bool, who identity.Identity) error {
         return e.txn(c, jobID, func(c context.Context, job *Job, isNew bool) error {
                 if isNew || !job.Enabled {
-                        return errors.New("no such job")
+                        return ErrNoSuchJob
                 }
                 if job.Paused == paused {
                         return errSkipPut
                 }
                 if paused {
                         logging.Warningf(c, "Job is paused by %s", who)
                 } else {
                         logging.Warningf(c, "Job is resumed by %s", who)
                 }
                 job.Paused = paused
                 return e.rollSM(c, job, func(sm *StateMachine) error {
                         sm.OnScheduleChange()
                         return nil
                 })
         })
 }
 
 func (e *engineImpl) AbortInvocation(c context.Context, jobID string, invID int64, who identity.Identity) error {
         c = logging.SetField(c, "JobID", jobID)
         c = logging.SetField(c, "InvID", invID)
 
         var inv *Invocation
         var err error
         switch inv, err = e.GetInvocation(c, jobID, invID); {
         case err != nil:
                 logging.Errorf(c, "Failed to fetch the invocation - %s", err)
                 return err
         case inv == nil:
                 logging.Errorf(c, "The invocation doesn't exist")
-                return errors.New("the invocation doesn't exist")
+                return ErrNoSuchInvocation
         case inv.Status.Final():
                 return nil
         }
 
         ctl, err := e.controllerForInvocation(c, inv)
         if err != nil {
                 logging.Errorf(c, "Cannot get controller - %s", err)
                 return err
         }
 
@@ skipping 183 matching lines @@
         c = logging.SetField(c, "JobID", jobID)
         c = logging.SetField(c, "InvID", invID)
 
         logging.Infof(c, "Handling invocation timer %q", timer.Name)
         inv, err := e.GetInvocation(c, jobID, invID)
         if err != nil {
                 logging.Errorf(c, "Failed to fetch the invocation - %s", err)
                 return err
         }
         if inv == nil {
-                return errors.New("the invocation doesn't exist")
+                return ErrNoSuchInvocation
         }
 
         // Finished invocations are immutable, skip the message.
         if inv.Status.Final() {
                 logging.Infof(c, "Skipping the timer, the invocation is in final state %q", inv.Status)
                 return nil
         }
 
         // Build corresponding controller.
         ctl, err := e.controllerForInvocation(c, inv)
@@ skipping 364 matching lines @@
         }
 
         c = logging.SetField(c, "JobID", jobID)
         c = logging.SetField(c, "InvID", invID)
         inv, err := e.GetInvocation(c, jobID, invID)
         if err != nil {
                 logging.Errorf(c, "Failed to fetch the invocation - %s", err)
                 return err
         }
         if inv == nil {
-                return errors.New("the invocation doesn't exist")
+                return ErrNoSuchInvocation
         }
 
         // Finished invocations are immutable, skip the message.
         if inv.Status.Final() {
                 logging.Infof(c, "Skipping the notification, the invocation is in final state %q", inv.Status)
                 return nil
         }
 
         // Build corresponding controller.
         ctl, err := e.controllerForInvocation(c, inv)
@@ skipping 230 matching lines @@
                 }
                 if hasFinished {
                         return ctl.eng.rollSM(c, job, func(sm *StateMachine) error {
                                 sm.OnInvocationDone(saving.ID)
                                 return nil
                         })
                 }
                 return nil
         })
 }