diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index b076769040..1c1a968cb5 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -489,6 +489,9 @@ pub struct Session { /// A further route for File › Print when neither `lp` nor a CUPS server over IPP is /// reachable (the XDG Print portal in a Flatpak); see `print_cmds::Spooler`. pub print_spooler: Option, + /// The printers `file.printers`, `file.print.printers` and the Print dialog list in place of + /// the system's (tests); see `print_cmds::PrinterSource`. `None` asks the spooler. + pub printer_source: Option, /// Background jobs (see [`jobs`]). jobs: jobs::Jobs, /// Color Sampler points dropped by the last canvas-size change (crop, Canvas Size, Image Size, diff --git a/crates/engine/src/print_cmds.rs b/crates/engine/src/print_cmds.rs index 3cc99aa276..bf452315de 100644 --- a/crates/engine/src/print_cmds.rs +++ b/crates/engine/src/print_cmds.rs @@ -71,6 +71,53 @@ pub struct Spooler { pub run: SpoolFn, } +/// A stand-in for the system's printers, installed on `Session::printer_source` (tests): +/// `file.printers`, `file.print.printers` and the Print dialog list these and do not ask the spooler. +pub type PrinterSource = std::sync::Arc Vec + Send + Sync>; + +/// Held while a thread of this process lists printers or calls into a printer driver. +static SPOOLER: std::sync::Mutex<()> = std::sync::Mutex::new(()); + +/// Runs `f`, which lists printers or calls into a printer driver, while no other thread of this +/// process does either. On Windows, two threads that open printers' PrintTicket providers for the +/// first time at once can crash the process inside the spooler client (`winspool.drv`). A panic in +/// an earlier caller does not block later ones. +pub fn with_spooler(f: impl FnOnce() -> T) -> T { + let _held = SPOOLER.lock().unwrap_or_else(std::sync::PoisonError::into_inner); + f() +} + +/// Counts the times this process asked the system for its printers. +static SYSTEM_LISTINGS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0); + +/// How many times this process has asked the system for its printers. A session with a +/// `printer_source` does not ask. +pub fn system_printer_listings() -> usize { + SYSTEM_LISTINGS.load(std::sync::atomic::Ordering::Relaxed) +} + +/// The printers `craft-print` spools to, or the session's stand-in for them. +fn system_printer_list(s: &Session) -> Vec { + with_spooler(|| match &s.printer_source { + Some(source) => source(), + None => { + SYSTEM_LISTINGS.fetch_add(1, std::sync::atomic::Ordering::Relaxed); + craft_print::printers() + } + }) +} + +/// The printers the GDI route prints to (`craft_print::rgb`), or the session's stand-in for them. +pub fn rgb_printers(s: &Session) -> std::result::Result, craft_print::rgb::PrintError> { + with_spooler(|| match &s.printer_source { + Some(source) => Ok(source().into_iter().map(|p| craft_print::rgb::Printer { name: p.name, default: p.default }).collect()), + None => { + SYSTEM_LISTINGS.fetch_add(1, std::sync::atomic::Ordering::Relaxed); + craft_print::rgb::printers() + } + }) +} + /// Why the IPP route could not spool: no route at all (the app's spooler may have one), or a /// failure on a route that exists (a wrong printer name, a rejected job). enum SpoolError { @@ -90,7 +137,7 @@ fn spool_job(spooler: Option<&Spooler>, job: &PrintJob, lp: &craft_print::Job) - return app(sp); } if let Some(name) = system_spooler() { - return craft_print::submit(&job.pdf, lp).map(|m| (m, name.to_string())).map_err(other); + return with_spooler(|| craft_print::submit(&job.pdf, lp)).map(|m| (m, name.to_string())).map_err(other); } } match cups_spool(job) { @@ -189,10 +236,10 @@ fn cups_spool(job: &PrintJob) -> std::result::Result { /// `file.printers`: the printers the system's (or `printServer`'s) print server knows, with the default. From /// `craft-print` (`lpstat`, the Windows spooler) where that is the route; over IPP for a named /// server and where there is no `lp` (a sandbox). -fn system_printers(_s: &mut Session, p: &Value) -> Result { +fn system_printers(s: &mut Session, p: &Value) -> Result { let named = p.get("printServer").and_then(Value::as_str).filter(|v| !v.is_empty()); - if named.is_none() && system_spooler().is_some() { - let list = craft_print::printers(); + if named.is_none() && (s.printer_source.is_some() || system_spooler().is_some()) { + let list = system_printer_list(s); let default = list.iter().find(|p| p.default).map(|p| p.name.clone()); let printers: Vec = list.into_iter().map(|p| json!({"name": p.name, "default": p.default})).collect(); return Ok(json!({"server": Value::Null, "default": default, "printers": printers})); @@ -671,7 +718,7 @@ fn printer_name(p: &Value) -> Result { if let Some(name) = p.get("printer").and_then(Value::as_str).filter(|v| !v.trim().is_empty()) { return Ok(name.to_string()); } - craft_print::rgb::default_printer().map_err(other)?.ok_or_else(|| other("no printer chosen and no default printer is set")) + with_spooler(craft_print::rgb::default_printer).map_err(other)?.ok_or_else(|| other("no printer chosen and no default printer is set")) } /// The driver settings chosen with Print Settings… (`printerSettings`, hex), when any. @@ -717,7 +764,7 @@ pub fn page_rect_top_left(page: &PrintPage) -> (f64, f64, f64, f64) { fn print_windows(page: &PrintPage, p: &Value, title: &str, copies: u32) -> Result { let printer = printer_name(p)?; let settings = printer_settings(p)?; - let device_page = craft_print::rgb::page(&printer, settings.as_ref()).map_err(other)?; + let device_page = with_spooler(|| craft_print::rgb::page(&printer, settings.as_ref())).map_err(other)?; if (device_page.paper.0 - page.paper.0).abs() > 2.0 || (device_page.paper.1 - page.paper.1).abs() > 2.0 { return Err(other("the driver paper or orientation differs from the print layout; choose the matching paper in Print Settings before printing")); } @@ -739,14 +786,14 @@ fn print_windows(page: &PrintPage, p: &Value, title: &str, copies: u32) -> Resul color_policy, primitives: &primitives, }; - let done = craft_print::rgb::print(&job, &image, rect).map_err(other)?; + let done = with_spooler(|| craft_print::rgb::print(&job, &image, rect)).map_err(other)?; Ok( json!({"printer": printer, "dpi": [done.dpi.0, done.dpi.1], "deviceRect": [done.device_rect.0, done.device_rect.1, done.device_rect.2, done.device_rect.3]}), ) } -fn printers(_: &mut Session, _: &Value) -> Result { - match craft_print::rgb::printers() { +fn printers(s: &mut Session, _: &Value) -> Result { + match rgb_printers(s) { Ok(list) => Ok(json!({"supported": true, "printers": list.iter().map(|p| json!({"name": p.name, "default": p.default})).collect::>()})), Err(craft_print::rgb::PrintError::Unsupported) => Ok(json!({"supported": false, "printers": []})), Err(e) => Err(other(e)), @@ -755,7 +802,8 @@ fn printers(_: &mut Session, _: &Value) -> Result { fn printer_page(_: &mut Session, p: &Value) -> Result { let printer = printer_name(p)?; - let pg = craft_print::rgb::page(&printer, printer_settings(p)?.as_ref()).map_err(other)?; + let settings = printer_settings(p)?; + let pg = with_spooler(|| craft_print::rgb::page(&printer, settings.as_ref())).map_err(other)?; Ok( json!({"printer": printer, "paper": [pg.paper.0, pg.paper.1], "printable": [pg.printable.0, pg.printable.1, pg.printable.2, pg.printable.3], "dpi": [pg.dpi.0, pg.dpi.1]}), ) diff --git a/crates/engine/src/print_cmds/tests.rs b/crates/engine/src/print_cmds/tests.rs index ddd1a65a16..83eca48f0b 100644 --- a/crates/engine/src/print_cmds/tests.rs +++ b/crates/engine/src/print_cmds/tests.rs @@ -196,12 +196,23 @@ fn native_rgb_route_preserves_pdf_only_color_and_page_content() { assert!(native_rgb_compatible(&page_of(1, vec![0; 2], false), "noColorManagement")); } +/// Two printers, the second the default, in place of the system spooler's. +fn test_printers() -> PrinterSource { + std::sync::Arc::new(|| { + vec![ + craft_print::Printer { name: "Studio".into(), default: false, two_sided: None }, + craft_print::Printer { name: "Office".into(), default: true, two_sided: Some(true) }, + ] + }) +} + #[test] fn printer_commands_answer_without_a_document_and_reject_bad_settings() { let mut s = Session::new(); + s.printer_source = Some(test_printers()); let r = s.execute("file.print.printers", json!({})).unwrap(); - assert_eq!(r["supported"], cfg!(windows)); - assert!(r["printers"].is_array()); + assert_eq!(r["supported"], true); + assert_eq!(r["printers"], json!([{"name": "Studio", "default": false}, {"name": "Office", "default": true}])); assert!(s.execute("file.print.page", json!({"printer": "Anything", "printerSettings": "zz"})).is_err()); let mut s = session("rgb", 8); assert!(s.execute("file.print", json!({"printer": "Anything", "printerSettings": "0102", "send": true})).is_err()); @@ -433,13 +444,60 @@ fn disabled_printing_never_spools() { #[test] fn printers_lists_the_spooler_destinations_without_a_document() { let mut s = Session::new(); + s.printer_source = Some(test_printers()); let r = s.execute("file.printers", json!({})).unwrap(); - let list = r["printers"].as_array().unwrap(); - assert!(list.iter().all(|p| p["name"].is_string() && p["default"].is_boolean())); - match r["default"].as_str() { - Some(d) => assert!(list.iter().any(|p| p["name"] == d && p["default"] == true)), - None => assert!(list.iter().all(|p| p["default"] == false)), + assert_eq!(r["printers"], json!([{"name": "Studio", "default": false}, {"name": "Office", "default": true}])); + assert_eq!(r["default"], "Office"); + s.printer_source = Some(std::sync::Arc::new(Vec::new)); + let r = s.execute("file.printers", json!({})).unwrap(); + assert_eq!((r["printers"].clone(), r["default"].clone()), (json!([]), Value::Null)); +} + +/// Threads that list printers at the same time enter the spooler one at a time: the stand-in +/// printer list records how many threads were inside it at once. +#[test] +fn printer_listings_enter_the_spooler_one_thread_at_a_time() { + use std::sync::atomic::{AtomicUsize, Ordering}; + use std::sync::{Arc, Barrier}; + const THREADS: usize = 8; + let inside = Arc::new(AtomicUsize::new(0)); + let most = Arc::new(AtomicUsize::new(0)); + let start = Arc::new(Barrier::new(THREADS)); + let threads: Vec<_> = (0..THREADS) + .map(|i| { + let (inside, most, start) = (Arc::clone(&inside), Arc::clone(&most), Arc::clone(&start)); + std::thread::spawn(move || { + let mut s = Session::new(); + s.printer_source = Some(Arc::new(move || { + let now = inside.fetch_add(1, Ordering::SeqCst) + 1; + most.fetch_max(now, Ordering::SeqCst); + std::thread::sleep(std::time::Duration::from_millis(5)); + inside.fetch_sub(1, Ordering::SeqCst); + vec![craft_print::Printer { name: "Office".into(), default: true, two_sided: None }] + })); + start.wait(); + for _ in 0..3 { + let id = if i % 2 == 0 { "file.printers" } else { "file.print.printers" }; + assert_eq!(s.execute(id, json!({})).unwrap()["printers"][0]["name"], "Office"); + } + }) + }) + .collect(); + for t in threads { + t.join().unwrap(); } + assert_eq!(most.load(Ordering::SeqCst), 1, "two threads were in the printer listing at once"); +} + +/// A caller that panics inside the spooler leaves it usable for later callers. +#[test] +fn a_panic_inside_the_spooler_does_not_block_later_callers() { + let panicked = std::thread::spawn(|| with_spooler::<()>(|| panic!("a driver call panicked"))).join(); + assert!(panicked.is_err()); + assert_eq!(with_spooler(|| 7), 7); + let mut s = Session::new(); + s.printer_source = Some(test_printers()); + assert_eq!(s.execute("file.printers", json!({})).unwrap()["default"], "Office"); } /// Spooling tests run in a child process: `disable_printing` is process-wide and a test above diff --git a/crates/engine/tests/panic_hunt.rs b/crates/engine/tests/panic_hunt.rs index 893ba5c23d..36b392a9ea 100644 --- a/crates/engine/tests/panic_hunt.rs +++ b/crates/engine/tests/panic_hunt.rs @@ -13,6 +13,8 @@ fn fresh() -> Session { // Belt and braces with the EXTERNAL skip below: nothing in this process may reach a printer. photocraft_engine::print_cmds::disable_printing(); let mut s = Session::new(); + // `file.printers` and `file.print.printers` list no printers and do not ask the spooler. + s.printer_source = Some(std::sync::Arc::new(Vec::new)); s.execute("file.new", json!({"width": 24, "height": 16})).unwrap(); s.execute("layer.new.layer", json!({})).unwrap(); s.execute("select.rect", json!({"x": 1, "y": 1, "width": 6, "height": 5})).unwrap(); diff --git a/crates/ui-egui/src/file_ui.rs b/crates/ui-egui/src/file_ui.rs index 3f87f6339c..2a5e632940 100644 --- a/crates/ui-egui/src/file_ui.rs +++ b/crates/ui-egui/src/file_ui.rs @@ -758,7 +758,7 @@ pub fn open_print(app: &mut PhotocraftApp) -> u64 { f.entry(k.to_string()).or_insert(v); } // Windows: the system's printers, and the paper from the chosen printer's driver settings. - if let Ok(list) = craft_print::rgb::printers() { + if let Ok(list) = photocraft_engine::print_cmds::rgb_printers(&app.session) { f.insert("__printers".into(), json!(list.iter().map(|p| p.name.clone()).collect::>())); let known = |n: &str| list.iter().any(|p| p.name == n); if !known(&s(&f, "printer", "")) { @@ -774,7 +774,7 @@ pub fn open_print(app: &mut PhotocraftApp) -> u64 { fn driver_page(f: &mut Map) { let printer = s(f, "printer", ""); let settings = f.get("printerSettings").and_then(Value::as_str).and_then(|h| craft_print::rgb::DevMode::from_hex(h).ok()); - match craft_print::rgb::page(&printer, settings.as_ref()) { + match photocraft_engine::print_cmds::with_spooler(|| craft_print::rgb::page(&printer, settings.as_ref())) { Ok(pg) => { f.insert("paper".into(), json!([pg.paper.0, pg.paper.1])); f.insert("orientation".into(), json!("portrait")); @@ -976,7 +976,7 @@ fn print_body(app: &mut PhotocraftApp, ui: &mut egui::Ui, f: &mut Map { f.insert("printerSettings".into(), json!(dm.to_hex())); driver_page(f); @@ -1168,6 +1168,8 @@ mod tests { fn app() -> (PhotocraftApp, egui::Context) { let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services::default()); + // Print lists this printer and does not ask the spooler. + app.session.printer_source = Some(Arc::new(|| vec![craft_print::Printer { name: "Test printer".into(), default: true, two_sided: None }])); app.run("file.new", json!({"width": 120, "height": 80, "name": "web"})).unwrap(); (app, egui::Context::default()) } @@ -1447,9 +1449,12 @@ mod tests { let (mut app, ctx) = app(); let id = crate::menus::invoke(&mut app, &ctx, "file.print", json!({})).unwrap()["dialog"].as_u64().unwrap(); let f = &app.ui.dialog_mut(id).unwrap().fields; - assert!(f.get("__systemPrinters").is_some_and(Value::is_array)); + assert_eq!(f["__systemPrinters"], json!([{"name": "Test printer", "default": true}])); + assert_eq!((f["__printers"].clone(), f["printer"].clone()), (json!(["Test printer"]), json!("Test printer"))); assert!(params(f).get("__systemPrinters").is_none()); assert!(params(f).get("__printers").is_none()); + // Every test in this binary that opens Print lists the session's printers. + assert_eq!(photocraft_engine::print_cmds::system_printer_listings(), 0, "a test asked the system spooler for its printers"); } #[test] diff --git a/crates/ui-egui/src/jobs_ui_tests.rs b/crates/ui-egui/src/jobs_ui_tests.rs index f2b7d0fbc0..f2f39d040b 100644 --- a/crates/ui-egui/src/jobs_ui_tests.rs +++ b/crates/ui-egui/src/jobs_ui_tests.rs @@ -703,6 +703,8 @@ fn printing_keeps_drawing_and_reports_only_the_final_spooler_result() { assert!(h.state().ui.status_error); } } + // The job and its status do not ask the system spooler for its printers. + assert_eq!(photocraft_engine::print_cmds::system_printer_listings(), 0, "a test asked the system spooler for its printers"); } fn layer_count(app: &PhotocraftApp) -> usize { diff --git a/crates/ui-egui/tests/custom_print_paper.rs b/crates/ui-egui/tests/custom_print_paper.rs index d0d81dea69..b65d7ce10b 100644 --- a/crates/ui-egui/tests/custom_print_paper.rs +++ b/crates/ui-egui/tests/custom_print_paper.rs @@ -6,15 +6,24 @@ use serde_json::{Map, Value, json}; fn app() -> (PhotocraftApp, u64) { let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), photocraft_ui_egui::Services::default()); + // Exercise PDF paper controls even when native printers are available, on every OS. Print + // lists this printer and does not ask the spooler. + app.session.printer_source = + Some(std::sync::Arc::new(|| vec![craft_print::Printer { name: "Test native printer".into(), default: true, two_sided: None }])); app.run("file.new", json!({"width": 120, "height": 80, "name": "Custom paper"})).unwrap(); let id = open_print(&mut app); + assert_no_system_listing(); // Every UI path in these fixtures is safe even if an unexpected Enter confirms the dialog. app.ui.dialog_mut(id).unwrap().fields.insert("dryRun".into(), json!(true)); - // Exercise PDF paper controls even when native printers are available, on every OS. - app.ui.dialog_mut(id).unwrap().fields.insert("__printers".into(), json!(["Test native printer"])); + assert_eq!(app.ui.dialog_mut(id).unwrap().fields["__printers"], json!(["Test native printer"])); (app, id) } +/// No test in this binary asks the system spooler for its printers. +fn assert_no_system_listing() { + assert_eq!(photocraft_engine::print_cmds::system_printer_listings(), 0, "a test asked the system spooler for its printers"); +} + fn show(ui: &mut egui::Ui, app: &mut PhotocraftApp) { if ui.ctx().fonts(|fonts| fonts.families().contains(&egui::FontFamily::Name("medium".into()))) { photocraft_ui_egui::dialogs::show(app, ui.ctx()); @@ -105,6 +114,7 @@ fn custom_paper_ui_edits_reach_preview_and_pdf_and_restore_when_reopened() { assert!(String::from_utf8_lossy(&pdf).contains("/MediaBox [0 0 666.00 522.00]")); assert_eq!(h.state().session.file_menu.last_print.as_ref().unwrap()["paper"], json!([522.0, 666.0])); let id = open_print(h.state_mut()); + assert_no_system_listing(); h.state_mut().ui.dialog_mut(id).unwrap().fields.insert("dryRun".into(), json!(true)); h.run_steps(3); assert!(shown(&h, "Custom"), "reopening array-valued settings must show Custom");