Struct Engine 

pub struct Engine { /* private fields */ }

High-level engine facade for planning and execution.

use daedalus_engine::{Engine, EngineConfig};
let engine = Engine::new(EngineConfig::default()).unwrap();
let _ = engine.config();

Implementations

impl Engine

pub fn new(config: EngineConfig) -> Result<Self, EngineError>

Create a new engine from configuration.

pub fn config(&self) -> &EngineConfig

Return a reference to the engine config.

pub fn plan( &self, registry: &Registry, graph: Graph, ) -> Result<PlannerOutput, EngineError>

Run planner on the provided graph + registry.

use daedalus_engine::{Engine, EngineConfig};
use daedalus_registry::store::Registry;
use daedalus_planner::Graph;
let engine = Engine::new(EngineConfig::default()).unwrap();
let registry = Registry::new();
let _ = engine.plan(&registry, Graph::default());

pub fn build_runtime_plan( &self, plan: &ExecutionPlan, ) -> Result<RuntimePlan, EngineError>

Construct a runtime plan from a planner plan using configured policies.

use daedalus_engine::{Engine, EngineConfig};
use daedalus_planner::{ExecutionPlan, Graph};
let engine = Engine::new(EngineConfig::default()).unwrap();
let plan = ExecutionPlan::new(Graph::default(), vec![]);
let _ = engine.build_runtime_plan(&plan);

pub fn execute<H: NodeHandler + Send + Sync + 'static>( &self, runtime_plan: RuntimePlan, handler: H, ) -> Result<ExecutionTelemetry, EngineError>

Execute a runtime plan using the provided handler.

use daedalus_engine::{Engine, EngineConfig};
use daedalus_runtime::{RuntimePlan, RuntimeNode};
use daedalus_runtime::executor::NodeError;
use daedalus_planner::{ExecutionPlan, Graph};

let engine = Engine::new(EngineConfig::default()).unwrap();
let plan = RuntimePlan::from_execution(&ExecutionPlan::new(Graph::default(), vec![]));
let handler = |_node: &RuntimeNode,
              _ctx: &daedalus_runtime::state::ExecutionContext,
              _io: &mut daedalus_runtime::io::NodeIo|
       -> Result<(), NodeError> { Ok(()) };
let _ = engine.execute(plan, handler);

pub fn execute_with_host<H: NodeHandler + Send + Sync + 'static>( &self, runtime_plan: RuntimePlan, host: HostBridgeManager, handler: H, ) -> Result<ExecutionTelemetry, EngineError>

Execute a runtime plan with host bridge support.

use daedalus_engine::{Engine, EngineConfig};
use daedalus_runtime::{HostBridgeManager, RuntimePlan, RuntimeNode};
use daedalus_runtime::executor::NodeError;
use daedalus_planner::{ExecutionPlan, Graph};

let engine = Engine::new(EngineConfig::default()).unwrap();
let plan = RuntimePlan::from_execution(&ExecutionPlan::new(Graph::default(), vec![]));
let host = HostBridgeManager::new();
let handler = |_node: &RuntimeNode,
              _ctx: &daedalus_runtime::state::ExecutionContext,
              _io: &mut daedalus_runtime::io::NodeIo|
       -> Result<(), NodeError> { Ok(()) };
let _ = engine.execute_with_host(plan, host, handler);

pub fn run<H: NodeHandler + Send + Sync + 'static>( &self, registry: &Registry, graph: Graph, handler: H, ) -> Result<RunResult, EngineError>

Full run: load registry (if not provided), plan, and execute.

use daedalus_engine::{Engine, EngineConfig};
use daedalus_registry::store::Registry;
use daedalus_planner::Graph;
use daedalus_runtime::executor::NodeError;

let engine = Engine::new(EngineConfig::default()).unwrap();
let registry = Registry::new();
let handler = |_node: &daedalus_runtime::RuntimeNode,
              _ctx: &daedalus_runtime::state::ExecutionContext,
              _io: &mut daedalus_runtime::io::NodeIo|
       -> Result<(), NodeError> { Ok(()) };
let _ = engine.run(&registry, Graph::default(), handler);