luci: go.chromium.org/luci/swarming/proto/jsonrpc Index | Files

package jsonrpc

import "go.chromium.org/luci/swarming/proto/jsonrpc"

Index

Package Files

gen.go taskstate.pb.go

Variables

var TaskState_name = map[int32]string{
    0:   "INVALID",
    16:  "RUNNING",
    32:  "PENDING",
    48:  "EXPIRED",
    64:  "TIMED_OUT",
    80:  "BOT_DIED",
    96:  "CANCELED",
    112: "COMPLETED",
    128: "KILLED",
    256: "NO_RESOURCE",
}
var TaskState_value = map[string]int32{
    "INVALID":     0,
    "RUNNING":     16,
    "PENDING":     32,
    "EXPIRED":     48,
    "TIMED_OUT":   64,
    "BOT_DIED":    80,
    "CANCELED":    96,
    "COMPLETED":   112,
    "KILLED":      128,
    "NO_RESOURCE": 256,
}

type TaskState Uses

type TaskState int32

TaskState defines the TaskState enum used by the swarming json rpc interface. This is not to be confused with the new proto rpc interface, which has its own incompatible definition of TaskState.

If you make any modifications, please keep comments in sync and make corresponding modifications swarming_rpcs.py:TaskState

const (
    // Invalid state, do not use.
    TaskState_INVALID TaskState = 0
    // The task is currently running. This is in fact 3 phases: the initial
    // overhead to fetch input files, the actual task running, and the tear down
    // overhead to archive output files to the server.
    TaskState_RUNNING TaskState = 16
    // The task is currently pending. This means that no bot reaped the task. It
    // will stay in this state until either a task reaps it or the expiration
    // elapsed. The task pending expiration is specified as
    // TaskSlice.expiration_secs, one per task slice.
    TaskState_PENDING TaskState = 32
    // The task is not pending anymore, and never ran due to lack of capacity. This
    // means that other higher priority tasks ran instead and that not enough bots
    // were available to run this task for TaskSlice.expiration_secs seconds.
    TaskState_EXPIRED TaskState = 48
    // The task ran for longer than the allowed time in
    // TaskProperties.execution_timeout_secs or TaskProperties.io_timeout_secs.
    // This means the bot forcefully killed the task process as described in the
    // graceful termination dance in the documentation.
    TaskState_TIMED_OUT TaskState = 64
    // The task ran but the bot had an internal failure, unrelated to the task
    // itself. It can be due to the server being unavailable to get task update,
    // the host on which the bot is running crashing or rebooting, etc.
    TaskState_BOT_DIED TaskState = 80
    // The task never ran, and was manually cancelled via the 'cancel' API before
    // it was reaped.
    TaskState_CANCELED TaskState = 96
    // The task ran and completed normally. The task process exit code may be 0 or
    // another value.
    TaskState_COMPLETED TaskState = 112
    // The task ran but was manually killed via the 'cancel' API. This means the
    // bot forcefully killed the task process as described in the graceful
    // termination dance in the documentation.
    TaskState_KILLED TaskState = 128
    // The task was never set to PENDING and was immediately refused, as the server
    // determined that there is no bot capacity to run this task. This happens
    // because no bot exposes a superset of the requested task dimensions.
    //
    // Set TaskSlice.wait_for_capacity to True to force the server to keep the task
    // slice pending even in this case. Generally speaking, the task will
    // eventually switch to EXPIRED, as there's no bot to run it. That said, there
    // are situations where it is known that in some not-too-distant future a wild
    // bot will appear that will be able to run this task.
    TaskState_NO_RESOURCE TaskState = 256
)

func (TaskState) EnumDescriptor Uses

func (TaskState) EnumDescriptor() ([]byte, []int)

func (TaskState) String Uses

func (x TaskState) String() string

Package jsonrpc imports 3 packages (graph). Updated 2019-11-11. Refresh now. Tools for package owners.