Method execute

crates/consensus/engine/src/task_queue/tasks/task.rs:185–227

(&self, state: &mut EngineState)

    type Error = EngineTaskErrors;

    async fn execute(&self, state: &mut EngineState) -> Result<(), Self::Error> {
        // Wall-clock duration of the entire retry loop (not per attempt), so the
        // difference against `engine_method_request_duration{method}` isolates pure
        // CL retry/yield overhead. Records on drop regardless of outcome
        // (success / critical / reset / flush).
        let label = self.task_metrics_label();
        let _task_timer = base_metrics::timed!(Metrics::engine_task_duration(label));

        // Retry the task until it succeeds or a critical error occurs.
        while let Err(e) = self.execute_inner(state).await {
            let severity = e.severity();

            Metrics::engine_task_failure(self.task_metrics_label(), severity.as_label())
                .increment(1);

            match severity {
                EngineTaskErrorSeverity::Temporary => {
                    trace!(target: "engine", error = %e, "Temporary engine error");

                    // Yield the task to allow other tasks to execute to avoid starvation.
                    yield_now().await;

                    continue;
                }
                EngineTaskErrorSeverity::Critical => {
                    error!(target: "engine", error = %e, "Critical engine error");
                    return Err(e);
                }
                EngineTaskErrorSeverity::Reset => {
                    warn!(target: "engine", "Engine requested derivation reset");
                    return Err(e);
                }
                EngineTaskErrorSeverity::Flush => {
                    warn!(target: "engine", "Engine requested derivation flush");
                    return Err(e);
                }
            }
        }

        Metrics::engine_task_count(self.task_metrics_label()).increment(1);

        Ok(())
    }
}