Struct Context 

pub struct Context { /* private fields */ }

A daemon plugin’s handle to the host, its configuration and its executor. Cheap to clone.

Implementations

impl Context

pub fn config<T: DeserializeOwned>(&self) -> Result<T>

The configuration, deserialized (an empty document is null).

pub fn config_json(&self) -> Json

pub fn values(&self) -> Values

Examples found in repository

examples/together_companion.rs (line 36)

fn publish(cx: &Context, state: &str, builds: u32) {
    let _ = cx
        .values()
        .set("together.status", &Status { state, builds });
    let _ = cx.events().emit("together.changed", &(), Target::Viewers);
}

pub fn live(&self) -> Live

Examples found in repository

examples/heartbeat_daemon.rs (line 48)

    async fn run(&self, cx: Context) {
        let _ = cx.events().on("heartbeat.ping");
        // Answer pings beside the heartbeat loop.
        let events = cx.clone();
        cx.spawn(async move {
            loop {
                if let Event::Plugin { name, .. } = events.next_event().await
                    && name == "heartbeat.ping"
                {
                    let _ = events.events().emit("heartbeat.pong", &(), Target::All);
                }
            }
        });
        loop {
            self.beats.set(self.beats.get() + 1);
            let _ = cx.live().publish("heartbeat.beat", &self.beats.get());
            cx.sleep(30_000).await;
        }
    }

pub fn events(&self) -> Events

Examples found in repository

examples/together_companion.rs (line 38)

fn publish(cx: &Context, state: &str, builds: u32) {
    let _ = cx
        .values()
        .set("together.status", &Status { state, builds });
    let _ = cx.events().emit("together.changed", &(), Target::Viewers);
}

examples/heartbeat_daemon.rs (line 34)

    async fn run(&self, cx: Context) {
        let _ = cx.events().on("heartbeat.ping");
        // Answer pings beside the heartbeat loop.
        let events = cx.clone();
        cx.spawn(async move {
            loop {
                if let Event::Plugin { name, .. } = events.next_event().await
                    && name == "heartbeat.ping"
                {
                    let _ = events.events().emit("heartbeat.pong", &(), Target::All);
                }
            }
        });
        loop {
            self.beats.set(self.beats.get() + 1);
            let _ = cx.live().publish("heartbeat.beat", &self.beats.get());
            cx.sleep(30_000).await;
        }
    }

pub fn claims(&self) -> Claims

Exactly-once effects across the daemons that run a fleet plugin (a singleton’s claims carry its lease epoch). No grant.

pub fn calls(&self) -> Calls

pub fn now_ms(&self) -> u64

The daemon’s monotonic clock as of the current drive call.

pub fn next_event(&self) -> NextEvent

The next event the host delivers (values, live messages, plugin events, account changes). Events queue while nothing awaits them, up to EVENT_QUEUE; past that the oldest are dropped.

Examples found in repository

examples/heartbeat_daemon.rs (line 39)

    async fn run(&self, cx: Context) {
        let _ = cx.events().on("heartbeat.ping");
        // Answer pings beside the heartbeat loop.
        let events = cx.clone();
        cx.spawn(async move {
            loop {
                if let Event::Plugin { name, .. } = events.next_event().await
                    && name == "heartbeat.ping"
                {
                    let _ = events.events().emit("heartbeat.pong", &(), Target::All);
                }
            }
        });
        loop {
            self.beats.set(self.beats.get() + 1);
            let _ = cx.live().publish("heartbeat.beat", &self.beats.get());
            cx.sleep(30_000).await;
        }
    }

pub fn interest(&self) -> Interest

Which of the plugin’s UI surfaces some viewer shows now (Interest). Changes arrive as Event::Interest.

pub fn next_event_until(&self, at_ms: Option<u64>) -> NextEventUntil

The next event, or None once the daemon’s clock reaches at_ms (never, with None): the one wait a loop that reads on a schedule and reacts to events needs. The timer goes with it, so an event that arrives first leaves no wake behind.

pub fn sleep(&self, ms: u64) -> Sleep

Completes ms milliseconds from now.

Examples found in repository

examples/heartbeat_daemon.rs (line 49)

    async fn run(&self, cx: Context) {
        let _ = cx.events().on("heartbeat.ping");
        // Answer pings beside the heartbeat loop.
        let events = cx.clone();
        cx.spawn(async move {
            loop {
                if let Event::Plugin { name, .. } = events.next_event().await
                    && name == "heartbeat.ping"
                {
                    let _ = events.events().emit("heartbeat.pong", &(), Target::All);
                }
            }
        });
        loop {
            self.beats.set(self.beats.get() + 1);
            let _ = cx.live().publish("heartbeat.beat", &self.beats.get());
            cx.sleep(30_000).await;
        }
    }

pub fn sleep_until(&self, at_ms: u64) -> Sleep

Completes at at_ms on the daemon’s clock.

pub fn spawn(&self, task: impl Future<Output = ()> + 'static)

Runs task beside the run loop until it completes or the plugin is deactivated.

Examples found in repository

examples/together_companion.rs (lines 78-82)

    fn call(&self, method: &str, _request: Json, cx: &Context) -> Result<Json, Error> {
        match method {
            "rebuild" => {
                let started = !self.running.replace(true);
                if started {
                    cx.spawn(rebuild(
                        cx.clone(),
                        self.builds.clone(),
                        self.running.clone(),
                    ));
                }
                Json::from_value(&started)
            }
            other => Err(Error::Invalid(format!("unknown method {other}"))),
        }
    }

examples/heartbeat_daemon.rs (lines 37-45)

    async fn run(&self, cx: Context) {
        let _ = cx.events().on("heartbeat.ping");
        // Answer pings beside the heartbeat loop.
        let events = cx.clone();
        cx.spawn(async move {
            loop {
                if let Event::Plugin { name, .. } = events.next_event().await
                    && name == "heartbeat.ping"
                {
                    let _ = events.events().emit("heartbeat.pong", &(), Target::All);
                }
            }
        });
        loop {
            self.beats.set(self.beats.get() + 1);
            let _ = cx.live().publish("heartbeat.beat", &self.beats.get());
            cx.sleep(30_000).await;
        }
    }

pub fn caller(&self) -> Option<Caller>

Who made the call being answered, inside DaemonPlugin::call; None elsewhere.

pub fn machine_id(&self) -> String

The machine this daemon runs on, by the account’s machine id: the id a UI plugin targets with Target::Machine and finds in account::state.

pub fn account_id(&self) -> Option<String>

The account this daemon is enrolled in, once the daemon has read it.

pub fn lease_epoch(&self) -> Option<u64>

The lease epoch a singleton runs under (every write of its account session carries it); None for a fleet plugin. A plugin that records who did something (a claim, a value) can tag it with its epoch.

pub fn release(&self) -> Option<Release>

The Standard Code build this daemon runs: its channel (branch:<name>, team, …), version and commit. None where it is not known.

Trait Implementations

impl Clone for Context

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Context

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

Formats the value using the given formatter.

impl Default for Context

fn default() -> Self

Returns the “default value” for a type.