Enum QueueServiceReason 

pub enum QueueServiceReason {
    NoQueueDeclaration,
    NoLivePollers,
    PollersIncompatible,
    Saturated,
    PollersUnreachable,
    PollersAtCapacity,
    PollersCapacityUnannounced,
}

Why a (namespace, task_queue, activity_type) address is not being served.

The names are R1’s, verbatim, and are the strings that reach logs, dispatch failures, and the queue-service accessor.

Variants

NoQueueDeclaration

No deployed .v4 contract declares this task queue at all. Structural: no worker can ever legitimately arrive for it, so it refuses unconditionally under every policy.

NoLivePollers

The queue is declared (or its declaration is unknowable) and no worker is connected for the pool at all.

PollersIncompatible

Workers are connected for the pool but none of them covers this activity type, or none of them sits on the dispatch’s pinned node.

Saturated

A compatible worker is connected and its intake is refusing work: the task could not be handed over before the schedule-to-start clock expired.

PollersUnreachable

Workers are connected and DO serve this activity on this node, but the liveness verdict has withdrawn dispatch eligibility from all of them after losing reachability.

🔴 Distinct from Self::PollersIncompatible because the remedies are close to opposite. Incompatible pollers need a worker deployed that covers the activity; these workers already cover it, and deploying another changes nothing — the fault is on the wire to the ones already there. Distinct from an opening probation, which is not reported at all because it clears itself within seconds.

PollersAtCapacity

Workers are connected, DO serve this activity on this node, and every one of them is already running every activity it advertised it would run at once. The work is queued and starts as capacity frees.

🔴 The one reason in this taxonomy that describes a HEALTHY fleet, which is why it could not be folded into any of the others. Every existing sentence here would be a lie about a busy pool: nothing is missing, no wire has failed, no deployment is absent. Its remedy is the exact opposite of Self::PollersUnreachable’s — starting another worker helps here and does not help there — and two opposite pieces of advice cannot share one name. (Self::NoLivePollers shares the remedy but not the diagnosis: there the pool is empty, here it is full and working.)

PollersCapacityUnannounced

Workers are connected and DO serve this activity on this node, at least one of them has not announced how much work it can take, and no worker whose capacity IS known has a free slot — so the server has nothing it can honestly select against.

Reported on > 0 rather than on the whole population, and it OUTRANKS Self::PollersAtCapacity in super::census::classify. Both conditions can hold of one pool at once, only one reason can be published, and this is the one that may need an operator: a busy pool clears itself as work completes, a mute worker does not.

🔴 NOT a quieter Self::PollersAtCapacity, and the distinction is the whole reason this variant exists. Selection excludes an unannounced worker by treating unknown capacity as full — the safe direction, since the alternative is inventing a number for a process that is about to state its own — but reporting that exclusion as “at capacity” would tell an operator their fleet was busy when it is idle and mute. The advice attached to a busy pool (“start another worker, or raise concurrency”) is actively wrong here: another worker of the same build will be just as silent.

Ordinarily invisible. It is true for exactly one round trip after a liminal worker registers, and a dispatch has to miss inside that window to see it. Persisting past that is the signal: the worker is an older build that does not announce, or its announcement was lost.

Implementations

impl QueueServiceReason

pub const ALL: [Self; 7]

Every variant, and the single source of that set.

🔴 Self::parse and the round-trip test both read THIS, so a variant missing here is a variant that cannot be parsed back from its own spelling — a wire value the server writes and then fails to read. The exhaustive match in Self::as_str forces a new variant to be given a spelling, but nothing forces it into this list; all_lists_every_variant is what does, by matching exhaustively so the compiler refuses a variant this list has not been told about.

pub const fn as_str(self) -> &'static str

The canonical wire/log spelling.

pub const fn is_structural(self) -> bool

Whether the unservability is structural — provable from the deployed contract records alone, unchangeable by waiting or retrying.

pub fn explain(self, address: &ServiceAddress) -> String

The operator-facing sentence for this reason at address: what has to be fixed, in words.

This is the single source of that sentence. The dispatch refusal’s human tail (WorkerUnavailable::explain) and the describe projection’s detail both read it here, so a queue that is unserved cannot be explained one way in a refusal and another way in a read.

pub fn parse(text: &str) -> Option<Self>

Read a reason back from its canonical spelling.

Trait Implementations

impl Clone for QueueServiceReason

fn clone(&self) -> QueueServiceReason

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for QueueServiceReason

impl Debug for QueueServiceReason

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

Formats the value using the given formatter.

impl Display for QueueServiceReason

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

Formats the value using the given formatter.

impl Eq for QueueServiceReason

impl Hash for QueueServiceReason

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for QueueServiceReason

fn cmp(&self, other: &QueueServiceReason) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for QueueServiceReason

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for QueueServiceReason

fn partial_cmp(&self, other: &QueueServiceReason) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for QueueServiceReason