Bound staged browser Load Actions selections before reading

This commit is contained in:
yoriswind committed 2026-11-02 15:12:13 -08:00
1 parent 87238953ec
commit f2e5d3f8fa
10 files changed
+183 -32

No files matched your search

+60
View File
@@ -15,6 +15,27 @@ where
Ok((name, read().await))
}
/// Preflight every immutable browser size before creating the future that reads any selection.
/// The optional staging budget is separate from the per-file cap enforced by [`read`].
pub async fn read_contents<F, Fut>(sizes: impl IntoIterator<Item = f64>, max: Option<u64>, read: F) -> Result<Vec<(String, Vec<u8>)>, String>
where
F: FnOnce() -> Fut,
Fut: Future<Output = Result<Vec<(String, Vec<u8>)>, String>>,
{
if let Some(max) = max {
let total = sizes.into_iter().try_fold(0u64, |sum, size| {
if !size.is_finite() || size < 0.0 || size.fract() != 0.0 || size >= u64::MAX as f64 {
return None;
}
sum.checked_add(size as u64)
});
if total.is_none_or(|total| total > max) {
return Err(format!("the selected files are larger than {max} bytes or their total size is invalid"));
}
}
read().await
}
#[cfg(test)]
mod tests {
use super::*;
@@ -53,4 +74,43 @@ mod tests {
}
}
}
/// Check all metadata before even creating the read future, including a late excess and
/// overflowing totals. Huge sizes here are numbers only; the reader returns four tiny bytes.
#[test]
fn contents_budget_preflights_the_entire_selection_before_any_read() {
let cases = [
(vec![2.0, 2.0], Some(4), true),
(vec![2.0, 3.0], Some(4), false),
(vec![0.0, 0.0], Some(0), true),
(vec![], Some(0), true),
(vec![(512u64 << 20) as f64], Some(512 << 20), true),
(vec![(512u64 << 20) as f64, 1.0], Some(512 << 20), false),
(vec![2f64.powi(63), 2f64.powi(63)], Some(u64::MAX), false),
(vec![2f64.powi(64)], Some(u64::MAX), false),
(vec![f64::NAN], Some(4), false),
(vec![f64::INFINITY], Some(4), false),
(vec![-1.0], Some(4), false),
(vec![0.5], Some(4), false),
(vec![f64::NAN, f64::INFINITY], None, true),
];
for (sizes, max, allowed) in cases {
let called = Cell::new(false);
let files = vec![("first.atn".into(), vec![1, 2]), ("last.atn".into(), vec![3, 4])];
let future = read_contents(sizes, max, || {
assert!(allowed, "no file can be read from a refused selection");
called.set(true);
std::future::ready(Ok(files.clone()))
});
let mut future = std::pin::pin!(future);
let Poll::Ready(result) = future.as_mut().poll(&mut Context::from_waker(Waker::noop())) else { panic!("an immediate read") };
assert_eq!(called.get(), allowed);
assert_eq!(result.is_ok(), allowed);
if allowed {
assert_eq!(result.unwrap(), files, "selection order and payloads are unchanged");
} else {
assert!(result.unwrap_err().contains("selected files"));
}
}
}
}
+13 -18
View File
@@ -419,7 +419,7 @@ fn services(inbox: Inbox, place_inbox: Inbox, cursor_pos: photocraft_ui_egui::Cu
file_dialog: Some(Box::new(|request, _parent, reply| match request {
// The browser's file picker hands over the files' contents, not paths. File › Open
// asks for several files (`multiple`), each opened in its own tab.
FileDialogRequest::Open { multiple, extensions, max_bytes, .. } => wasm_bindgen_futures::spawn_local(async move {
FileDialogRequest::Open { multiple, extensions, max_bytes, max_contents_bytes, .. } => wasm_bindgen_futures::spawn_local(async move {
let dialog = if let Some(exts) = extensions {
rfd::AsyncFileDialog::new().add_filter("Supported Files", &exts)
} else {
@@ -428,24 +428,19 @@ fn services(inbox: Inbox, place_inbox: Inbox, cursor_pos: photocraft_ui_egui::Cu
let picked = if multiple { dialog.pick_files().await } else { dialog.pick_file().await.map(|file| vec![file]) };
let answer = match picked {
Some(picked) if !picked.is_empty() => {
let mut files = Vec::with_capacity(picked.len());
let mut error = None;
for file in picked {
// File/Blob size is immutable; reject before rfd creates its ArrayBuffer/Vec.
match crate::picked_file::read(file.file_name(), file.inner().size(), max_bytes, || file.read()).await {
Ok(file) => files.push(file),
Err(why) => {
error = Some(why);
break;
}
let contents = crate::picked_file::read_contents(picked.iter().map(|file| file.inner().size()), max_contents_bytes, || async {
let mut files = Vec::with_capacity(picked.len());
for file in &picked {
// File/Blob size is immutable; each cap precedes its ArrayBuffer/Vec.
files.push(crate::picked_file::read(file.file_name(), file.inner().size(), max_bytes, || file.read()).await?);
}
}
if let Some(why) = error {
Some(FileDialogAnswer::Unavailable(why))
} else if multiple {
Some(FileDialogAnswer::ContentsMany(files))
} else {
files.pop().map(|(name, bytes)| FileDialogAnswer::Contents(name, bytes))
Ok(files)
})
.await;
match contents {
Err(why) => Some(FileDialogAnswer::Unavailable(why)),
Ok(files) if multiple => Some(FileDialogAnswer::ContentsMany(files)),
Ok(mut files) => files.pop().map(|(name, bytes)| FileDialogAnswer::Contents(name, bytes)),
}
}
_ => None,
+7 -1
View File
@@ -26,7 +26,13 @@ fn browse_field(app: &mut PhotocraftApp, id: u64, fields: &serde_json::Map<Strin
app.ask_folder(move |app, path| fill_field(app, id, &key, path))
} else if fields.get("__command").and_then(Value::as_str) == Some("plugin.install") {
let initial_dir = crate::file_dialog::last_used_dir(&app.ui.recent_files);
let request = crate::file_dialog::FileDialogRequest::Open { multiple: false, initial_dir, extensions: Some(vec!["wasm".into()]), max_bytes: None };
let request = crate::file_dialog::FileDialogRequest::Open {
multiple: false,
initial_dir,
extensions: Some(vec!["wasm".into()]),
max_bytes: None,
max_contents_bytes: None,
};
app.ask_file(request, move |app, answer| match answer {
crate::file_dialog::FileDialogAnswer::Paths(mut paths) if !paths.is_empty() => fill_field(app, id, &key, paths.remove(0)),
_ => Err("Install Plug-in reads a .wasm file from disk".into()),
+1 -1
View File
@@ -1099,7 +1099,7 @@ pub(crate) fn ask_displace_map(app: &mut PhotocraftApp, dialog: u64, command: St
use crate::file_dialog::{FileDialogAnswer, FileDialogRequest};
let doc = app.active_doc_id()?;
let initial_dir = crate::file_dialog::last_used_dir(&app.ui.recent_files);
app.ask_file(FileDialogRequest::Open { multiple: false, initial_dir, extensions: None, max_bytes: None }, move |app, answer| {
app.ask_file(FileDialogRequest::Open { multiple: false, initial_dir, extensions: None, max_bytes: None, max_contents_bytes: None }, move |app, answer| {
let path = match answer {
FileDialogAnswer::Paths(paths) => paths.into_iter().next().ok_or("no displacement map was chosen")?,
FileDialogAnswer::Unavailable(e) => return Err(e),
+9 -6
View File
@@ -98,12 +98,15 @@ fn browse(app: &mut PhotocraftApp, id: u64, folder: bool) {
})
} else {
let initial_dir = crate::file_dialog::last_used_dir(&app.ui.recent_files);
app.ask_file(FileDialogRequest::Open { multiple: true, initial_dir, extensions: None, max_bytes: None }, move |app, answer| {
let FileDialogAnswer::Paths(paths) = answer else { return Err("Load Files into Stack reads files from disk".into()) };
let d = app.ui.dialog_mut(id).ok_or("the dialog was closed")?;
add(&mut d.fields, paths);
Ok(Value::Null)
})
app.ask_file(
FileDialogRequest::Open { multiple: true, initial_dir, extensions: None, max_bytes: None, max_contents_bytes: None },
move |app, answer| {
let FileDialogAnswer::Paths(paths) = answer else { return Err("Load Files into Stack reads files from disk".into()) };
let d = app.ui.dialog_mut(id).ok_or("the dialog was closed")?;
add(&mut d.fields, paths);
Ok(Value::Null)
},
)
};
if let Err(e) = r.map(|_| ()).or_else(|e| if e == crate::file_dialog::CANCELLED { Ok(()) } else { Err(e) }) {
app.ui.status = e;
+5 -2
View File
@@ -32,6 +32,9 @@ pub enum FileDialogRequest {
extensions: Option<Vec<String>>,
/// Per-file limit: byte-producing services must check size before reading; consumers recheck.
max_bytes: Option<u64>,
/// Aggregate staged contents limit; byte-producing services preflight before any read.
/// Path-producing services do not stage payloads and leave this to the contents consumer.
max_contents_bytes: Option<u64>,
},
/// Which folder to read from. Starts in `initial_dir` when available.
Folder { initial_dir: Option<String> },
@@ -250,7 +253,7 @@ impl PhotocraftApp {
) -> Result<Value, String> {
let initial_dir = last_used_dir(&self.ui.recent_files);
let extensions = (!extensions.is_empty()).then(|| extensions.iter().map(|s| (*s).to_string()).collect());
self.ask_file(FileDialogRequest::Open { multiple: false, initial_dir, extensions, max_bytes: max }, move |app, answer| {
self.ask_file(FileDialogRequest::Open { multiple: false, initial_dir, extensions, max_bytes: max, max_contents_bytes: None }, move |app, answer| {
let (name, bytes) = read_picked(answer, max)?;
then(app, name, bytes)
})
@@ -259,7 +262,7 @@ impl PhotocraftApp {
/// File › Open: opens every chosen file, reporting each failure (see [`Self::open_paths`]).
pub fn open_dialog_file(&mut self) -> Result<Value, String> {
let initial_dir = last_used_dir(&self.ui.recent_files);
self.ask_file(FileDialogRequest::Open { multiple: true, initial_dir, extensions: None, max_bytes: None }, |app, answer| {
self.ask_file(FileDialogRequest::Open { multiple: true, initial_dir, extensions: None, max_bytes: None, max_contents_bytes: None }, |app, answer| {
match answer {
FileDialogAnswer::Paths(paths) => {
app.open_paths(&paths);
+2 -2
View File
@@ -378,7 +378,7 @@ fn open_starts_in_the_last_used_folder() {
menus::invoke(&mut app, &ctx, "file.open", json!({})).unwrap();
app.poll_file_dialog(&ctx, None);
assert!(
matches!(open.borrow().as_slice(), [(FileDialogRequest::Open { multiple: true, initial_dir: Some(dir), extensions: None, max_bytes: None }, _)] if dir == "/pics"),
matches!(open.borrow().as_slice(), [(FileDialogRequest::Open { multiple: true, initial_dir: Some(dir), extensions: None, max_bytes: None, max_contents_bytes: None }, _)] if dir == "/pics"),
"{:?}",
open.borrow().first().map(|(r, _)| r.clone())
);
@@ -1516,7 +1516,7 @@ fn picked_file_limit_refuses_before_callback_and_keeps_other_callers_unchanged()
app.pick_file_bytes_filtered(&["atn"], then).unwrap();
}
app.poll_file_dialog(&ctx, None);
assert!(matches!(open.borrow().as_slice(), [(FileDialogRequest::Open { max_bytes, .. }, _)] if *max_bytes == max));
assert!(matches!(open.borrow().as_slice(), [(FileDialogRequest::Open { max_bytes, max_contents_bytes: None, .. }, _)] if *max_bytes == max));
let bounded_path = max.is_some() && matches!(chosen, FileDialogAnswer::Paths(_));
answer(&open, Some(chosen));
app.poll_file_dialog(&ctx, None);
+25 -1
View File
@@ -558,10 +558,34 @@ fn load_source(app: &mut PhotocraftApp, name: &str, params: Value) -> Result<Val
Ok(r)
}
/// Bound browser selection staging to 512 MiB, separately from each preset file's input cap.
/// This does not bound parsed actions, transient copies or the whole process's memory.
const MAX_LOAD_CONTENTS_BYTES: u64 = 512 << 20;
/// Load every chosen action file in order, retaining failures and unsupported-step warnings.
fn load_dialog(app: &mut PhotocraftApp) -> Result<Value, String> {
load_dialog_with_limit(app, MAX_LOAD_CONTENTS_BYTES)
}
/// Carry the selection budget through the producer and recheck byte-producing custom services.
fn load_dialog_with_limit(app: &mut PhotocraftApp, max_contents_bytes: u64) -> Result<Value, String> {
let initial_dir = crate::file_dialog::last_used_dir(&app.ui.recent_files);
app.ask_file(FileDialogRequest::Open { multiple: true, initial_dir, extensions: Some(vec!["atn".into()]), max_bytes: None }, |app, answer| {
let request = FileDialogRequest::Open {
multiple: true,
initial_dir,
extensions: Some(vec!["atn".into()]),
max_bytes: None,
max_contents_bytes: Some(max_contents_bytes),
};
app.ask_file(request, move |app, answer| {
let total = match &answer {
FileDialogAnswer::Contents(_, bytes) => Some(bytes.len() as u64),
FileDialogAnswer::ContentsMany(files) => files.iter().try_fold(0u64, |sum, (_, bytes)| sum.checked_add(bytes.len() as u64)),
_ => Some(0), // Native paths are read one at a time, not staged as contents.
};
if total.is_none_or(|total| total > max_contents_bytes) {
return Err(format!("the selected files are larger than {max_contents_bytes} bytes or their total size is invalid"));
}
let files: Vec<_> = match answer {
FileDialogAnswer::Paths(paths) => paths.into_iter().map(|name| (name, None)).collect(),
FileDialogAnswer::Contents(name, bytes) => vec![(name, Some(bytes))],
+60 -1
View File
@@ -26,7 +26,9 @@ fn bulk_load_imports_every_chosen_action_file() {
load_dialog(&mut app).unwrap();
app.poll_file_dialog(&egui::Context::default(), None);
assert_eq!(app.session.actions.list.iter().map(|a| a.name.as_str()).collect::<Vec<_>>(), ["First", "Second"]);
assert!(matches!(asked.borrow().as_slice(), [FileDialogRequest::Open { multiple: true, extensions: Some(ext), .. }] if ext == &["atn"]));
assert!(
matches!(asked.borrow().as_slice(), [FileDialogRequest::Open { multiple: true, extensions: Some(ext), max_bytes: None, max_contents_bytes: Some(MAX_LOAD_CONTENTS_BYTES), .. }] if ext == &["atn"])
);
assert!(!app.file_dialog_open());
assert!(!app.ui.status_error, "{}", app.ui.status);
}
@@ -2032,3 +2034,60 @@ fn bulk_load_summary_counts_unsupported_steps_of_surviving_sets() {
assert_eq!(names, ["A", "B"]);
assert!(app.session.actions.list[0].steps.iter().any(|(id, _)| id == "actions.photoshopStep"));
}
/// Byte-producing providers must stay within the whole-selection budget before the first
/// set is parsed or replaced; exact-size single and multiple selections still import normally.
#[test]
fn bulk_load_rechecks_total_contents_before_importing_any_set() {
use crate::file_dialog::{FileDialogAnswer, FileDialogRequest};
let first = ("replacement.atn".to_string(), action_set_bytes("Shared", "Replacement"));
let last = ("later.atn".to_string(), action_set_bytes("Other", "Later"));
for multiple in [false, true] {
for allowed in [false, true] {
let total = first.1.len() as u64 + if multiple { last.1.len() as u64 } else { 0 };
let max = total - u64::from(!allowed);
let answer = if multiple {
FileDialogAnswer::ContentsMany(vec![first.clone(), last.clone()])
} else {
FileDialogAnswer::Contents(first.0.clone(), first.1.clone())
};
let (show, asked) = crate::file_dialog::fake(vec![Some(answer)]);
let mut app = PhotocraftApp::new(photocraft_engine::Session::new(), crate::Services { file_dialog: Some(show), ..Default::default() });
let mut original = Action::new("Original", vec![]);
original.set = Some("Shared".into());
app.session.actions.list.push(original);
app.ui.actions.selected = Some(0);
let before = app.session.actions.clone();
let panel = app.ui.actions.clone();
let journal = app.session.journal.clone();
load_dialog_with_limit(&mut app, max).unwrap();
app.poll_file_dialog(&egui::Context::default(), None);
assert!(matches!(asked.borrow().as_slice(), [FileDialogRequest::Open { max_bytes: None, max_contents_bytes: Some(limit), .. }] if *limit == max));
assert!(!app.file_dialog_open());
assert_eq!(app.ui.status_error, !allowed, "{}", app.ui.status);
if allowed {
let names: Vec<_> = app.session.actions.list.iter().map(|a| a.name.as_str()).collect();
assert_eq!(names, if multiple { vec!["Replacement", "Later"] } else { vec!["Replacement"] });
} else {
assert!(app.ui.status.contains("selected files"), "{}", app.ui.status);
assert_eq!(app.session.actions, before, "not even the first same-set replacement may run");
assert_eq!(app.ui.actions, panel);
assert_eq!(app.session.journal, journal);
}
}
}
}
/// Native path services do not retain a whole selection's payloads in the picker.
#[test]
fn bulk_load_contents_budget_does_not_limit_native_paths() {
use crate::file_dialog::FileDialogAnswer;
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("native.atn");
std::fs::write(&path, action_set_bytes("Native", "From disk")).unwrap();
let mut app = disk_app(vec![Some(FileDialogAnswer::Paths(vec![path.to_string_lossy().into_owned()]))]);
load_dialog_with_limit(&mut app, 0).unwrap();
app.poll_file_dialog(&egui::Context::default(), None);
assert!(!app.ui.status_error, "{}", app.ui.status);
assert_eq!(app.session.actions.list[0].name, "From disk");
}
+1
View File
@@ -227,6 +227,7 @@ fn choose_program(app: &mut PhotocraftApp) -> Result<Value, String> {
initial_dir: None,
extensions: if cfg!(windows) { Some(vec!["exe".into()]) } else { None },
max_bytes: None,
max_contents_bytes: None,
},
move |app, answer| {
let crate::file_dialog::FileDialogAnswer::Paths(paths) = answer else { return Err("Choose a local editor executable".into()) };