Struct WorkerRuntime

pub struct WorkerRuntime { /* private fields */ }

A runtime for worker nodes.

This runtime provides functionality for the three responsibilities of a worker process.

1. Listen for new Tasks.
2. Execute those Tasks.
3. Send back the results of a Task execution.

Implementations

impl WorkerRuntime

pub async fn from_config(config: &Config, marker: Marker) -> Result<Self>

Initializes the WorkerRuntime with the provided Config.

pub async fn get_result_sender( &self, identifier: String, ) -> Result<Box<dyn Publisher<AnyTaskResult> + Send + Unpin + Sync + '_>>

Provides a Publisher for dispatching AnyTaskResults.

Typically used by a worker node for send back the results of a Task execution.

pub async fn get_ipc_sender( &self, ) -> Result<Box<dyn Publisher<WorkerIpc> + Send + Unpin + Sync + '_>>

Get a Publisher for dispatching WorkerIpc messages.

Typically used by a worker node to notify other workers of a fatal error.

pub async fn get_ipc_receiver(&self) -> Result<BoxStream<'static, WorkerIpc>>

Get a Stream for receiving WorkerIpc messages.

Typically used by a worker node to listen for fatal errors from other workers.

pub async fn get_task_receiver( &self, ) -> Result<Box<dyn Stream<Item = (AnyTask, Box<dyn Acker>)> + Send + Unpin + '_>>

Provides a Stream incoming AnyTasks.

Typically the the worker node’s first interaction with the Runtime. This is how workers receive Tasks for remote execution.

Example

use clap::Parser;
use paladin::{
    RemoteExecute,
    config::Config,
    registry,
    runtime::WorkerRuntime,
    operation::{Operation, Result},
};
use serde::{Deserialize, Serialize};
use futures::StreamExt;

#[derive(Parser, Debug)]
pub struct Cli {
    #[command(flatten)]
    pub options: Config,
}

paladin::registry!();

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let args = Cli::parse();
    let runtime = WorkerRuntime::from_config(&args.options, register()).await?;

    let mut task_stream = runtime.get_task_receiver().await?;
    while let Some((task, delivery)) = task_stream.next().await {
        // ... handle task
    }
}

pub async fn dispatch_fatal<E>(&self, __arg1: ExecutionErr<E>) -> Result<()>

where E: Display + Debug,

Notify the Runtime of a fatal error.

This will pass the error back to the consumer of the Task and notify other workers of the error.

pub async fn dispatch_ok<'a>(&self, __arg1: ExecutionOk) -> Result<()>

Notify the Runtime of a successful execution.

This will pass the output back to the consumer of the Task and ack the message.

pub async fn main_loop(&self) -> Result<()>

A default worker loop that can be used to process Tasks.

Worker implementations generally wont vary, as the their primary responsibility is to process incoming tasks. We provide one out of the box that will work for most use cases. Users are free to implement their own if they need to.

Note that if you define your operations in a separate crate, you’ll need to use the registry! macro to register them with the runtime.

Example

use paladin::{
    RemoteExecute,
    runtime::WorkerRuntime,
    config::Config,
    task::Task,
    operation::{Result, Operation},
    registry,
};
use clap::Parser;
use serde::{Deserialize, Serialize};

#[derive(Parser, Debug)]
pub struct Cli {
    #[command(flatten)]
    pub options: Config,
}

registry!();

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let args = Cli::parse();
    let runtime = WorkerRuntime::from_config(&args.options, register()).await?;
    runtime.main_loop().await?;

    Ok(())
}

Trait Implementations

impl Clone for WorkerRuntime

fn clone(&self) -> WorkerRuntime

Returns a duplicate of the value.

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

Performs copy-assignment from source.