Function execute_long_deployment

lib-engine/src/environment/report/mod.rs:175–251

Function that take a deployment reporter and a deployment task and execute/synchronize them together The reporter is going to be executed in a separate thread and the task in the current thread. Reporter will not be executed while the task is running the pre_run and post_run_success methods. Only during the run method

(
    mut deployment_reporter: impl DeploymentReporter<DeploymentResult = TaskRet, Logger = Log>,
    mut long_task: impl DeploymentTask<Logger = Log, DeploymentResult = TaskRet>,
)

// Reporter will not be executed while the task is running the pre_run and post_run_success methods.
// Only during the run method
pub fn execute_long_deployment<Log, TaskRet>(
    mut deployment_reporter: impl DeploymentReporter<DeploymentResult = TaskRet, Logger = Log>,
    mut long_task: impl DeploymentTask<Logger = Log, DeploymentResult = TaskRet>,
) -> Result<(), Box<EngineError>> {
    // stop the thread when the blocking task is done
    let (tx, rx) = mpsc::channel();
    let deployment_start = Arc::new(Barrier::new(2));
    let mut state = deployment_reporter.new_state();

    let logger = deployment_reporter.logger();

    // 1. Execute pre_run and if it succeed, start the reporter thread
    let deployment_result = match long_task.pre_run(logger) {
        Err(err) => Err(err),
        Ok(prerun_result) => {
            // 2. Start the reporter thread in background
            thread::scope(|th_scope| {
                // monitor thread to notify user while the blocking task is executed
                let thread_name = format!("reporter-of-{}", thread::current().name().unwrap_or("unknown-thread"));
                let th_handle = thread::Builder::new().name(thread_name).spawn_scoped(th_scope, {
                    // Propagate the current span into the thread. This span is only used by tests
                    let current_span = tracing::Span::current();
                    let deployment_start = deployment_start.clone();
                    let deployment_reporter = &deployment_reporter; // to avoid moving the object into the thread
                    let state = &mut state;

                    move || {
                        let _span = current_span.enter();

                        // Before the launch of the deployment
                        deployment_reporter.deployment_before_start(state);

                        // Wait the start of the deployment
                        deployment_start.wait();

                        // Send deployment progress report every x secs
                        let report_frequency = deployment_reporter.report_frequency();
                        loop {
                            match rx.recv_timeout(report_frequency) {
                                // Deployment is terminated, we received the result of the task
                                Ok(_) => break,

                                // Deployment is still in progress
                                Err(RecvTimeoutError::Timeout) => deployment_reporter.deployment_in_progress(state),

                                // Other side died without passing us the result ! this is a logical bug !
                                Err(RecvTimeoutError::Disconnected) => {
                                    panic!(
                                        "Haven't received task deployment result, but otherside of the channel is dead !"
                                    );
                                }
                            }
                        }
                    }
                });

                // Wait for our watcher thread to be ready before starting
                let _ = deployment_start.wait();