Struct ShutdownTracker 

pub struct ShutdownTracker { /* private fields */ }

Extracted TaskTracker and ShutdownToken to more easily allow tracking nested tasks without having to pass whole ShutdownManager around.

Implementations

impl ShutdownTracker

pub fn spawn<F>(&self, task: F) -> JoinHandle<<F as Future>::Output>

where F: Future + Send + 'static, <F as Future>::Output: Send + 'static,

Spawn the provided future on the current Tokio runtime, and track it in the underlying TaskTracker.

pub fn try_spawn_named<F>( &self, task: F, name: &str, ) -> JoinHandle<<F as Future>::Output>

where F: Future + Send + 'static, <F as Future>::Output: Send + 'static,

Spawn the provided future on the current Tokio runtime, and track it in the underlying TaskTracker. Furthermore, attach a name to the spawned task to more easily track it within a tokio console

Note that is no different from spawn if the underlying binary has not been built with RUSTFLAGS="--cfg tokio_unstable" and --features="tokio-tracing"

pub fn spawn_on<F>( &self, task: F, handle: &Handle, ) -> JoinHandle<<F as Future>::Output>

where F: Future + Send + 'static, <F as Future>::Output: Send + 'static,

Spawn the provided future on the provided Tokio runtime, and track it in the underlying TaskTracker.

pub fn spawn_local<F>(&self, task: F) -> JoinHandle<<F as Future>::Output>

where F: Future + 'static, <F as Future>::Output: 'static,

Spawn the provided future on the current LocalSet, and track it in the underlying TaskTracker.

pub fn spawn_blocking<F, T>(&self, task: F) -> JoinHandle<T>

where F: FnOnce() -> T + Send + 'static, T: Send + 'static,

Spawn the provided blocking task on the current Tokio runtime, and track it in the underlying TaskTracker.

pub fn spawn_blocking_on<F, T>(&self, task: F, handle: &Handle) -> JoinHandle<T>

where F: FnOnce() -> T + Send + 'static, T: Send + 'static,

Spawn the provided blocking task on the provided Tokio runtime, and track it in the underlying TaskTracker.

pub fn try_spawn_named_with_shutdown<F>( &self, task: F, name: &str, ) -> JoinHandle<Result<<F as Future>::Output, Cancelled>>

where F: Future + Send + 'static, <F as Future>::Output: Send + 'static,

Spawn the provided future on the current Tokio runtime that will get cancelled once a global shutdown signal is detected, and track it in the underlying TaskTracker.

Note that to fully use the naming feature, such as tracking within a tokio console, the underlying binary has to be built with RUSTFLAGS="--cfg tokio_unstable" and --features="tokio-tracing"

pub fn spawn_with_shutdown<F>( &self, task: F, ) -> JoinHandle<Result<<F as Future>::Output, Cancelled>>

where F: Future + Send + 'static, <F as Future>::Output: Send + 'static,

Spawn the provided future on the current Tokio runtime that will get cancelled once a global shutdown signal is detected, and track it in the underlying TaskTracker.

impl ShutdownTracker

pub fn new_from_external_shutdown_token( shutdown_token: ShutdownToken, ) -> ShutdownTracker

Create new instance of the ShutdownTracker using an external shutdown token. This could be useful in situations where shutdown is being managed by an external entity that is not ShutdownManager, but interface requires providing a ShutdownTracker, such as client-core tasks

pub async fn wait_for_tracker(&self)

Waits until the underlying TaskTracker is both closed and empty.

If the underlying TaskTracker is already closed and empty when this method is called, then it returns immediately.

pub fn close_tracker(&self) -> bool

Close the underlying TaskTracker.

This allows wait_for_tracker futures to complete. It does not prevent you from spawning new tasks.

Returns true if this closed the underlying TaskTracker, or false if it was already closed.

pub fn reopen_tracker(&self) -> bool

Reopen the underlying TaskTracker.

This prevents wait_for_tracker futures from completing even if the underlying TaskTracker is empty.

Returns true if this reopened the underlying TaskTracker, or false if it was already open.

pub fn is_tracker_closed(&self) -> bool

Returns true if the underlying TaskTracker is closed.

pub fn tracked_tasks(&self) -> usize

Returns the number of tasks tracked by the underlying TaskTracker.

pub fn is_tracker_empty(&self) -> bool

Returns true if there are no tasks in the underlying TaskTracker.

pub fn child_shutdown_token(&self) -> ShutdownToken

Obtain a ShutdownToken that is a child of the root token

pub fn clone_shutdown_token(&self) -> ShutdownToken

Obtain a ShutdownToken on the same hierarchical structure as the root token

pub fn child_tracker(&self) -> ShutdownTracker

Create a child ShutdownTracker that inherits cancellation from this tracker but has its own TaskTracker for managing sub-tasks.

This enables hierarchical task management where:

• Parent cancellation flows to all children
• Each level tracks its own tasks independently
• Components can wait for their specific sub-tasks to complete

pub async fn shutdown(self)

Convenience method to perform a complete shutdown sequence. This method:

1. Signals cancellation to all tasks
2. Closes the tracker to prevent new tasks
3. Waits for all existing tasks to complete

Trait Implementations

impl Clone for ShutdownTracker

fn clone(&self) -> ShutdownTracker

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ShutdownTracker

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

Formats the value using the given formatter.

impl Default for ShutdownTracker

fn default() -> ShutdownTracker

Returns the “default value” for a type.