Group site generation by section

crates/bds-ui/src/app/engine_handlers.rs

@@ -139,109 +139,7 @@ impl BdsApp {
                     },
                 )
             }
-            Message::GenerateSite => {
-                let locale = self.ui_locale;
-                self.spawn_engine_task(
-                    "engine.generateSiteStarted",
-                    move |db_path, project_id, data_dir, tm, tid| {
-                        let db = Database::open(&db_path).map_err(|e| e.to_string())?;
-                        let metadata = engine::meta::read_project_json(&data_dir)
-                            .map_err(|e| e.to_string())?;
-                        if metadata
-                            .public_url
-                            .as_deref()
-                            .unwrap_or("")
-                            .trim()
-                            .is_empty()
-                        {
-                            return Err(
-                                "public URL is required before generating the site".to_string()
-                            );
-                        }
-                        let main_language = metadata
-                            .main_language
-                            .clone()
-                            .unwrap_or_else(|| "en".to_string());
-                        let all_posts = bds_core::db::queries::post::list_posts_by_project(
-                            db.conn(),
-                            &project_id,
-                        )
-                        .map_err(|e| e.to_string())?;
-                        let published_posts = all_posts
-                            .into_iter()
-                            .filter(engine::generation::has_published_snapshot)
-                            .collect::<Vec<_>>();
-                        let total = published_posts.len().max(1) as f32;
-                        let mut sources = Vec::new();
-                        for (index, post) in published_posts.into_iter().enumerate() {
-                            if tm.is_cancelled(tid) {
-                                return Err("cancelled".to_string());
-                            }
-                            tm.report_progress(
-                                tid,
-                                Some(((index as f32) / total) * 0.7),
-                                Some(tw(locale, "engine.renderingPost", &[("post", &post.slug)])),
-                            );
-                            if let Some(source) =
-                                engine::generation::load_published_post_source(&data_dir, post)
-                                    .map_err(|error| error.to_string())?
-                            {
-                                sources.push(source);
-                            }
-                        }
-                        let output_dir = data_dir.join("html");
-                        std::fs::create_dir_all(&output_dir).map_err(|e| e.to_string())?;
-                        tm.report_progress(
-                            tid,
-                            Some(0.85),
-                            Some(t(locale, "engine.writingGeneratedFiles")),
-                        );
-                        let progress_start = 0.70_f32;
-                        let progress_span = 0.28_f32;
-                        let task_manager = Arc::clone(&tm);
-                        let report = engine::generation::generate_starter_site_with_progress(
-                            db.conn(),
-                            &output_dir,
-                            &project_id,
-                            &metadata,
-                            &sources,
-                            &main_language,
-                            move |current, total, path| {
-                                let fraction = if total == 0 {
-                                    1.0
-                                } else {
-                                    current as f32 / total as f32
-                                };
-                                task_manager.report_progress(
-                                    tid,
-                                    Some(progress_start + fraction * progress_span),
-                                    Some(tw(
-                                        locale,
-                                        "engine.generatedPage",
-                                        &[
-                                            ("url", path),
-                                            ("current", &current.to_string()),
-                                            ("total", &total.to_string()),
-                                        ],
-                                    )),
-                                );
-                            },
-                        )
-                        .map_err(|e| e.to_string())?;
-                        tm.report_progress(
-                            tid,
-                            Some(1.0),
-                            Some(t(locale, "engine.generationComplete")),
-                        );
-                        Ok(format!(
-                            "written={}, skipped={}, output={}",
-                            report.written_paths.len(),
-                            report.skipped_paths.len(),
-                            output_dir.display(),
-                        ))
-                    },
-                )
-            }
+            Message::GenerateSite => self.queue_site_generation(None),
             Message::RunMetadataDiff => {
                 self.open_singleton_tab(TabType::MetadataDiff, "tabBar.metadataDiff");
                 self.start_metadata_diff()
@@ -349,6 +247,125 @@ impl BdsApp {
                 self.refresh_task_snapshots();
                 sidebar_task
             }
+            Message::SiteGenerationSectionDone {
+                group_id,
+                task_id,
+                result,
+            } => {
+                if self.task_manager.status(task_id) == Some(TaskStatus::Cancelled) {
+                    self.refresh_task_snapshots();
+                    return Task::none();
+                }
+                match result {
+                    Ok(report) => {
+                        self.task_manager.complete(task_id);
+                        if let Some(workflow) = self.site_generation_workflows.get_mut(&group_id) {
+                            workflow.report.append(report);
+                        }
+                    }
+                    Err(error) => {
+                        self.task_manager.fail(task_id, error.clone());
+                        self.task_manager.cancel_group(&group_id);
+                        if let Some(workflow) = self.site_generation_workflows.remove(&group_id)
+                            && workflow.kind == SiteGenerationKind::Validation
+                        {
+                            self.site_validation_state.is_applying = false;
+                            self.site_validation_state.error_message = Some(error.clone());
+                        }
+                        let message = tw(
+                            self.ui_locale,
+                            "common.operationFailed",
+                            &[
+                                ("operation", &t(self.ui_locale, "engine.renderSiteGroup")),
+                                ("error", &error),
+                            ],
+                        );
+                        self.notify(ToastLevel::Error, &message);
+                        self.refresh_task_snapshots();
+                        return Task::none();
+                    }
+                }
+
+                let should_index =
+                    self.site_generation_workflows
+                        .get(&group_id)
+                        .is_some_and(|workflow| {
+                            workflow.index_task_id.is_none()
+                                && workflow.render_task_ids.iter().all(|task_id| {
+                                    self.task_manager.status(*task_id)
+                                        == Some(TaskStatus::Completed)
+                                })
+                        });
+                self.refresh_task_snapshots();
+                if should_index {
+                    self.queue_site_search_index(&group_id)
+                } else {
+                    Task::none()
+                }
+            }
+            Message::SiteGenerationIndexDone {
+                group_id,
+                task_id,
+                result,
+            } => {
+                if self.task_manager.status(task_id) == Some(TaskStatus::Cancelled) {
+                    self.refresh_task_snapshots();
+                    return Task::none();
+                }
+                match result {
+                    Ok(report) => {
+                        self.task_manager.complete(task_id);
+                        let Some(mut workflow) = self.site_generation_workflows.remove(&group_id)
+                        else {
+                            self.refresh_task_snapshots();
+                            return Task::none();
+                        };
+                        workflow.report.append(report);
+                        let message = tw(
+                            self.ui_locale,
+                            "engine.generationSummary",
+                            &[
+                                ("written", &workflow.report.written_paths.len().to_string()),
+                                ("skipped", &workflow.report.skipped_paths.len().to_string()),
+                                ("deleted", &workflow.report.deleted_paths.len().to_string()),
+                                (
+                                    "output",
+                                    &workflow.data_dir.join("html").display().to_string(),
+                                ),
+                            ],
+                        );
+                        self.notify(ToastLevel::Success, &message);
+                        self.refresh_task_snapshots();
+                        if workflow.kind == SiteGenerationKind::Validation {
+                            self.site_validation_state.is_applying = false;
+                            self.site_validation_state.error_message = None;
+                            self.start_site_validation()
+                        } else {
+                            Task::none()
+                        }
+                    }
+                    Err(error) => {
+                        self.task_manager.fail(task_id, error.clone());
+                        if let Some(workflow) = self.site_generation_workflows.remove(&group_id)
+                            && workflow.kind == SiteGenerationKind::Validation
+                        {
+                            self.site_validation_state.is_applying = false;
+                            self.site_validation_state.error_message = Some(error.clone());
+                        }
+                        let message = tw(
+                            self.ui_locale,
+                            "common.operationFailed",
+                            &[
+                                ("operation", &t(self.ui_locale, "engine.buildSearchIndex")),
+                                ("error", &error),
+                            ],
+                        );
+                        self.notify(ToastLevel::Error, &message);
+                        self.refresh_task_snapshots();
+                        Task::none()
+                    }
+                }
+            }
             Message::SiteValidationLoaded(result) => {
                 self.site_validation_state.is_running = false;
                 self.site_validation_state.has_run = true;
@@ -391,21 +408,6 @@ impl BdsApp {
                 }
                 Task::none()
             }
-            Message::SiteValidationApplied(result) => {
-                self.site_validation_state.is_applying = false;
-                match result {
-                    Ok(detail) => {
-                        self.site_validation_state.error_message = None;
-                        self.notify(ToastLevel::Success, &detail);
-                        self.start_site_validation()
-                    }
-                    Err(error) => {
-                        self.site_validation_state.error_message = Some(error.clone());
-                        self.notify(ToastLevel::Error, &error);
-                        Task::none()
-                    }
-                }
-            }
             _ => unreachable!("non-engine message routed to engine handler"),
         }
     }

