Method dispatch

chirpstack/src/applayer/fuota/flow.rs:44–103

(&mut self)

    }

    async fn dispatch(&mut self) -> Result<()> {
        let resp = match self.job.job {
            FuotaJob::CreateMcGroup => self.create_mc_group().await,
            FuotaJob::AddDevsToMcGroup => self.add_devices_to_multicast_group().await,
            FuotaJob::AddGwsToMcGroup => self.add_gateways_to_multicast_group().await,
            FuotaJob::McGroupSetup => self.multicast_group_setup().await,
            FuotaJob::FragSessionSetup => self.fragmentation_session_setup().await,
            FuotaJob::McSession => self.multicast_session_setup().await,
            FuotaJob::Enqueue => self.enqueue().await,
            FuotaJob::FragStatus => self.fragmentation_status().await,
            FuotaJob::DeleteMcGroup => self.delete_mc_group().await,
            FuotaJob::Complete => self.complete().await,
        };

        match resp {
            Ok(Some((next_job, scheduler_run_after))) => {
                if self.job.job == next_job {
                    // Re-run the same job in the future.
                    let mut job = self.job.clone();
                    job.scheduler_run_after = scheduler_run_after;
                    let _ = fuota::update_job(job).await?;
                } else {
                    // Update the current job (to increment the attempt count).
                    let job = self.job.clone();
                    let _ = fuota::update_job(job).await?;

                    // Create the next job (which automatically sets the current job to completed).
                    let _ = fuota::create_job(fuota::FuotaDeploymentJob {
                        fuota_deployment_id: self.job.fuota_deployment_id,
                        job: next_job,
                        max_retry_count: match next_job {
                            FuotaJob::McGroupSetup
                            | FuotaJob::FragSessionSetup
                            | FuotaJob::McSession => self.fuota_deployment.unicast_max_retry_count,
                            _ => 0,
                        },
                        scheduler_run_after,
                        ..Default::default()
                    })
                    .await?;
                }
            }
            Ok(None) => {
                // No further jobs to execute, set the current job to completed.
                let mut job = self.job.clone();
                job.completed_at = Some(Utc::now());
                let _ = fuota::update_job(job).await?;
            }
            Err(e) => {
                // Re-run the same job in the future.
                let mut job = self.job.clone();
                job.scheduler_run_after = Utc::now() + self.scheduler_interval;
                job.error_msg = format!("Error: {}", e);
                let _ = fuota::update_job(job).await?;
                return Err(e);
            }
        }