hugo/RuDS
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

Group site generation by section

Browse Source
This commit is contained in:
Chili Palmer
2026-07-19 10:27:12 +02:00
parent 055dd5efc5
commit 90a9002124
19 changed files with 1467 additions and 399 deletions
Download Patch File Download Diff File Expand all files Collapse all files

265
crates/bds-ui/src/app.rs
View File

@@ -201,8 +201,17 @@ pub enum Message {
label: String,
result: Result<String, String>,
},
SiteGenerationSectionDone {
group_id: String,
task_id: TaskId,
result: Result<engine::generation::GenerationReport, String>,
},
SiteGenerationIndexDone {
group_id: String,
task_id: TaskId,
result: Result<engine::generation::GenerationReport, String>,
},
SiteValidationLoaded(Result<engine::validate_site::SiteValidationReport, String>),
SiteValidationApplied(Result<String, String>),
// Editor views
PostEditor(PostEditorMsg),
@@ -242,6 +251,24 @@ pub enum Message {
InitMenuBar,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum SiteGenerationKind {
Full,
Validation,
}
#[derive(Debug, Clone)]
struct SiteGenerationWorkflow {
kind: SiteGenerationKind,
db_path: PathBuf,
project_id: String,
data_dir: PathBuf,
group_name: String,
render_task_ids: Vec<TaskId>,
index_task_id: Option<TaskId>,
report: engine::generation::GenerationReport,
}
enum PersistedPostState {
Canonical(Box<Post>),
Translation(Box<bds_core::model::PostTranslation>),
@@ -754,6 +781,7 @@ pub struct BdsApp {
search_index_rebuild_required: bool,
search_index_rebuild_running: bool,
search_index_rebuild_task_id: Option<TaskId>,
site_generation_workflows: HashMap<String, SiteGenerationWorkflow>,
// Platform
_menu_bar: Option<muda::Menu>,
@@ -908,6 +936,7 @@ impl BdsApp {
search_index_rebuild_required,
search_index_rebuild_running: false,
search_index_rebuild_task_id: None,
site_generation_workflows: HashMap::new(),
_menu_bar: Some(menu_bar),
menu_registry: registry,
ui_locale: locale,
@@ -974,6 +1003,7 @@ impl BdsApp {
search_index_rebuild_required: false,
search_index_rebuild_running: false,
search_index_rebuild_task_id: None,
site_generation_workflows: HashMap::new(),
_menu_bar: None,
menu_registry: MenuRegistry::empty(),
ui_locale: UiLocale::En,
@@ -1610,6 +1640,9 @@ impl BdsApp {
)
}
Message::CancelTask(task_id) => {
if self.cancel_site_generation_task(task_id) {
return Task::none();
}
self.task_manager.cancel(task_id);
self.refresh_task_snapshots();
Task::none()
@@ -1831,8 +1864,9 @@ impl BdsApp {
| Message::RunSiteValidation
| Message::ApplySiteValidation
| Message::EngineTaskDone { .. }
| Message::SiteValidationLoaded(_)
| Message::SiteValidationApplied(_)) => self.handle_engine_message(message),
| Message::SiteGenerationSectionDone { .. }
| Message::SiteGenerationIndexDone { .. }
| Message::SiteValidationLoaded(_)) => self.handle_engine_message(message),
// ── Toasts ──
Message::ShowToast(level, msg) => {
@@ -2660,68 +2694,9 @@ impl BdsApp {
return Task::none();
}
let Some(project_id) = self
.active_project
.as_ref()
.map(|project| project.id.clone())
else {
self.site_validation_state.error_message =
Some(t(self.ui_locale, "engine.generateSiteNoProject"));
return Task::none();
};
let Some(data_dir) = self.data_dir.clone() else {
self.site_validation_state.error_message =
Some(t(self.ui_locale, "engine.previewDataDirUnavailable"));
return Task::none();
};
self.site_validation_state.is_applying = true;
self.site_validation_state.error_message = None;
let db_path = self.db_path.clone();
let applied_label = t(self.ui_locale, "siteValidation.apply");
Task::perform(
async move {
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 all_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 all_posts
.into_iter()
.filter(engine::generation::has_published_snapshot)
{
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 apply_report = engine::generation::apply_validation_sections(
db.conn(),
&output_dir,
&project_id,
&metadata,
&sources,
&sections,
)
.map_err(|error| error.to_string())?;
Ok(format!(
"{}: written={}, skipped={}, deleted={}, output={}",
applied_label,
apply_report.written_paths.len(),
apply_report.skipped_paths.len(),
apply_report.deleted_paths.len(),
output_dir.display(),
))
},
Message::SiteValidationApplied,
)
self.queue_site_generation(Some(report))
}
fn refresh_counts(&mut self) -> Task<Message> {
@@ -6236,6 +6211,8 @@ mod tests {
use bds_core::db::Database;
use bds_core::db::fts::ensure_fts_tables;
use bds_core::db::queries::project::insert_project;
use bds_core::engine::generation::GenerationReport;
use bds_core::engine::task::{TaskStatus, TaskStatus::*};
use bds_core::engine::{ai, media, post, script, template};
use bds_core::model::{Project, ScriptKind, TemplateKind};
use chrono::{Datelike, TimeZone};
@@ -6317,6 +6294,12 @@ mod tests {
BdsApp::new_for_tests(db, project, tmp.path().to_path_buf())
}
fn enable_generation(tmp: &TempDir) {
let mut metadata = bds_core::engine::meta::read_project_json(tmp.path()).unwrap();
metadata.public_url = Some("https://example.com".to_string());
bds_core::engine::meta::write_project_json(tmp.path(), &metadata).unwrap();
}
fn open_post_editor(app: &mut BdsApp, post: &bds_core::model::Post) {
let tab = crate::state::tabs::Tab {
id: post.id.clone(),
@@ -6462,6 +6445,162 @@ mod tests {
));
}
#[test]
fn full_generation_queues_five_ordered_section_tasks_before_indexing() {
let (db, project, tmp) = setup();
enable_generation(&tmp);
let mut app = make_app(db, project, &tmp);
let _task = app.queue_site_generation(None);
let snapshots = app.task_manager.snapshots();
assert_eq!(
snapshots
.iter()
.map(|task| task.label.as_str())
.collect::<Vec<_>>(),
vec![
"Render Site Core",
"Render Single Posts",
"Render Category Archives",
"Render Tag Archives",
"Render Date Archives",
]
);
assert!(
snapshots
.iter()
.all(|task| task.group_name.as_deref() == Some("Render Site"))
);
assert_eq!(
snapshots
.iter()
.map(|task| task.status.clone())
.collect::<Vec<_>>(),
vec![Running, Running, Running, Pending, Pending]
);
}
#[test]
fn search_index_is_queued_only_after_every_render_task_succeeds() {
let (db, project, tmp) = setup();
enable_generation(&tmp);
let mut app = make_app(db, project, &tmp);
let _task = app.queue_site_generation(None);
let group_id = app.task_manager.snapshots()[0].group_id.clone().unwrap();
let render_ids = app.site_generation_workflows[&group_id]
.render_task_ids
.clone();
for (index, task_id) in render_ids.into_iter().enumerate() {
let _task = app.handle_engine_message(Message::SiteGenerationSectionDone {
group_id: group_id.clone(),
task_id,
result: Ok(GenerationReport::default()),
});
let has_index = app
.task_manager
.snapshots()
.iter()
.any(|task| task.label == "Build Search Index");
assert_eq!(has_index, index == 4);
}
}
#[test]
fn failed_render_cancels_its_group_and_never_queues_index() {
let (db, project, tmp) = setup();
enable_generation(&tmp);
let mut app = make_app(db, project, &tmp);
let _task = app.queue_site_generation(None);
let snapshots = app.task_manager.snapshots();
let group_id = snapshots[0].group_id.clone().unwrap();
let first_id = snapshots[0].id;
let _task = app.handle_engine_message(Message::SiteGenerationSectionDone {
group_id: group_id.clone(),
task_id: first_id,
result: Err("render failed".to_string()),
});
let snapshots = app.task_manager.snapshots();
assert_eq!(
app.task_manager.status(first_id),
Some(TaskStatus::Failed("render failed".to_string()))
);
assert!(
snapshots
.iter()
.filter(|task| task.group_id.as_deref() == Some(&group_id))
.all(|task| matches!(task.status, TaskStatus::Failed(_) | TaskStatus::Cancelled))
);
assert!(
!snapshots
.iter()
.any(|task| task.label == "Build Search Index")
);
assert!(!app.site_generation_workflows.contains_key(&group_id));
}
#[test]
fn cancelling_a_render_task_cancels_the_generation_group() {
let (db, project, tmp) = setup();
enable_generation(&tmp);
let mut app = make_app(db, project, &tmp);
let _task = app.queue_site_generation(None);
let snapshots = app.task_manager.snapshots();
let group_id = snapshots[0].group_id.clone().unwrap();
let _task = app.update(Message::CancelTask(snapshots[0].id));
let snapshots = app.task_manager.snapshots();
assert!(
snapshots
.iter()
.filter(|task| task.group_id.as_deref() == Some(&group_id))
.all(|task| task.status == TaskStatus::Cancelled)
);
assert!(
!snapshots
.iter()
.any(|task| task.label == "Build Search Index")
);
assert!(!app.site_generation_workflows.contains_key(&group_id));
}
#[test]
fn validation_apply_queues_only_affected_sections_then_index() {
let (db, project, tmp) = setup();
enable_generation(&tmp);
let mut app = make_app(db, project, &tmp);
let validation = bds_core::engine::validate_site::SiteValidationReport {
stale_pages: vec!["2024/03/09/hello/index.html".to_string()],
..Default::default()
};
let _task = app.queue_site_generation(Some(validation));
let snapshots = app.task_manager.snapshots();
assert_eq!(snapshots.len(), 1);
assert_eq!(snapshots[0].label, "Render Single Posts");
assert_eq!(
snapshots[0].group_name.as_deref(),
Some("Apply Site Validation")
);
let group_id = snapshots[0].group_id.clone().unwrap();
let _task = app.handle_engine_message(Message::SiteGenerationSectionDone {
group_id,
task_id: snapshots[0].id,
result: Ok(GenerationReport::default()),
});
assert!(
app.task_manager
.snapshots()
.iter()
.any(|task| task.label == "Build Search Index")
);
}
#[test]
fn post_editor_save_flow_persists_changes() {
let (db, project, tmp) = setup();

238
crates/bds-ui/src/app/engine_handlers.rs
View File

@@ -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"),
}
}

313
crates/bds-ui/src/app/tasks.rs
View File

@@ -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())
}