crates/bds-ui/src/app/tasks.rs

@@ -32,6 +32,218 @@ impl BdsApp {
             })
             .collect();
     }
+
+    pub(super) fn queue_site_generation(
+        &mut self,
+        validation: Option<engine::validate_site::SiteValidationReport>,
+    ) -> Task<Message> {
+        let kind = if validation.is_some() {
+            SiteGenerationKind::Validation
+        } else {
+            SiteGenerationKind::Full
+        };
+        let (Some(project), Some(data_dir)) = (&self.active_project, &self.data_dir) else {
+            if kind == SiteGenerationKind::Validation {
+                self.site_validation_state.is_applying = false;
+            }
+            self.notify(
+                ToastLevel::Error,
+                &t(self.ui_locale, "engine.generateSiteNoProject"),
+            );
+            return Task::none();
+        };
+        let metadata = match engine::meta::read_project_json(data_dir) {
+            Ok(metadata) => metadata,
+            Err(error) => {
+                if kind == SiteGenerationKind::Validation {
+                    self.site_validation_state.is_applying = false;
+                    self.site_validation_state.error_message = Some(error.to_string());
+                }
+                self.notify(ToastLevel::Error, &error.to_string());
+                return Task::none();
+            }
+        };
+        if metadata
+            .public_url
+            .as_deref()
+            .unwrap_or("")
+            .trim()
+            .is_empty()
+        {
+            if kind == SiteGenerationKind::Validation {
+                self.site_validation_state.is_applying = false;
+            }
+            self.notify(
+                ToastLevel::Error,
+                &t(self.ui_locale, "engine.publicUrlRequired"),
+            );
+            return Task::none();
+        }
+
+        let sections = validation.as_ref().map_or_else(
+            || engine::generation::GenerationSection::ALL.to_vec(),
+            engine::generation::sections_from_validation_report,
+        );
+        if sections.is_empty() {
+            return Task::none();
+        }
+
+        let project_id = project.id.clone();
+        let db_path = self.db_path.clone();
+        let data_dir = data_dir.clone();
+        let group_id = format!("site-generation:{}", Uuid::new_v4());
+        let group_name = t(
+            self.ui_locale,
+            if kind == SiteGenerationKind::Full {
+                "engine.renderSiteGroup"
+            } else {
+                "engine.applyValidationGroup"
+            },
+        );
+        let mut render_task_ids = Vec::new();
+        let mut tasks = Vec::new();
+
+        for section in sections {
+            let label = t(self.ui_locale, generation_section_label_key(section));
+            self.add_output(&label);
+            let task_id = self
+                .task_manager
+                .submit_grouped(&label, &group_id, &group_name);
+            render_task_ids.push(task_id);
+            let task_manager = Arc::clone(&self.task_manager);
+            let task_db_path = db_path.clone();
+            let task_project_id = project_id.clone();
+            let task_data_dir = data_dir.clone();
+            let task_group_id = group_id.clone();
+            let task_validation = validation.clone();
+            let locale = self.ui_locale;
+            tasks.push(Task::perform(
+                async move {
+                    tokio::task::spawn_blocking(move || {
+                        run_site_generation_section(
+                            task_db_path,
+                            task_project_id,
+                            task_data_dir,
+                            task_manager,
+                            task_id,
+                            section,
+                            task_validation,
+                            locale,
+                        )
+                    })
+                    .await
+                    .unwrap_or_else(|error| Err(format!("task panicked: {error}")))
+                },
+                move |result| Message::SiteGenerationSectionDone {
+                    group_id: task_group_id.clone(),
+                    task_id,
+                    result,
+                },
+            ));
+        }
+
+        self.site_generation_workflows.insert(
+            group_id,
+            SiteGenerationWorkflow {
+                kind,
+                db_path,
+                project_id,
+                data_dir,
+                group_name,
+                render_task_ids,
+                index_task_id: None,
+                report: engine::generation::GenerationReport::default(),
+            },
+        );
+        self.refresh_task_snapshots();
+        Task::batch(tasks)
+    }
+
+    pub(super) fn queue_site_search_index(&mut self, group_id: &str) -> Task<Message> {
+        let Some(workflow) = self.site_generation_workflows.get(group_id).cloned() else {
+            return Task::none();
+        };
+        let label = t(self.ui_locale, "engine.buildSearchIndex");
+        self.add_output(&label);
+        let task_id = self
+            .task_manager
+            .submit_grouped(&label, group_id, &workflow.group_name);
+        if let Some(workflow) = self.site_generation_workflows.get_mut(group_id) {
+            workflow.index_task_id = Some(task_id);
+        }
+        self.refresh_task_snapshots();
+
+        let locale = self.ui_locale;
+        let task_manager = Arc::clone(&self.task_manager);
+        let task_group_id = group_id.to_string();
+        Task::perform(
+            async move {
+                tokio::task::spawn_blocking(move || {
+                    if !task_manager.wait_until_runnable(task_id) {
+                        return Err("cancelled".to_string());
+                    }
+                    let db =
+                        Database::open(&workflow.db_path).map_err(|error| error.to_string())?;
+                    let metadata = engine::meta::read_project_json(&workflow.data_dir)
+                        .map_err(|error| error.to_string())?;
+                    let output_dir = workflow.data_dir.join("html");
+                    let progress_manager = Arc::clone(&task_manager);
+                    let cancel_manager = Arc::clone(&task_manager);
+                    engine::generation::build_site_search_index_with_progress(
+                        db.conn(),
+                        &output_dir,
+                        &workflow.project_id,
+                        &metadata,
+                        move |current, total, path| {
+                            let progress = if total == 0 {
+                                1.0
+                            } else {
+                                current as f32 / total as f32
+                            };
+                            progress_manager.report_progress(
+                                task_id,
+                                Some(progress),
+                                Some(tw(
+                                    locale,
+                                    "engine.builtSearchFile",
+                                    &[
+                                        ("path", path),
+                                        ("current", &current.to_string()),
+                                        ("total", &total.to_string()),
+                                    ],
+                                )),
+                            );
+                        },
+                        move || cancel_manager.is_cancelled(task_id),
+                    )
+                    .map_err(|error| error.to_string())
+                })
+                .await
+                .unwrap_or_else(|error| Err(format!("task panicked: {error}")))
+            },
+            move |result| Message::SiteGenerationIndexDone {
+                group_id: task_group_id.clone(),
+                task_id,
+                result,
+            },
+        )
+    }
+
+    pub(super) fn cancel_site_generation_task(&mut self, task_id: TaskId) -> bool {
+        let Some(group_id) = self.task_manager.group_id(task_id) else {
+            return false;
+        };
+        let Some(workflow) = self.site_generation_workflows.remove(&group_id) else {
+            return false;
+        };
+        self.task_manager.cancel_group(&group_id);
+        if workflow.kind == SiteGenerationKind::Validation {
+            self.site_validation_state.is_applying = false;
+        }
+        self.add_output(&t(self.ui_locale, "engine.generationCancelled"));
+        self.refresh_task_snapshots();
+        true
+    }
     /// Rebuild the shared search index while the modal blocks editor writes.
     pub(super) fn start_search_index_rebuild(&mut self) -> Task<Message> {
         if self.db.is_none() || self.search_index_rebuild_running {
@@ -185,3 +397,104 @@ impl BdsApp {
         )
     }
 }
