Struct Signaler

pub struct Signaler { /* private fields */ }

Coordinates a one-time signal across many tasks.

Example

Basic Usage

use commonware_runtime::{Spawner, Runner, Signaler, deterministic};

let executor = deterministic::Runner::default();
executor.start(|context| async move {
    // Setup signaler and get future
    let (mut signaler, signal) = Signaler::new();

    // Signal shutdown
    signaler.signal(2);

    // Wait for shutdown in task
    let sig = signal.await.unwrap();
    println!("Received signal: {}", sig);
});

Advanced Usage

While Futures::Shared is efficient, there is still meaningful overhead to cloning it (i.e. in each iteration of a loop). To avoid a performance regression from introducing Signaler, it is recommended to wait on a reference to Signal (i.e. &mut signal).

use commonware_macros::select;
use commonware_runtime::{Clock, Spawner, Runner, Signaler, deterministic, Metrics};
use futures::channel::oneshot;
use std::time::Duration;

let executor = deterministic::Runner::default();
executor.start(|context| async move {
    // Setup signaler and get future
    let (mut signaler, mut signal) = Signaler::new();

    // Loop on the signal until resolved
    let (tx, rx) = oneshot::channel();
    context.with_label("waiter").spawn(|context| async move {
        loop {
            // Wait for signal or sleep
            select! {
                 sig = &mut signal => {
                     println!("Received signal: {}", sig.unwrap());
                     break;
                 },
                 _ = context.sleep(Duration::from_secs(1)) => {},
            };
        }
        let _ = tx.send(());
    });

    // Send signal
    signaler.signal(9);

    // Wait for task
    rx.await.expect("shutdown signaled");
});

Implementations

impl Signaler

pub fn new() -> (Self, Signal)

Create a new Signaler.

Returns a Signaler and a Signal that will resolve when signal is called.

pub fn signal(&mut self, value: i32)

Resolve the Signal for all waiters (if not already resolved).