Struct ProtectedRunner 

pub struct ProtectedRunner<S: CheckpointStore> { /* private fields */ }

Protected Runner

Wraps a Runner with input processor pipeline and optional protected emitter. Input is validated/transformed BEFORE execution begins.

Usage

use enact_core::runner::{ProtectedRunner, DefaultRunner};
use enact_core::policy::{PiiInputProcessor, PiiInputMode};

let runner = DefaultRunner::default_new();
let protected = ProtectedRunner::new(runner)
    .with_input_processor(Arc::new(
        PiiInputProcessor::new().with_mode(PiiInputMode::BlockDirect)
    ));

// Input will be validated before callable runs
let result = protected.run_callable(&my_callable, "user input").await;

Implementations

impl<S: CheckpointStore> ProtectedRunner<S>

pub fn new(runner: Runner<S>) -> Self

Create a new protected runner wrapping an existing runner

pub fn with_input_processor(self, processor: Arc<dyn InputProcessor>) -> Self

Add an input processor to the pipeline

pub fn with_protected_emitter(self, emitter: ProtectedEventEmitter) -> Self

Set a protected emitter for output processing

pub fn execution_id(&self) -> &ExecutionId

Get the execution ID

pub fn emitter(&self) -> &EventEmitter

Get the event emitter (from inner runner)

pub fn cancel(&self)

Cancel the run

pub fn is_cancelled(&self) -> bool

Check if cancelled

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

Pause the run

pub fn resume(&self)

Resume the run

pub fn is_paused(&self) -> bool

Check if paused

pub async fn run_callable<A: Callable>( &mut self, callable: &A, input: &str, ) -> Result<String>

Run a callable with input validation

pub async fn run_graph( &mut self, graph: &CompiledGraph, input: &str, ) -> Result<NodeState>

Run a graph with input validation

impl ProtectedRunner<InMemoryCheckpointStore>

pub fn default_new() -> Self

Create a new protected runner with in-memory checkpoint store