Enum OrphanPolicy 

pub enum OrphanPolicy {
    Enforced,
    Permissive,
}

Defines the runtime’s structured concurrency policy.

This policy dictates what happens when a parent task exits before its child tasks have completed.

The default policy is OrphanPolicy::Enforced, which guarantees that children are cancelled when their parent exits. This global policy can be set to OrphanPolicy::Permissive to allow children to outlive their parents.

Note on Detached Tasks:

This policy controls the global behavior for parent-child relationships. It is separate from spawning an individually “detached” task.

The idiomatic way to spawn a task that is not attached to the current parent is to use TaskOpts::BACKGROUND_TASK. This option attaches the new task directly to the ROOT_NODE of the task tree, allowing it to outlive its spawner regardless of the OrphanPolicy.

Example

use ringolo::TaskOpts;

ringolo::spawn_builder()
    .with_opts(TaskOpts::BACKGROUND_TASK)
    .spawn(async {
        // ... background work ...
    });

Variants

Enforced

All children of a task are cancelled on exit. The program is not allowed to create orphans. This leads to better performance because we prevent many synchronous parent swapping operations and avoid child adoption by the ORPHAN_ROOT_NODE.

Permissive

Children are allowed to outlive their parents. If a parent terminates before it’s children, all of the children are adopted by the ORPHAN_ROOT_NODE and become orphans. This flexibility comes at a cost, with synchronous parent swapping operations and child adoption.

Trait Implementations

impl Clone for OrphanPolicy

fn clone(&self) -> OrphanPolicy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OrphanPolicy

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

Formats the value using the given formatter.

impl Default for OrphanPolicy

fn default() -> OrphanPolicy

Returns the “default value” for a type.

impl PartialEq for OrphanPolicy

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for OrphanPolicy

impl Eq for OrphanPolicy

impl StructuralPartialEq for OrphanPolicy