Method deploy_environment

lib-engine/src/environment/task.rs:308–399

(
        mut environment: Environment,
        infra_ctx: &InfrastructureContext,
        abort: &dyn Abort,
    )

    }

    pub fn deploy_environment(
        mut environment: Environment,
        infra_ctx: &InfrastructureContext,
        abort: &dyn Abort,
    ) -> Result<(), Box<EngineError>> {
        let mut deployed_services: HashSet<Uuid> = HashSet::new();
        let event_details = environment.event_details().clone();
        let run_deploy = || -> Result<(), Box<EngineError>> {
            // Build apps
            if abort.status().should_cancel() {
                return Err(Box::new(EngineError::new_task_cancellation_requested(event_details)));
            }

            let logger = Arc::new(infra_ctx.kubernetes().logger().clone_dyn());

            // INFO (qov-1569) Trigger external secrets deployments only for a Create environment action
            // Note: it doesn't mean that the underlying services are in Deploy state, but it prevents from
            //       deploying external secrets on Pause / Restart / Delete env actions.
            if environment.action == service::Action::Create {
                handle_service_external_secrets(&mut environment, infra_ctx, abort)?;
            }

            let services_to_build: Vec<&mut dyn Service> = environment
                .applications
                .iter_mut()
                .map(|app| app.as_service_mut())
                .chain(environment.jobs.iter_mut().map(|job| job.as_service_mut()))
                .chain(
                    environment
                        .terraform_services
                        .iter_mut()
                        .map(|terraform_service| terraform_service.as_service_mut()),
                )
                .collect();
            Self::build_and_push_services(
                environment.long_id,
                environment.project_long_id,
                services_to_build,
                &DeploymentOption {
                    force_build: false,
                    force_push: false,
                },
                infra_ctx,
                environment.max_parallel_build as usize,
                |srv: &dyn Service| EnvLogger::new(srv, EnvironmentStep::Build, logger.clone()),
                abort,
            )?;

            if abort.status().should_cancel() {
                return Err(Box::new(EngineError::new_task_cancellation_requested(event_details)));
            }
            let mut env_deployment = EnvironmentDeployment::new(infra_ctx, &environment, abort, logger.clone())?;
            let deployment_ret = match environment.action {
                service::Action::Create => env_deployment.on_create(),
                service::Action::Pause => env_deployment.on_pause(),
                service::Action::Delete => env_deployment.on_delete(),
                service::Action::Restart => env_deployment.on_restart(),
            };