Skip to content

LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust

Preserve requested source in render failure diagnostics

FredApps69e34624e061
diff --git a/crates/ui-egui/src/render.rs b/crates/ui-egui/src/render.rs
index 095fba4b2..101e5f845 100644
--- a/crates/ui-egui/src/render.rs
+++ b/crates/ui-egui/src/render.rs
@@ -97,6 +97,12 @@ struct Finished {
color: Option<Arc<egui::ColorImage>>,
}
+/// Immutable identity captured when a request is submitted, not when its result is collected.
+struct Requested {
+ id: u64,
+ source: Option<lightcraft_catalog::Source>,
+}
+
struct Queued {
slot: Slot,
priority: u32,
@@ -183,7 +189,9 @@ const VARIANT_PRIORITY: u32 = 6;
pub struct Renderer {
#[cfg(test)]
pub(crate) thumb_jobs_built: usize,
- request_ids: HashMap<Slot, u64>,
+ requests: HashMap<Slot, Requested>,
+ #[cfg(test)]
+ failure_messages: Vec<String>,
/// Request id of the pixels each interactive view (loupe, before, hover) shows: a draft that
/// finishes after a newer request was made still replaces older pixels, so a long slider drag
/// keeps updating the loupe instead of waiting for the drag to pause.
@@ -272,7 +280,9 @@ impl Renderer {
Renderer {
#[cfg(test)]
thumb_jobs_built: 0,
- request_ids: HashMap::new(),
+ requests: HashMap::new(),
+ #[cfg(test)]
+ failure_messages: Vec::new(),
shown_ids: HashMap::new(),
epoch: 0,
preview_generation: None,
@@ -459,7 +469,7 @@ impl Renderer {
}
self.pending.insert(slot, (job.key, priority));
job.request_id = lightcraft_preview::next_tick();
- self.request_ids.insert(slot, job.request_id);
+ self.requests.insert(slot, Requested { id: job.request_id, source: Some(job.origin.clone()) });
// (an offload keeps its own per-view stage caches; the flag tells it to)
let job = if slot.is_view() { job.with_stages(self.stages.entry(slot).or_default().clone()) } else { job };
if self.offload.is_some() {
@@ -491,7 +501,12 @@ impl Renderer {
self.quick_tried.insert(slot, job.key);
self.pending.insert(slot, (job.key, priority));
job.request_id = lightcraft_preview::next_tick();
- self.request_ids.insert(slot, job.request_id);
+ let source = job
+ .small
+ .as_ref()
+ .map(|job| job.origin.clone())
+ .or_else(|| job.embedded.as_ref().map(|(path, _, _)| lightcraft_catalog::Source::File { path: path.clone() }));
+ self.requests.insert(slot, Requested { id: job.request_id, source });
let key = job.key;
let display = self.display.clone();
self.pool.submit(slot, key, priority, Box::new(move || Self::run_for(|| job.run(), &display)));
@@ -510,7 +525,7 @@ impl Renderer {
}
self.pending.insert(slot, (key, priority));
let request_id = lightcraft_preview::next_tick();
- self.request_ids.insert(slot, request_id);
+ self.requests.insert(slot, Requested { id: request_id, source: None });
let display = self.display.clone();
self.pool.submit(slot, key, priority, Box::new(move || Self::run_for(|| compose.result(request_id), &display)));
}
@@ -524,7 +539,7 @@ impl Renderer {
self.prefetched.insert(slot, job.key);
self.pending.insert(slot, (job.key, priority));
job.request_id = lightcraft_preview::next_tick();
- self.request_ids.insert(slot, job.request_id);
+ self.requests.insert(slot, Requested { id: job.request_id, source: Some(job.origin.clone()) });
let key = job.key;
self.pool.submit(
slot,
@@ -546,7 +561,7 @@ impl Renderer {
self.queue.retain(|q| !gone(&q.slot));
// (a render already running finishes unclaimed: its result is dropped)
self.pending.retain(|s, _| !gone(s));
- self.request_ids.retain(|s, _| !gone(s));
+ self.requests.retain(|s, _| !gone(s));
self.failed.retain(|s, _| !gone(s));
self.slides_live = !keep.is_empty();
}
@@ -554,7 +569,7 @@ impl Renderer {
/// Is a request for `slot` queued or running?
/// Drop every texture and cached stage (another library was opened: photo ids changed meaning).
pub fn forget_all(&mut self) {
- self.request_ids.clear();
+ self.requests.clear();
self.shown_ids.clear();
self.epoch = lightcraft_preview::next_tick();
self.preview_generation = None;
@@ -679,14 +694,14 @@ impl Renderer {
});
for s in dropped {
self.pending.remove(&s);
- self.request_ids.remove(&s);
+ self.requests.remove(&s);
}
- let request_ids = &mut self.request_ids;
+ let requests = &mut self.requests;
let pending = &mut self.pending;
self.queue.retain(|q| match q.slot {
Slot::Variant(k) if stale(used.get(&k)) => {
pending.remove(&q.slot);
- request_ids.remove(&q.slot);
+ requests.remove(&q.slot);
false
}
_ => true,
@@ -787,9 +802,9 @@ impl Renderer {
// an interactive view still takes a superseded draft that is newer than what it
// shows, and the source it decoded: a drag supersedes every request before it
// finishes, and a source thrown away with them is decoded again for every tick.
- if self.request_ids.get(&slot) != Some(&r.request_id) {
+ let source = if self.requests.get(&slot).map(|request| request.id) != Some(r.request_id) {
let newer_draft = slot.is_view()
- && self.request_ids.contains_key(&slot)
+ && self.requests.contains_key(&slot)
&& r.request_id >= self.epoch
&& self.shown_ids.get(&slot).is_none_or(|shown| r.request_id > *shown)
&& r.rendered.is_ok();
@@ -797,10 +812,12 @@ impl Renderer {
continue;
}
session.accept(&r);
+ None // superseded successful drafts have no failure diagnostic
} else {
- self.request_ids.remove(&slot);
+ let source = self.requests.remove(&slot).and_then(|request| request.source);
session.accept(&r);
- }
+ source
+ };
if slot.is_view() {
self.shown_ids.insert(slot, r.request_id);
}
@@ -822,7 +839,10 @@ impl Renderer {
}
Err(e) => {
if !matches!(slot, Slot::Prefetch(_)) {
- log::warn!("{}", render_failure_message(slot, r.photo, session.catalog.photo(r.photo).map(|p| &p.source), &e));
+ let message = render_failure_message(slot, r.photo, source.as_ref(), &e);
+ #[cfg(test)]
+ self.failure_messages.push(message.clone());
+ log::warn!("{message}");
self.failed.insert(slot, (r.key, e, self.catalog_rev, r.photo));
}
continue;
@@ -957,7 +977,7 @@ impl Renderer {
self.pool.reprioritize(|s, p| if matches!(s, Slot::Import(_)) { None } else { Some(p) });
self.queue.retain(|q| !matches!(q.slot, Slot::Import(_)));
self.pending.retain(|s, _| !matches!(s, Slot::Import(_)));
- self.request_ids.retain(|s, _| !matches!(s, Slot::Import(_)));
+ self.requests.retain(|s, _| !matches!(s, Slot::Import(_)));
self.textures.retain(|s, _| !matches!(s, Slot::Import(_)));
self.quick_tried.retain(|s, _| !matches!(s, Slot::Import(_)));
}
@@ -972,15 +992,15 @@ impl Renderer {
});
for s in dropped {
self.pending.remove(&s);
- self.request_ids.remove(&s);
+ self.requests.remove(&s);
self.quick_tried.remove(&s);
}
- let request_ids = &mut self.request_ids;
+ let requests = &mut self.requests;
let pending = &mut self.pending;
self.queue.retain(|q| match q.slot {
Slot::Thumb(id) if !keep.contains(&id) && q.priority <= 10 => {
pending.remove(&q.slot);
- request_ids.remove(&q.slot);
+ requests.remove(&q.slot);
false
}
_ => true,
@@ -1180,6 +1200,64 @@ mod thumbnail_tests {
crate::panels::grid::request_thumb(app, PhotoId(1), 256, 10);
}
+ fn relink_destination() -> std::path::PathBuf {
+ let path = std::env::temp_dir().join(format!("lc-render-relinked-{}-{}.nef", std::process::id(), lightcraft_preview::next_tick()));
+ std::fs::write(&path, b"replacement source").unwrap();
+ path
+ }
+
+ #[test]
+ fn completed_failure_keeps_requested_source_after_relink() {
+ let replacement = relink_destination();
+ for slot in [Slot::Thumb(PhotoId(1)), Slot::Main, Slot::Before, Slot::Compare(1), Slot::Region] {
+ let (mut app, work, ctx) = fixture();
+ app.session.media.file_loader = Some(Arc::new(|_, _| Err("simulated decode failure".into())));
+ let job = app.session.render_job(PhotoId(1), 64, 64, false, true).unwrap();
+ app.renderer.request(slot, job, 100);
+ let (submitted, job) = take_job(&work);
+ assert_eq!(submitted, slot);
+ let result = job.run();
+ assert!(result.rendered.is_err(), "the old request has already failed");
+ app.session.execute("photo.relink", &serde_json::json!({"id": 1, "path": replacement})).unwrap();
+ assert!(
+ matches!(&app.session.catalog.photo(PhotoId(1)).unwrap().source, Source::File { path } if path.ends_with(replacement.file_name().unwrap().to_str().unwrap()))
+ );
+ finish(&mut app, &work, &ctx, slot, result);
+ assert_eq!(app.renderer.failure(slot), Some("simulated decode failure"));
+ assert!(!app.renderer.is_pending(slot));
+ let message = app.renderer.failure_messages.last().expect("the collector emitted a diagnostic");
+ assert!(message.contains("audit.jpg"), "{message}");
+ assert!(!message.contains("lc-render-relinked-"), "the failed request did not read the replacement: {message}");
+ assert!(message.ends_with(": simulated decode failure"), "{message}");
+ }
+ std::fs::remove_file(replacement).unwrap();
+ }
+
+ #[test]
+ fn superseded_failure_does_not_take_the_new_requests_source() {
+ let replacement = relink_destination();
+ let (mut app, work, ctx) = fixture();
+ app.session.media.file_loader = Some(Arc::new(|_, _| Err("simulated decode failure".into())));
+ let slot = Slot::Main;
+ let old_job = app.session.render_job(PhotoId(1), 64, 64, false, true).unwrap();
+ app.renderer.request(slot, old_job, 100);
+ let (_, old_job) = take_job(&work);
+ let old_result = old_job.run();
+ app.session.execute("photo.relink", &serde_json::json!({"id": 1, "path": replacement})).unwrap();
+ let new_job = app.session.render_job(PhotoId(1), 64, 64, false, true).unwrap();
+ app.renderer.request(slot, new_job, 100);
+ let (_, new_job) = take_job(&work);
+ finish(&mut app, &work, &ctx, slot, old_result);
+ assert!(app.renderer.failure_messages.is_empty(), "obsolete failures stay suppressed");
+ assert!(app.renderer.is_pending(slot));
+ finish(&mut app, &work, &ctx, slot, new_job.run());
+ let message = app.renderer.failure_messages.last().expect("new failure is reported");
+ assert!(message.contains("lc-render-relinked-"), "{message}");
+ assert!(!message.contains("audit.jpg"), "{message}");
+ assert!(app.renderer.requests.is_empty(), "completed request identity is released");
+ std::fs::remove_file(replacement).unwrap();
+ }
+
#[test]
fn unchanged_ready_and_running_frames_build_no_jobs() {
let (mut app, work, ctx) = fixture();