Struct FlowEngineBuilder 

pub struct FlowEngineBuilder { /* private fields */ }

Builder for constructing a FlowEngine.

Register action executors with .action() / .action_fallback(), foreach item sources with .item_provider(), gate resolvers with .gate_resolver(), and environment injection with .script_env_provider().

Implementations

impl FlowEngineBuilder

pub fn new() -> Self

Examples found in repository

examples/stdout_event_sink.rs (line 49)

fn main() {
    let sink = StdoutEventSink;

    sink.emit(&EngineEventData::new(
        "run-001".into(),
        EngineEvent::RunStarted {
            workflow_name: "my-workflow".into(),
        },
    ));
    sink.emit(&EngineEventData::new(
        "run-001".into(),
        EngineEvent::RunCompleted { succeeded: true },
    ));

    // Wire it into a FlowEngine (builder shown; engine not actually run here):
    let _engine = FlowEngineBuilder::new()
        .event_sink(Box::new(StdoutEventSink))
        .build()
        .expect("engine build failed");
    println!("engine built with StdoutEventSink attached");
}

pub fn action(self, executor: Box<dyn ActionExecutor>) -> Self

Register a named executor. The executor’s name() is used as the lookup key.

pub fn action_fallback( self, executor: Box<dyn ActionExecutor>, ) -> Result<Self, EngineError>

Register the fallback (catch-all) executor.

Returns Err if called more than once — only one fallback is allowed.

pub fn item_provider<P: ItemProvider + 'static>(self, provider: P) -> Self

Register an item provider for foreach fan-outs.

pub fn gate_resolver<R: GateResolver + 'static>(self, resolver: R) -> Self

Register a gate resolver for a specific gate type.

pub fn script_env_provider(self, provider: Box<dyn ScriptEnvProvider>) -> Self

Set the script env provider. Defaults to NoOpScriptEnvProvider.

pub fn workflow_dir(self, path: impl Into<PathBuf>) -> Self

Convenience: register a DirectoryWorkflowResolver rooted at path.

FlowEngine::validate() will read <path>/<name>.wf on each call workflow node it encounters. Re-reads on every call so hot-reload is preserved.

pub fn workflow_resolver(self, resolver: Box<dyn WorkflowResolver>) -> Self

Set a custom WorkflowResolver for sub-workflow validation and cycle detection.

Overrides any previous .workflow_dir() call.

pub fn event_sink(self, sink: Box<dyn EventSink>) -> Self

Register an event sink. Multiple calls register multiple sinks; events are emitted to all sinks in registration order.

Examples found in repository

examples/stdout_event_sink.rs (line 50)

fn main() {
    let sink = StdoutEventSink;

    sink.emit(&EngineEventData::new(
        "run-001".into(),
        EngineEvent::RunStarted {
            workflow_name: "my-workflow".into(),
        },
    ));
    sink.emit(&EngineEventData::new(
        "run-001".into(),
        EngineEvent::RunCompleted { succeeded: true },
    ));

    // Wire it into a FlowEngine (builder shown; engine not actually run here):
    let _engine = FlowEngineBuilder::new()
        .event_sink(Box::new(StdoutEventSink))
        .build()
        .expect("engine build failed");
    println!("engine built with StdoutEventSink attached");
}

pub fn with_event_sinks(self, sinks: &Arc<[Arc<dyn EventSink>]>) -> Self

Register multiple event sinks from an existing Arc<[Arc<dyn EventSink>]>. Sinks are appended in slice order after any already registered.

pub fn build(self) -> Result<FlowEngine, EngineError>

Consume the builder and produce a FlowEngine.

Examples found in repository

examples/stdout_event_sink.rs (line 51)

fn main() {
    let sink = StdoutEventSink;

    sink.emit(&EngineEventData::new(
        "run-001".into(),
        EngineEvent::RunStarted {
            workflow_name: "my-workflow".into(),
        },
    ));
    sink.emit(&EngineEventData::new(
        "run-001".into(),
        EngineEvent::RunCompleted { succeeded: true },
    ));

    // Wire it into a FlowEngine (builder shown; engine not actually run here):
    let _engine = FlowEngineBuilder::new()
        .event_sink(Box::new(StdoutEventSink))
        .build()
        .expect("engine build failed");
    println!("engine built with StdoutEventSink attached");
}

Trait Implementations

impl Default for FlowEngineBuilder

fn default() -> Self

Returns the “default value” for a type.