feat: deliver owner-scoped text file tasks through a bounded provider pool
This commit is contained in:
+154
@@ -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<String, String>;
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
struct Shared {
|
||||
ready: Mutex<HashMap<WeakObjectRef, Completion>>,
|
||||
active: AtomicUsize,
|
||||
}
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct Provider {
|
||||
shared: Arc<Shared>,
|
||||
}
|
||||
/// Only Task payloads own this lease. Provider threads hold just its flag.
|
||||
#[derive(Debug)]
|
||||
pub struct Lease {
|
||||
shared: Arc<Shared>,
|
||||
task: WeakObjectRef,
|
||||
cancelled: Arc<AtomicBool>,
|
||||
}
|
||||
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<AtomicBool>,
|
||||
shared: Arc<Shared>,
|
||||
}
|
||||
impl Provider {
|
||||
pub fn submit(
|
||||
&self,
|
||||
task: WeakObjectRef,
|
||||
path: String,
|
||||
replacing: bool,
|
||||
) -> Result<Arc<Lease>, 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<Vec<(WeakObjectRef, Completion)>, VmError> {
|
||||
Ok(self
|
||||
.shared
|
||||
.ready
|
||||
.lock()
|
||||
.map_err(|_| VmError::InvalidArgument("file mailbox poisoned"))?
|
||||
.drain()
|
||||
.collect())
|
||||
}
|
||||
}
|
||||
fn pool() -> Result<&'static SyncSender<Job>, &'static str> {
|
||||
static POOL: OnceLock<Result<SyncSender<Job>, String>> = OnceLock::new();
|
||||
POOL.get_or_init(|| {
|
||||
let (sender, receiver) = sync_channel::<Job>(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<String, String> {
|
||||
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()
|
||||
}
|
||||
@@ -12,6 +12,7 @@ mod endor_script;
|
||||
mod event_dispatch;
|
||||
mod events;
|
||||
mod geometry;
|
||||
mod io_tasks;
|
||||
mod layout;
|
||||
mod mount;
|
||||
mod native_visual;
|
||||
|
||||
+208
-68
@@ -47,6 +47,10 @@ struct Task {
|
||||
due: Instant,
|
||||
callback: Option<ObjectRef>,
|
||||
state: State,
|
||||
ready: bool,
|
||||
text: Option<Arc<str>>,
|
||||
error: Option<Arc<str>>,
|
||||
lease: Option<Arc<crate::io_tasks::Lease>>,
|
||||
}
|
||||
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<endor_core::CallArity> {
|
||||
Some(endor_core::CallArity::exact(4))
|
||||
Some(self.signature.arity)
|
||||
}
|
||||
|
||||
fn invoke(&self, cx: &mut NativeContext<'_>, args: &[Value]) -> Result<NativeResult, VmError> {
|
||||
@@ -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::<Task>(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, "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<usize> {
|
||||
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::<Task>(reference, "Task")?.clone();
|
||||
if task.state != State::Pending || task.lease.is_none() {
|
||||
return Ok(());
|
||||
}
|
||||
let owner = vm.upgrade(task.owner)?;
|
||||
let active = (|| -> Result<bool> {
|
||||
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::<Task>(reference, "Task")?.clone();
|
||||
let mut task = vm.payload::<Task>(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::<Task>(reference, "Task")?.clone();
|
||||
task.error = Some(message.chars().take(1024).collect::<String>().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::<Task>(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<Scheduler> {
|
||||
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,
|
||||
})
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user