System Components

fn create_vm(&self) -> LuaResult<VmData> {
    let runtime = KhronosRuntime::new(
        RuntimeCreateOpts {
            disable_task_lib: false,
            time_limit: Some(MAX_TEMPLATES_EXECUTION_TIME),
            give_time: TEMPLATE_GIVE_TIME
        },
        None,
        vfs::OverlayFS::new(&vec![
            vfs::EmbeddedFS::<BuiltinsPatches>::new().into(),
            vfs::EmbeddedFS::<Builtins>::new().into(),
            vfs::EmbeddedFS::<TemplatingTypes>::new().into(),
        ])
    )?;
    
    runtime.set_memory_limit(MAX_TEMPLATE_MEMORY_USAGE)?;
    
    Ok(VmData { state, runtime, kv_constraints, ratelimits })
}

pub fn get_vm_for(&self, id: Id) -> LuaResult<VmData> {
    let mut vms = self.vms.borrow_mut();
    if let Some(vm) = vms.get(&id) {
        return Ok(vm.clone());
    }
    
    let vm = self.create_vm()?;
    vms.insert(id, vm.clone());
    Ok(vm)
}

pub fn remove_vm_for(&self, id: Id) -> Result<(), crate::Error> {
    let cell_opt = self.vms.borrow_mut().remove(&id);
    
    if let Some(vm) = cell_opt {
        vm.runtime.mark_broken(true)?;
    }
    
    Ok(())
}

pub async fn dispatch_event(&self, id: Id, event: CreateEvent) -> mlua::Result<KhronosValue> {
    let tenant_state = self.vm_manager.worker_state().get_cached_tenant_state_for(id)?;
    
    if !tenant_state.events.contains(event.name()) {
        return Ok(KhronosValue::Null);
    }
    
    let vm_data = self.vm_manager.get_vm_for(id)?;
    
    if vm_data.runtime.is_broken() {
        return Err(mlua::Error::external("Lua VM to dispatch to is broken"));
    }
    
    let func = vm_data.runtime.eval_script("./builtins.templateloop")?;
    let provider = TemplateContextProvider::new(id, vm_data.clone());
    let context = vm_data.runtime.create_context(provider, event)?;
    
    match vm_data.runtime.call_in_scheduler::<_, KhronosValue>(func, context).await {
        Ok(result) => Ok(result),
        Err(e) => {
            tokio::task::spawn_local(async move {
                Self::log_error_to_main_server(&vm_data, err_str).await
            });
            Err(e)
        },
    }
}

pub fn dispatch_startup_events(&self) {
    let ids = self.vm_manager.worker_state().get_startup_event_tenants();
    for id in ids.iter() {
        let event = CreateEvent::new("OnStartup".to_string(), None, json!({
            "reason": "worker_startup"
        }));
        
        tokio::task::spawn_local(async move {
            self.dispatch_event(id, event).await
        });
    }
}

pub async fn run_script(&self, id: Id, name: String, code: String, event: CreateEvent) -> mlua::Result<KhronosValue> {
    let vm_data = self.vm_manager.get_vm_for(id)?;
    
    if vm_data.runtime.is_broken() {
        return Err(mlua::Error::external("Lua VM to dispatch to is broken"));
    }
    
    let func = vm_data.runtime.eval_chunk(&code, Some(&name), None)?;
    let provider = TemplateContextProvider::new(id, vm_data.clone());
    let context = vm_data.runtime.create_context(provider, event)?;
    
    vm_data.runtime.call_in_scheduler::<_, KhronosValue>(func, context).await
}