Struct TaskNode 

pub struct TaskNode {
    pub name: &'static str,
    pub mode: Mode,
    pub spawn: Option<fn(Spawner) -> Result<(), SpawnError>>,
    /* private fields */
}

A node in the supervisor’s task graph.

Designed to live in static memory: every field is Sync, all constructors are const. Declared by supervisor_graph!, which emits one per managed task along with the Graph (GRAPH) that Supervisor::new consumes.

Fields

name: &'static str

Human-readable name. Used in defmt logs and panic messages.

mode: Mode

Lifecycle policy. See Mode.

spawn: Option<fn(Spawner) -> Result<(), SpawnError>>

App-provided spawn function (typically an inline closure at the node’s declaration). Called once at boot from Supervisor::start, again from respawn_terminate for Terminate nodes, and at runtime from start_node for OnDemand nodes. None for a parked node the application spawns itself (e.g. a Pause sensor holding a peripheral handle): the supervisor tracks its lifecycle but never spawns it.

Implementations

impl TaskNode

pub const fn new( name: &'static str, mode: Mode, spawn: Option<fn(Spawner) -> Result<(), SpawnError>>, disabled_at_boot: bool, ) -> Self

A single-instance node started at boot (Terminate/Pause) or on demand (Mode::OnDemand). Every node is single-instance; an elastic service is modelled as several OnDemand nodes of the same pooled task fn.

A TaskNode carries only its own identity and behaviour; the graph’s dependency edges live in the compile-time index table that supervisor_graph! emits and Supervisor::new consumes. disabled_at_boot seeds the node’s disabled flag so a control-started node (e.g. an OTA task) can be declared down and started later via a control op. spawn is None for a parked node the application spawns itself.

pub const fn with_executor(self, slot: &'static SpawnerSlot) -> Self

Route this node’s spawn through the given executor SpawnerSlot (the executor: NAME graph annotation). The supervisor awaits the slot before spawning the node, so a tier filled late — or from another core — is handled without a race, and the generated glue’s non-blocking get is already filled. const and chainable in a static initializer; emitted by supervisor_graph!.

pub const fn with_resources( self, gates: &'static [&'static dyn ResourceGate], ) -> Self

Declare the ResourceSlots this node’s spawn takes from (the resources: graph clause). The supervisor awaits every gate being filled before spawning the node, so the generated glue’s non-blocking take() finds the value. const and chainable in a static initializer; emitted by supervisor_graph!.

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

Override the pre-spawn slot/gate wait bound for this node (the slot_timeout: <millis> graph clause). The default (SLOT_READY_TIMEOUT, 100 ms) assumes slots are provided before start(); a node consuming a provider node’s outputs must cover the provider’s async build time (the failure mode stays a loud SpawnError::Busy, just later). const and chainable in a static initializer; emitted by supervisor_graph!.

pub fn shutdown_requested(&self) -> bool

True iff the supervisor has requested shutdown. Checked at the loop top alongside wait_shutdown() in a select.

pub async fn wait_shutdown(&self)

Park until shutdown is requested. Returns immediately if shutdown has already been requested. Use this for single-instance tasks in a select against the task’s main work future.

pub fn ack_dropped(&self)

Mark this instance as having shut down: clears the running flag and acks the teardown handshake (so the supervisor’s wait_dropped completes). Every instance must call this exactly once on exit (Terminate/OnDemand mode) or on each pause (Pause mode). It also covers an autonomous exit the supervisor didn’t request — e.g. a pool worker backing off — so the pool sees the instance as down and can re-grow it under later demand.

pub async fn wait_resume(&self)

Pause-mode only: park until the supervisor signals resume. Call after ack_dropped — ack the pause, then park; held resources stay owned across the park.

pub fn mark_busy(&self)

Report that this task started serving a request (active). Fires the scale-request signal on a real idle→busy transition so the scaling policy can react (e.g. grow the pool); a redundant call doesn’t re-signal.

pub fn mark_idle(&self)

Report that this task finished serving and is idle again. Fires the scale-request signal on a real busy→idle transition so the scaling policy can react (e.g. shrink the pool); a redundant call doesn’t re-signal.

pub fn is_busy(&self) -> bool

True while this task is actively serving. Read by the scaling policy.

pub fn is_running(&self) -> bool

True while the supervisor has this node spawned (and it hasn’t exited). Read by the scaling policy to count live instances, and by a task-state view.

pub fn is_disabled(&self) -> bool

True while the node is disabled: declared disabled in the graph (stopped-at-boot, up on an explicit Activate), or manually deactivated via the control interface and not yet re-activated. Read by a task-state view and by the automatic bring-up paths (which skip a disabled node).

pub fn set_detached(&self, detached: bool)

Mark/clear this node as detached: a self-managing node the supervisor brings up once (via start) and then stops managing entirely. Every runtime lifecycle operation skips a detached node: full teardown, the control deactivate/activate cascades, stop_node, respawn_terminate, and pause-resume. It keeps running (or, for a one-shot, stays exited) across a teardown/wake cycle instead of being stopped, re-enabled, or re-spawned. Use it for a task that must outlive the teardown it participates in — e.g. a sleep/power coordinator that tears the graph down, sleeps, then wakes it — or a self-managed one-shot whose deps: exist only for start-ordering. The node owns its own shutdown; the supervisor will not drive it.

pub fn is_detached(&self) -> bool

True while this node is detached: self-managed, skipped by every runtime lifecycle operation (teardown, deactivate/activate, stop_node, respawn, pause-resume). Only the initial start brings it up.

pub fn set_task_id(&self, id: u32)

Record the executor task id (SpawnToken::id() / TaskRef::id()) currently backing this node, so the trace recorders can attribute executor polls to it. Called automatically by the spawn glue supervisor_graph! generates; call it manually only for a parked node (no spawn:) or a verbatim-closure spawn:, where the macro cannot see the token. Overwrites on every (re)spawn.

pub fn adopt<S>(&self, token: &SpawnToken<S>)

Register an externally-spawned token as this node’s live task: records the task id for the trace recorders and (feature metadata-names) stamps the node name into the task Metadata. One call replaces the manual set_task_id dance wherever the macro can’t see the token — parked nodes and verbatim-closure spawn: forms:

let t = environment_task(i2c_dev)?;
BME280.adopt(&t);
high_spawner.spawn(t);

pub fn stamp_name<S>(&self, token: &SpawnToken<S>)

Stamp this node’s name into the task’s embassy Metadata (feature metadata-names), so external consumers — rtos-trace/SystemView, debuggers — show the graph node name instead of an opaque task id. Unlike adopt this does not capture the task id or touch the supervisor’s trace recorders, so it needs neither the trace feature nor the _embassy_trace_* hook symbols: it is the name-only spawn path emitted when metadata-names is on but trace is off (pair it with embassy’s rtos-trace). Called automatically by the spawn glue; call it manually only for a parked or verbatim-closure node the macro can’t see.

Requires embassy-executor’s metadata-name feature, which metadata-names pulls in; without a registered name the task keeps embassy’s default.

pub fn task_id(&self) -> u32

The executor task id last recorded by set_task_id (0 = never spawned / not registered).

pub fn exec_ticks(&self) -> u32

Accumulated executor-poll time of this node, in embassy-time ticks. Wrapping: sample twice and wrapping_sub the readings to get a rate over a window.

pub fn poll_count(&self) -> u32

Number of executor polls of this node (wrapping counter).

pub fn max_poll_ticks(&self) -> u32

Longest single executor poll of this node ever observed, in ticks — the “never yields” watermark. A poll is expected to be microseconds; a large value names the node that hogged its executor, even after the fact.

pub fn set_disabled(&self, disabled: bool)

Set/clear the manual-deactivation flag. Set by Supervisor::deactivate, cleared by Supervisor::activate. Deliberately not touched by reset(), so a manual stop survives respawn cycles and RAM-retaining power-state transitions.

Public so an application can pre-disable a Terminate node before Supervisor::start, making it a stopped-at-boot task that only comes up on an explicit Activate control (a node started by control rather than at boot).

Trait Implementations

impl Debug for TaskNode

Manual impl: the private TaskHandle (Signals + atomics) has no Debug, and a snapshot of the live flags is more useful than raw handle internals anyway. finish_non_exhaustive marks the elided fields (spawn, the handle).

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

Formats the value using the given formatter.