Initial distributor implementation

appengine/cmd/dm/enums/execution/state.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 //go:generate stringer -type=State
 
 package execution
 
 import (
         "fmt"
 )
 
 // State is the state that a single Execution can be in.
 type State int8
 
 // State values
 const (
-        UnknownState State = iota
+        Unknown State = iota
 
+        // The execution has been accepted by the distributor, but is not running yet
         Scheduled
-        Running
 
+        // The execution is running
+        Started
+
+        // The execution was unable to be accepted by the distributor
         Rejected
+
+        // The execution was accepted by the distributor, but couldn't run in time.
+        TimedOut
+
+        // The execution ran and completed
         Finished
-        Crashed
+
+        // The execution ran, but the distributor claims it did not complete
+        Failed
+
+        // The distributor claims to not know anything about this execution
+        Missing
+
+        // Some entity (DM, Human, Distributor) requested that this execution not run.
+        Cancelled
 )
 
 // validStateEvolution defines all valid {From -> []To} state transitions. The
 // identity transition (X -> X) is implied, as long as X has an entry in this
 // mapping.
 var validStateEvolution = map[State][]State{
-        Scheduled: {Running, Rejected, Crashed, Finished},
-        Running:   {Crashed, Finished, Rejected},
+        Scheduled: {Started, Finished, Missing, Cancelled, TimedOut},
+        Started:   {Finished, Failed, Missing, Cancelled},
 
-        Crashed:  {},
-        Finished: {},
-        Rejected: {},
+        Cancelled: {},
+        Finished:  {},
+        Failed:    {},
+        Missing:   {},
+        Rejected:  {},
+        TimedOut:  {},
+}
+
+// FromString returns the State for it's equivalent string representation.
+//
+// All unknown state vals are converted to Unknown.
+func FromString(val string) State {
+        switch val {
+        case "Scheduled":
+                return Scheduled
+        case "Started":
+                return Started
+        case "Rejected":
+                return Rejected
+        case "TimedOut":
+                return TimedOut
+        case "Finished":
+                return Finished
+        case "Failed":
+                return Failed
+        case "Missing":
+                return Missing
+        case "Cancelled":
+                return Cancelled
+        }
+        return Unknown
+}
+
+// IsTerminal returns True if State has no more valid evolutions.
+func (s State) IsTerminal() bool {
+        return len(validStateEvolution[s]) == 0
 }
 
 // Evolve attempts to evolve the state of this Attempt. If the state
 // evolution is not allowed (e.g. invalid state transition), this returns an
 // error.
 func (s *State) Evolve(newState State) error {
         nextStates := validStateEvolution[*s]
         if nextStates == nil {
                 return fmt.Errorf("invalid state transition: no transitions defined for %s", *s)
         }
@@ skipping 12 matching lines @@
         return fmt.Errorf("invalid state transition %v -> %v", *s, newState)
 }
 
 // MustEvolve is a panic'ing version of Evolve.
 func (s *State) MustEvolve(newState State) {
         err := s.Evolve(newState)
         if err != nil {
                 panic(err)
         }
 }