Lógica del ciclo de vida

AQE expone un trait por cada fase del ciclo de vida:

aq-engine/src/core/lifecycle/mod.rs

pub trait OnStartLogic {
    fn version(&self) -> &str;
    fn run(&mut self, ctx: &mut dyn StrategyContext) -> LifecycleResult;
}

pub trait OnInitLogic {
    fn version(&self) -> &str;
    fn run(&mut self, ctx: &mut dyn StrategyContext, asset: &Asset) -> LifecycleResult;
}

pub trait OnTeardownLogic {
    fn version(&self) -> &str;
    fn run(&mut self, ctx: &mut dyn StrategyContext) -> LifecycleResult;
}

Cada método run devuelve LifecycleResult, que registra si la operación se completó correctamente, un mensaje opcional y los metadatos del componente. Si un componente falla con can_fail(false), detiene la ejecución; si falla con can_fail(true), registra el fallo y permite continuar.

Política de fallos predeterminada:

• OnStartLogic: estricta por defecto
• OnInitLogic: estricta por defecto
• OnTeardownLogic: tolerante por defecto, porque la limpieza debe continuar siempre que sea posible

Momento de ejecución

Los envoltorios del ciclo de vida usan LifecycleTiming para elegir dónde ejecutarse con respecto al cuerpo del método de estrategia:

LifecycleTiming::BeforeGenerated
LifecycleTiming::AfterGenerated

En los proyectos generados por AQS, «generado» se refiere al cuerpo del método generado a partir del grafo. En proyectos de AQE escritos a mano, se refiere al cuerpo que has escrito directamente en la implementación de Strategy.

Usa BeforeGenerated para validación, configuración del entorno, inicialización del estado y dependencias que espera el cuerpo de la estrategia. Usa AfterGenerated para tareas posteriores, comprobaciones de registro y metadatos que dependan de que el cuerpo de la estrategia ya se haya ejecutado.

Registrar lógica del ciclo de vida

Los proyectos que usan AQE directamente registran la lógica del ciclo de vida en StrategyState antes de iniciar la ejecución. El motor llama a los componentes automáticamente; tu código de estrategia no debe llamar manualmente a las funciones auxiliares de ejecución del ciclo de vida.

state.add_on_start_logic(
    OnStartLogicBuilder::new(Box::new(SeedRuntimeState::new()))
        .timing(LifecycleTiming::BeforeGenerated)
        .can_fail(false)
        .build(),
);

state.add_on_init_logic(
    OnInitLogicBuilder::new(Box::new(InitAssetState::new()))
        .timing(LifecycleTiming::AfterGenerated)
        .can_fail(false)
        .build(),
);

state.add_on_teardown_logic(
    OnTeardownLogicBuilder::new(Box::new(FlushRuntimeLogs::new()))
        .timing(LifecycleTiming::AfterGenerated)
        .can_fail(true)
        .build(),
);

Ejemplo de componente de arranque

use aq_engine::core::lifecycle::{LifecycleResult, OnStartLogic};
use aq_engine::core::strategy::StrategyContext;
use serde_json::json;

pub struct SeedRuntimeState;

impl SeedRuntimeState {
    pub fn new() -> Self {
        Self
    }
}

impl OnStartLogic for SeedRuntimeState {
    fn version(&self) -> &str {
        "1.0"
    }

    fn run(&mut self, ctx: &mut dyn StrategyContext) -> LifecycleResult {
        ctx.variables().insert(
            self.name().to_string(),
            json!({
                "started": true,
                "symbols_seen": 0
            }),
        );

        LifecycleResult::passed(self.name().to_string())
    }
}