Struct QueueServiceConfig 

pub struct QueueServiceConfig {
    pub default_policy: QueueServicePolicy,
    pub overrides: Vec<QueueServiceOverride>,
    pub service_availability_deadline: Option<Duration>,
    pub schedule_to_start_timeout: Option<Duration>,
}

The operator’s queue-service settings.

These are now the ONLY clocks that bound waiting for a worker

Worth stating here, where the clocks are set, because it changed and it is not obvious from anywhere else an operator reads.

An activity’s authored per-attempt timeout bounds the ATTEMPT — it starts when a worker accepts the work and the durable lease is recorded. It does NOT bound the time a dispatch spends waiting for a worker to exist. It used to, as a side effect of when the clock started, and that produced a bad answer twice over: an activity that waited eleven minutes and then ran for four seconds could blow a five-minute bound without ever having been slow, and the expiry could not cancel the dispatch it gave up on, so each one stacked another parked thread rather than freeing anything.

So the wait is bounded by Self::service_availability_deadline and Self::schedule_to_start_timeout, and by nothing else. Both default to None. A server whose operator has set neither will hold a dispatch to a queue with no eligible worker indefinitely, visibly — the queue-service state names the reason and GET /queues/unserved lists it — rather than failing it on a clock that was measuring the wrong thing. No default is invented for you: how long work may wait for a worker that does not exist is a decision about your fleet, not one this server can make on your behalf.

Fields

default_policy: QueueServicePolicy

Policy for every queue with no written override. strict.

overrides: Vec<QueueServiceOverride>

Written per-queue opt-ins. The first entry matching a dispatch wins, so a namespace-scoped entry placed before a namespace-less one is honoured.

service_availability_deadline: Option<Duration>

How long a dispatch waits for a compatible worker to exist before a typed WorkerUnavailable refusal. Unset = unbounded.

schedule_to_start_timeout: Option<Duration>

How long a dispatch tries to hand its task to a live compatible worker before a typed SATURATED refusal. Unset = one attempt, exactly as before.

Implementations

impl QueueServiceConfig

pub fn policy_for( &self, namespace: &str, task_queue: &str, ) -> QueueServicePolicy

The policy governing one dispatch address.

pub const fn availability_deadline_for( &self, policy: QueueServicePolicy, ) -> Option<Duration>

Whether the service-availability deadline governs this dispatch.

durable_pending is precisely the declaration that this dispatch waits for its worker, so the availability deadline — the strict policy’s instrument for refusing rather than lying — does not cut it short. The schedule-to-start clock still applies under both policies: it bounds a hand-off to a worker that already exists, which is a different question.

Trait Implementations

impl Clone for QueueServiceConfig

fn clone(&self) -> QueueServiceConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QueueServiceConfig

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

Formats the value using the given formatter.

impl Default for QueueServiceConfig

fn default() -> QueueServiceConfig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for QueueServiceConfig

where QueueServiceConfig: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for QueueServiceConfig

impl PartialEq for QueueServiceConfig

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for QueueServiceConfig