diff --git a/src/io_tasks.rs b/src/io_tasks.rs new file mode 100644 index 0000000..7ae5c03 --- /dev/null +++ b/src/io_tasks.rs @@ -0,0 +1,154 @@ +//! Background providers carry plain data and weak task identities, never a VM. +use endor_core::{VmError, WeakObjectRef}; +use std::{ + collections::HashMap, + fs::File, + io::Read, + sync::{ + Arc, Mutex, OnceLock, + atomic::{AtomicBool, AtomicUsize, Ordering}, + mpsc::{SyncSender, sync_channel}, + }, + thread, +}; + +const MAX_TEXT: usize = 1024 * 1024; +const MAX_ACTIVE: usize = 16; +const WORKERS: usize = 4; +const QUEUE: usize = 64; +type Completion = Result; + +#[derive(Debug, Default)] +struct Shared { + ready: Mutex>, + active: AtomicUsize, +} +#[derive(Clone, Debug, Default)] +pub struct Provider { + shared: Arc, +} +/// Only Task payloads own this lease. Provider threads hold just its flag. +#[derive(Debug)] +pub struct Lease { + shared: Arc, + task: WeakObjectRef, + cancelled: Arc, +} +impl Drop for Lease { + fn drop(&mut self) { + self.cancelled.store(true, Ordering::Release); + if let Ok(mut ready) = self.shared.ready.lock() { + ready.remove(&self.task); + } + self.shared.active.fetch_sub(1, Ordering::AcqRel); + } +} +struct Job { + path: String, + task: WeakObjectRef, + cancelled: Arc, + shared: Arc, +} +impl Provider { + pub fn submit( + &self, + task: WeakObjectRef, + path: String, + replacing: bool, + ) -> Result, VmError> { + self.shared + .active + .fetch_update(Ordering::AcqRel, Ordering::Acquire, |active| { + (active < MAX_ACTIVE + usize::from(replacing)).then_some(active + 1) + }) + .map_err(|_| VmError::ExecutionLimit("16 file tasks per runtime"))?; + let lease = Arc::new(Lease { + shared: self.shared.clone(), + task, + cancelled: Arc::new(AtomicBool::new(false)), + }); + let sender = pool().map_err(|_| VmError::InvalidArgument("file provider unavailable"))?; + sender + .try_send(Job { + path, + task, + cancelled: lease.cancelled.clone(), + shared: self.shared.clone(), + }) + .map_err(|_| VmError::ExecutionLimit("file provider queue full or unavailable"))?; + Ok(lease) + } + pub fn take_ready(&self) -> Result, VmError> { + Ok(self + .shared + .ready + .lock() + .map_err(|_| VmError::InvalidArgument("file mailbox poisoned"))? + .drain() + .collect()) + } +} +fn pool() -> Result<&'static SyncSender, &'static str> { + static POOL: OnceLock, String>> = OnceLock::new(); + POOL.get_or_init(|| { + let (sender, receiver) = sync_channel::(QUEUE); + let receiver = Arc::new(Mutex::new(receiver)); + for index in 0..WORKERS { + let receiver = receiver.clone(); + thread::Builder::new() + .name(format!("tessera-file-{index}")) + .spawn(move || { + loop { + let job = match receiver.lock() { + Ok(receiver) => receiver.recv(), + Err(_) => break, + }; + let Ok(job) = job else { + break; + }; + if job.cancelled.load(Ordering::Acquire) { + continue; + } + let result = read_text(&job.path); + if let Ok(mut ready) = job.shared.ready.lock() + && !job.cancelled.load(Ordering::Acquire) + { + ready.insert(job.task, result); + } + } + }) + .map_err(|error| error.to_string())?; + } + Ok(sender) + }) + .as_ref() + .map_err(|_| "file provider unavailable") +} +fn read_text(path: &str) -> Completion { + let read = || -> Result { + let metadata = std::fs::metadata(path).map_err(|error| error.to_string())?; + if !metadata.is_file() { + return Err("text source must be a regular file".into()); + } + if metadata.len() > MAX_TEXT as u64 { + return Err("text source exceeds 1 MiB".into()); + } + let file = File::open(path).map_err(|error| error.to_string())?; + if !file + .metadata() + .map_err(|error| error.to_string())? + .is_file() + { + return Err("text source must be a regular file".into()); + } + let mut bytes = Vec::new(); + file.take(MAX_TEXT as u64 + 1) + .read_to_end(&mut bytes) + .map_err(|error| error.to_string())?; + if bytes.len() > MAX_TEXT { + return Err("text source exceeds 1 MiB".into()); + } + String::from_utf8(bytes).map_err(|_| "text source must be UTF-8".into()) + }; + read() +} diff --git a/src/main.rs b/src/main.rs index 96521dc..d0a643f 100644 --- a/src/main.rs +++ b/src/main.rs @@ -12,6 +12,7 @@ mod endor_script; mod event_dispatch; mod events; mod geometry; +mod io_tasks; mod layout; mod mount; mod native_visual; diff --git a/src/tasks.rs b/src/tasks.rs index 2009f4d..85067ba 100644 --- a/src/tasks.rs +++ b/src/tasks.rs @@ -47,6 +47,10 @@ struct Task { due: Instant, callback: Option, state: State, + ready: bool, + text: Option>, + error: Option>, + lease: Option>, } impl ObjectPayload for Task { fn as_any(&self) -> &dyn std::any::Any { @@ -183,6 +187,8 @@ pub fn cancel_owner(cx: &mut NativeContext<'_>, owner: ObjectRef) -> Result<(), if task.state == State::Pending { task.state = State::Cancelled; task.callback = None; + task.lease = None; + task.text = None; cx.replace_payload(reference, task)?; } cx.dict_delete(scope, &key)?; @@ -192,6 +198,8 @@ pub fn cancel_owner(cx: &mut NativeContext<'_>, owner: ObjectRef) -> Result<(), #[derive(Debug)] struct After { + file: bool, + provider: crate::io_tasks::Provider, signature: endor_core::CallSignature, index: Index, desktop: ObjectRef, @@ -201,7 +209,7 @@ impl NativeCallable for After { Some(self.signature.clone()) } fn arity(&self) -> Option { - Some(endor_core::CallArity::exact(4)) + Some(self.signature.arity) } fn invoke(&self, cx: &mut NativeContext<'_>, args: &[Value]) -> Result { @@ -210,23 +218,29 @@ impl NativeCallable for After { "asynchronous work is forbidden during read-only rendering", )); } - let [owner, key, delay, callback] = args else { - return Err(invalid( - "ui.after requires owner, key, milliseconds and callback", - )); + let (owner, key, delay, callback) = match args { + [owner, key, delay, callback] => (owner, key, delay, Some(callback)), + [owner, key, path] if self.file => (owner, key, path, None), + _ => { + return Err(invalid( + "asynchronous request requires owner, key, delay/path and optional file callback", + )); + } }; let owner = object(owner)?; - let callback = object(callback)?; - if !cx.store().object(callback)?.payload().is_function() { - return Err(invalid("task callback must be a Function")); - } - if !cx - .store() - .call_arity(callback)? - .ok_or(invalid("task callback requires positional metadata"))? - .accepts(0) - { - return Err(invalid("task callback requires zero unbound parameters")); + let callback = callback.map(object).transpose()?; + if let Some(callback) = callback { + if !cx.store().object(callback)?.payload().is_function() { + return Err(invalid("task callback must be a Function")); + } + if !cx + .store() + .call_arity(callback)? + .ok_or(invalid("task callback requires positional metadata"))? + .accepts(0) + { + return Err(invalid("task callback requires zero unbound parameters")); + } } let Value::Text(key) = key else { return Err(invalid("task key must be text")); @@ -234,17 +248,28 @@ impl NativeCallable for After { if key.is_empty() || key.len() > 128 || key.chars().any(char::is_control) { return Err(invalid("invalid task key")); } - let Value::Number(delay) = delay else { - return Err(invalid( - "task delay must be an integer number of milliseconds", - )); + let (milliseconds, path) = if self.file { + let Value::Text(path) = delay else { + return Err(invalid("text path must be a String")); + }; + if path.is_empty() || path.len() > 4096 || path.contains('\0') { + return Err(invalid("invalid text path")); + } + (0, Some(path.clone())) + } else { + let Value::Number(delay) = delay else { + return Err(invalid( + "task delay must be an integer number of milliseconds", + )); + }; + let milliseconds = delay + .as_i64() + .filter(|delay| (0..=86_400_000).contains(delay)) + .ok_or(invalid( + "task delay must be 0..86400000 integer milliseconds", + ))?; + (milliseconds, None) }; - let milliseconds = delay - .as_i64() - .filter(|delay| (0..=86_400_000).contains(delay)) - .ok_or(invalid( - "task delay must be 0..86400000 integer milliseconds", - ))?; if !eligible(cx.store(), owner, self.desktop)? { return Err(invalid("task owner is closed or detached")); } @@ -282,10 +307,31 @@ impl NativeCallable for After { due: Instant::now() .checked_add(Duration::from_millis(milliseconds as u64)) .ok_or(invalid("task deadline overflow"))?, - callback: Some(callback), + callback, state: State::Pending, + ready: !self.file, + text: None, + error: None, + lease: None, })?; cx.attach_type(task, desktop_type(cx.store(), "Task", self.desktop)?)?; + if let Some(path) = path { + let replacing = previous + .map(|previous| { + cx.store() + .payload::(previous, "Task") + .map(|task| task.state == State::Pending && task.lease.is_some()) + }) + .transpose()? + .unwrap_or(false); + let lease = self + .provider + .submit(cx.store().downgrade(task)?, path, replacing)?; + let mut value = cx.store().payload::(task, "Task")?.clone(); + value.lease = Some(lease); + cx.replace_payload(task, value)?; + } + let task_scope = if let Some(scope) = existing_scope { scope } else { @@ -308,6 +354,8 @@ impl NativeCallable for After { if old.state == State::Pending { old.state = State::Cancelled; old.callback = None; + old.lease = None; + old.text = None; cx.replace_payload(previous, old)?; } } @@ -325,6 +373,8 @@ enum Query { Cancel, Status, Active, + Result, + Error, } #[derive(Debug)] struct Method { @@ -368,6 +418,19 @@ impl NativeCallable for Method { .into(), ), Query::Active => Value::Bool(active), + Query::Result => { + if !matches!(task.state, State::Running | State::Completed) || task.error.is_some() + { + return Err(invalid( + "task result is not available; inspect status and error", + )); + } + task.text + .as_ref() + .map(|text| Value::Text(text.to_string())) + .unwrap_or(Value::Nil) + } + Query::Error => Value::Text(task.error.as_deref().unwrap_or_default().into()), Query::Cancel => { if cx.store().is_read_only() { return Err(invalid( @@ -377,6 +440,8 @@ impl NativeCallable for Method { if pending { task.state = State::Cancelled; task.callback = None; + task.lease = None; + task.text = None; cx.replace_payload(reference, task.clone())?; if let Some(owner) = owner && current(cx.store(), owner, reference, &task)? @@ -395,12 +460,49 @@ impl NativeCallable for Method { pub struct Scheduler { index: Index, desktop: ObjectRef, + provider: crate::io_tasks::Provider, } impl Scheduler { /// Mutation boundaries collect unreachable owner/callback cycles before /// this weak lookup. Idle timer polling does not rescan the entire heap. pub fn poll(&self, vm: &mut Vm, limit: usize) -> Result { anyhow::ensure!((1..=MAX_READY).contains(&limit), "invalid task poll limit"); + // Provider threads only fill the mailbox. Only this VM worker updates + // managed payloads, and delivery below rechecks owner/key generation. + for (weak, completion) in self.provider.take_ready()? { + if let Some(reference) = vm.upgrade(weak)? { + let result = (|| -> Result<()> { + let mut task = vm.payload::(reference, "Task")?.clone(); + if task.state != State::Pending || task.lease.is_none() { + return Ok(()); + } + let owner = vm.upgrade(task.owner)?; + let active = (|| -> Result { + Ok(if let Some(owner) = owner { + eligible(vm.object_store(), owner, self.desktop)? + && current(vm.object_store(), owner, reference, &task)? + } else { + false + }) + })(); + if let Some(owner) = owner { + vm.release(owner)?; + } + if !active? { + return Ok(()); + } + task.ready = true; + match completion { + Ok(text) => task.text = Some(text.into()), + Err(error) => task.error = Some(error.into()), + } + vm.replace_payload(reference, task)?; + Ok(()) + })(); + vm.release(reference)?; + result?; + } + } let snapshot = self .index .lock() @@ -416,7 +518,7 @@ impl Scheduler { continue; }; let result = (|| -> Result<()> { - let task = vm.payload::(reference, "Task")?.clone(); + let mut task = vm.payload::(reference, "Task")?.clone(); if task.state != State::Pending { return Ok(()); } @@ -432,13 +534,19 @@ impl Scheduler { work += 1; return finish(vm, reference, State::Cancelled); } - if task.due > now { + if task.due > now || !task.ready { return Ok(()); } work += 1; - let callback = task - .callback - .ok_or_else(|| anyhow::anyhow!("pending task has no callback"))?; + if task.error.is_some() { + return finish(vm, reference, State::Failed); + } + let Some(callback) = task.callback else { + return finish(vm, reference, State::Completed); + }; + // The provider is finished. Keep the result in the Task, + // but release its I/O slot before running source callbacks. + task.lease = None; let mut running = task.clone(); running.state = State::Running; vm.replace_payload(reference, running)?; @@ -456,22 +564,18 @@ impl Scheduler { Ok(value) => { let unit = matches!(value, Value::Nil); vm.release_value(value)?; - finish( - vm, - reference, - if unit { - State::Completed - } else { - State::Failed - }, - )?; if !unit { + fail_callback( + vm, + reference, + "asynchronous callback must return Unit", + )?; bail!("asynchronous callback must return Unit"); } - Ok(()) + finish(vm, reference, State::Completed) } Err(error) => { - finish(vm, reference, State::Failed)?; + fail_callback(vm, reference, &format!("{error:#}"))?; Err(error) } } @@ -529,6 +633,13 @@ impl Scheduler { Ok(()) } } +fn fail_callback(vm: &mut Vm, reference: ObjectRef, message: &str) -> Result<()> { + let mut task = vm.payload::(reference, "Task")?.clone(); + task.error = Some(message.chars().take(1024).collect::().into()); + vm.replace_payload(reference, task)?; + finish(vm, reference, State::Failed) +} + fn finish(vm: &mut Vm, reference: ObjectRef, state: State) -> Result<()> { let mut task = vm.payload::(reference, "Task")?.clone(); if !matches!(task.state, State::Pending | State::Running) { @@ -536,6 +647,10 @@ fn finish(vm: &mut Vm, reference: ObjectRef, state: State) -> Result<()> { } task.state = state; task.callback = None; + task.lease = None; + if state == State::Cancelled { + task.text = None; + } vm.replace_payload(reference, task.clone())?; if let Some(owner) = vm.upgrade(task.owner)? { let result = (|| -> Result<()> { @@ -560,30 +675,51 @@ pub fn install( ) -> Result { let index = Arc::new(Mutex::new(Vec::new())); let definition = desktop_type(vm.object_store(), "Task", desktop)?; - let after = vm.allocate(ContextNativeFunction::new( - "after", - After { - signature: endor_core::CallSignature::exact( - vec![ - endor_core::AnnotationType::Any, - endor_core::AnnotationType::String, - endor_core::AnnotationType::Number, - endor_core::AnnotationType::Function, - ], - endor_core::AnnotationType::Nominal(definition), - endor_core::CallEffect::Mutating, - ), - index: index.clone(), - desktop, - }, - vec![desktop], - ))?; - roots.push(after); - vm.set_attr(ui, "after", Value::Object(after))?; + let provider = crate::io_tasks::Provider::default(); + for (name, file) in [("after", false), ("readText", true)] { + let function = vm.allocate(ContextNativeFunction::new( + name, + After { + file, + provider: provider.clone(), + signature: { + let mut signature = endor_core::CallSignature::exact( + vec![ + endor_core::AnnotationType::Any, + endor_core::AnnotationType::String, + if file { + endor_core::AnnotationType::String + } else { + endor_core::AnnotationType::Number + }, + endor_core::AnnotationType::Function, + ], + endor_core::AnnotationType::Nominal(definition), + if file { + endor_core::CallEffect::External + } else { + endor_core::CallEffect::Mutating + }, + ); + if file { + signature.arity = endor_core::CallArity::range(3, 4); + } + signature + }, + index: index.clone(), + desktop, + }, + vec![desktop], + ))?; + roots.push(function); + vm.set_attr(ui, name, Value::Object(function))?; + } for (name, query) in [ ("cancel", Query::Cancel), ("status", Query::Status), ("active", Query::Active), + ("result", Query::Result), + ("error", Query::Error), ] { let method = vm.allocate(ContextNativeFunction::new( name, @@ -592,10 +728,10 @@ pub fn install( desktop, signature: endor_core::CallSignature::exact( vec![endor_core::AnnotationType::Nominal(definition)], - if matches!(query, Query::Status) { - endor_core::AnnotationType::String - } else { - endor_core::AnnotationType::Bool + match query { + Query::Status | Query::Error => endor_core::AnnotationType::String, + Query::Result => endor_core::AnnotationType::Any, + _ => endor_core::AnnotationType::Bool, }, if matches!(query, Query::Cancel) { endor_core::CallEffect::Mutating @@ -609,5 +745,9 @@ pub fn install( roots.push(method); vm.define_method(definition, name, method)?; } - Ok(Scheduler { index, desktop }) + Ok(Scheduler { + index, + desktop, + provider, + }) }