Struct TaskSpec 

pub struct TaskSpec<P> {

    pub payload: Arc<P>,
    pub kind: Arc<str>,
    pub pool: Arc<str>,
    pub priority: Priority,
    pub key: Option<Arc<str>>,
    pub deadline: Option<Time>,
    pub fixed_start: Option<FixedStart>,
    pub duration_hint: Option<Duration>,
    pub timeout: Option<Duration>,
    pub retry: Option<RetryPolicy>,
    pub deps: Vec<Dep>,
    pub resources: SmallVec<[(Arc<str>, u32); 2]>,
    pub tags: Vec<(Arc<str>, Arc<str>)>,
    pub labels: Vec<(Arc<str>, Arc<str>)>,
    pub tenant: Option<Arc<str>>,
}

Everything the engine needs to schedule one task.

Built with TaskSpec::new and the chained setters; all fields are public for direct use.

Fields

payload: Arc<P>

The work itself, handed to the executor unchanged.

kind: Arc<str>

Free-form category; duration statistics are learned per (pool, kind).

pool: Arc<str>

Pool that runs the task (default "default").

priority: Priority

Priority class.

key: Option<Arc<str>>

Optional unique key: deduplicates submissions while the task is live or retained, and lets dependents refer to it by name.

deadline: Option<Time>

Soft deadline for completion; urgency rises as its latest start time approaches.

fixed_start: Option<FixedStart>

Start at (or close to) a given time, with capacity reserved in advance.

duration_hint: Option<Duration>

Expected runtime; when absent the engine uses learned statistics.

timeout: Option<Duration>

Per-attempt timeout.

retry: Option<RetryPolicy>

None uses the pool default.

deps: Vec<Dep>

Tasks that must finish first (see Dep).

resources: SmallVec<[(Arc<str>, u32); 2]>

Shared resources needed while running: (resource name, amount).

tags: Vec<(Arc<str>, Arc<str>)>

Labels passed through to executors (e.g. traceparent, tenant).

labels: Vec<(Arc<str>, Arc<str>)>

Worker labels this task requires: it runs only on a worker group whose labels include every (name, value) pair (see Core::set_group_capacity).

tenant: Option<Arc<str>>

Tenant the task belongs to, for weighted fair sharing of pools with PoolConfig::fairness.

Implementations

impl<P> TaskSpec<P>

pub fn map_payload<Q>(self, payload: Arc<Q>) -> TaskSpec<Q>

Same task description with a different payload type.

pub fn new(payload: P) -> Self

A Normal task in the "default" pool.

pub fn from_arc(payload: Arc<P>) -> Self

Like TaskSpec::new with an already shared payload.

pub fn kind(self, k: impl Into<Arc<str>>) -> Self

Set the kind.

pub fn pool(self, p: impl Into<Arc<str>>) -> Self

Set the pool.

pub fn priority(self, p: Priority) -> Self

Set the priority class.

pub fn key(self, k: impl Into<Arc<str>>) -> Self

Set the unique key.

pub fn deadline(self, t: Time) -> Self

Set the deadline.

pub fn fixed_start(self, f: FixedStart) -> Self

Set a fixed start.

pub fn duration_hint(self, d: Duration) -> Self

Set the expected runtime.

pub fn timeout(self, d: Duration) -> Self

Set the per-attempt timeout.

pub fn retry(self, r: RetryPolicy) -> Self

Set the retry policy.

pub fn dep(self, d: Dep) -> Self

Add a dependency.

pub fn after(self, target: impl Into<TaskRef>) -> Self

Run after target succeeds.

pub fn resource(self, name: impl Into<Arc<str>>, amount: u32) -> Self

Require amount units of a resource while running.

pub fn tag(self, k: impl Into<Arc<str>>, v: impl Into<Arc<str>>) -> Self

Add a label.

pub fn tenant(self, tenant: impl Into<Arc<str>>) -> Self

The tenant the task belongs to (for fair sharing).

pub fn label( self, name: impl Into<Arc<str>>, value: impl Into<Arc<str>>, ) -> Self

Require a worker label (name = value) to run.

Trait Implementations

impl<P> Clone for TaskSpec<P>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug> Debug for TaskSpec<P>

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

Formats the value using the given formatter.