+
+fn generation_section_label_key(section: engine::generation::GenerationSection) -> &'static str {
+    match section {
+        engine::generation::GenerationSection::Core => "engine.renderSiteCore",
+        engine::generation::GenerationSection::Single => "engine.renderSinglePosts",
+        engine::generation::GenerationSection::Category => "engine.renderCategoryArchives",
+        engine::generation::GenerationSection::Tag => "engine.renderTagArchives",
+        engine::generation::GenerationSection::Date => "engine.renderDateArchives",
+    }
+}
+
+#[expect(
+    clippy::too_many_arguments,
+    reason = "task input is captured generation context"
+)]
+fn run_site_generation_section(
+    db_path: PathBuf,
+    project_id: String,
+    data_dir: PathBuf,
+    task_manager: Arc<TaskManager>,
+    task_id: TaskId,
+    section: engine::generation::GenerationSection,
+    validation: Option<engine::validate_site::SiteValidationReport>,
+    locale: UiLocale,
+) -> Result<engine::generation::GenerationReport, String> {
+    if !task_manager.wait_until_runnable(task_id) {
+        return Err("cancelled".to_string());
+    }
+    let db = Database::open(&db_path).map_err(|error| error.to_string())?;
+    let metadata = engine::meta::read_project_json(&data_dir).map_err(|error| error.to_string())?;
+    let posts = bds_core::db::queries::post::list_posts_by_project(db.conn(), &project_id)
+        .map_err(|error| error.to_string())?;
+    let mut sources = Vec::new();
+    for post in posts
+        .into_iter()
+        .filter(engine::generation::has_published_snapshot)
+    {
+        if task_manager.is_cancelled(task_id) {
+            return Err("cancelled".to_string());
+        }
+        if let Some(source) = engine::generation::load_published_post_source(&data_dir, post)
+            .map_err(|error| error.to_string())?
+        {
+            sources.push(source);
+        }
+    }
+    let output_dir = data_dir.join("html");
+    std::fs::create_dir_all(&output_dir).map_err(|error| error.to_string())?;
+    let progress_manager = Arc::clone(&task_manager);
+    let cancel_manager = Arc::clone(&task_manager);
+    let progress_key = if validation.is_some() {
+        "engine.rewrotePage"
+    } else {
+        "engine.generatedPage"
+    };
+    let on_page = move |current: usize, total: usize, url: &str| {
+        let progress = if total == 0 {
+            1.0
+        } else {
+            current as f32 / total as f32
+        };
+        progress_manager.report_progress(
+            task_id,
+            Some(progress),
+            Some(tw(
+                locale,
+                progress_key,
+                &[
+                    ("url", url),
+                    ("current", &current.to_string()),
+                    ("total", &total.to_string()),
+                ],
+            )),
+        );
+    };
+    let is_cancelled = move || cancel_manager.is_cancelled(task_id);
+    match validation {
+        Some(validation) => engine::generation::apply_validation_section_with_progress(
+            db.conn(),
+            &output_dir,
+            &project_id,
+            &metadata,
+            &sources,
+            &validation,
+            section,
+            on_page,
+            is_cancelled,
+        ),
+        None => engine::generation::render_site_section_with_progress(
+            db.conn(),
+            &output_dir,
+            &project_id,
+            &metadata,
+            &sources,
+            section,
+            on_page,
+            is_cancelled,
+        ),
+    }
+    .map_err(|error| error.to_string())
+}