Enum Waiting 

pub enum Waiting {
    Paused,
    Backoff {
        until: u64,
        cause: HoldCause,
    },
    RunnerStarting,
    Reseeding {
        profile: String,
    },
    PullingImage {
        profile: String,
    },
    NoSlot {
        profile: String,
    },
    Memory {
        needs: u64,
        free: u64,
    },
    HostMemory {
        needs: u64,
        free: u64,
    },
    Cpu {
        needs: u64,
        free: u64,
    },
    BehindCpu {
        job: u64,
    },
    BehindStart {
        job: u64,
    },
}

Why a queued job has no runner of its own yet. Jobs are served oldest first; each takes the first of these that holds for it.

Variants

Paused

Its repository is paused.

Backoff

Runners of its repository failed, so none starts before until (seconds since the Unix epoch).

Fields

until: u64

When runners may start again.

cause: HoldCause

What failed; NoJob from a daemon before it said.

RunnerStarting

A runner started for it and waits for GitHub to hand it the job: a runner takes any job its labels match, so not necessarily this one.

Reseeding

Slot 1 of its profile is becoming the profile’s snapshot, so none of the profile’s slots starts.

Fields

profile: String

The profile.

PullingImage

Its profile’s image is being pulled, so none of the profile’s slots starts.

Fields

profile: String

The profile.

NoSlot

Every slot of its profile holds a runner.

Fields

profile: String

The profile.

Memory

What its runner would reserve does not fit the memory budget left. Under measured admission, free is 0 while the slice is at the high-water mark (Budget::held).

Fields

needs: u64

What its runner would reserve, in bytes.

free: u64

What the budget has left, in bytes.

HostMemory

What its runner would reserve does not fit what the host’s memory has to spare beside its other programs (HostBudget::spare), though it fits the slice’s budget. free is 0 while the host’s tasks stall for memory (HostBudget::stalled).

Fields

needs: u64

What its runner would reserve, in bytes.

free: u64

What the host has to spare, in bytes.

Cpu

What its runner would reserve does not fit the CPU budget left, in millicores.

Fields

needs: u64

What its runner would reserve.

free: u64

What the CPU budget has left.

BehindCpu

An older job has waited long enough for CPU that no younger one takes CPU before it.

Fields

job: u64

The older job’s ID.

BehindStart

An older job is about to have a runner start for it, which takes the slot, memory or CPU this one would otherwise start with: what holds it is that start, not what runs now.

Fields

job: u64

The older job’s ID.

Implementations

impl Waiting

pub fn kind(&self) -> WaitKind

What it waits on.

pub fn reason(&self, job: &QueuedJob, status: &Status, now: u64) -> String

Why job waits, in the owner’s words with the numbers that hold it, as every client says it: such as All 2 node slots are busy or Needs 9G of memory; 2.5G of the budget is free. status is the one job is queued in, which names the slot of a starting runner and the older job one waits behind.

Trait Implementations

impl Clone for Waiting

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Waiting

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Waiting

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Waiting

impl PartialEq for Waiting

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Waiting

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Waiting