Method run

app/src/deployment_manager/mod.rs:165–211

(mut self)

    }

    pub async fn run(mut self) {
        const SPAN_NAME: &str = "deploymnt_mngr";
        let mut state = DeploymentManagerState::SeekingNewDeployment {};
        let mut delay = None;
        let mut span = span!(Level::INFO, SPAN_NAME, execution_id = field::Empty);
        let mut run_once_started_deployment = false;

        while state.does_execute_deployment() || !self.should_shutdown.load(Ordering::Relaxed) {
            if let Some(delay) = delay {
                tokio::time::sleep(delay).await;
            }

            let (new_state, new_delay, run_outcome) = self.run_exec_state(state).instrument(span.clone()).await;
            let should_stop_run_once = self.run_mode == DeploymentManagerRunMode::RunOnce
                && (run_outcome == DeploymentManagerRunOutcome::NoDeploymentAvailable
                    || (run_once_started_deployment
                        && matches!(new_state, DeploymentManagerState::SeekingNewDeployment {})));
            run_once_started_deployment |= matches!(
                new_state,
                DeploymentManagerState::ExecutingDeployment { .. }
                    | DeploymentManagerState::ExecutingDeploymentTask { .. }
                    | DeploymentManagerState::ResumingDeploymentTask { .. }
            );

            state = new_state;
            delay = new_delay;

            // Add some Hook on transition change for metrics and tracing
            match &state {
                DeploymentManagerState::SeekingNewDeployment { .. } => {
                    METRICS_NB_RUNNING_TASKS.set(0);
                    span = span!(Level::INFO, SPAN_NAME, execution_id = field::Empty);
                }
                DeploymentManagerState::ExecutingDeployment { deployment, .. } => {
                    METRICS_NB_RUNNING_TASKS.set(1);
                    span = span!(Level::INFO, SPAN_NAME, execution_id = deployment.deployment_info.execution_id);
                }
                DeploymentManagerState::ExecutingDeploymentTask { .. } => {}
                DeploymentManagerState::ResumingDeploymentTask { .. } => {}
            }

            if should_stop_run_once {
                info!("RUN_ONCE mode completed, stopping deployment manager");
                break;
            }
        }
    }

    async fn run_exec_state(
        &mut self,