Added epoll to WASIX

lib/cli/src/commands/run.rs

@@ -37,6 +37,7 @@ use wasmer_wasix::{
         module_cache::{CacheError, ModuleHash},
         package_loader::PackageLoader,
         resolver::{PackageSpecifier, QueryError},
+        task_manager::VirtualTaskManagerExt,
     },
     WasiError,
 };
@@ -104,21 +105,22 @@ impl Run {
             wasmer_vm::set_stack_size(self.stack_size.unwrap());
         }
 
+        let _guard = handle.enter();
         let (store, _) = self.store.get_store()?;
-        let runtime = self
-            .wasi
-            .prepare_runtime(store.engine().clone(), &self.env, handle)?;
+        let runtime =
+            self.wasi
+                .prepare_runtime(store.engine().clone(), &self.env, handle.clone())?;
 
         // This is a slow operation, so let's temporarily wrap the runtime with
         // something that displays progress
-        let monitoring_runtime = MonitoringRuntime::new(runtime, pb.clone());
+        let monitoring_runtime = Arc::new(MonitoringRuntime::new(runtime, pb.clone()));
+        let runtime: Arc<dyn Runtime + Send + Sync> = monitoring_runtime.runtime.clone();
+        let monitoring_runtime: Arc<dyn Runtime + Send + Sync> = monitoring_runtime;
 
         let target = self.input.resolve_target(&monitoring_runtime, &pb)?;
 
         pb.finish_and_clear();
 
-        let runtime: Arc<dyn Runtime + Send + Sync> = Arc::new(monitoring_runtime.runtime);
-
         let result = {
             match target {
                 ExecutableTarget::WebAssembly { module, path } => {
@@ -166,7 +168,7 @@ impl Run {
             .get_command(id)
             .with_context(|| format!("Unable to get metadata for the \"{id}\" command"))?;
 
-        let uses = self.load_injected_packages(&*runtime)?;
+        let uses = self.load_injected_packages(&runtime)?;
 
         if WcgiRunner::can_run_command(cmd.metadata())? {
             self.run_wcgi(id, pkg, uses, runtime)
@@ -183,16 +185,25 @@ impl Run {
     }
 
     #[tracing::instrument(level = "debug", skip_all)]
-    fn load_injected_packages(&self, runtime: &dyn Runtime) -> Result<Vec<BinaryPackage>, Error> {
+    fn load_injected_packages(
+        &self,
+        runtime: &Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<Vec<BinaryPackage>, Error> {
         let mut dependencies = Vec::new();
 
         for name in &self.wasi.uses {
             let specifier = PackageSpecifier::parse(name)
                 .with_context(|| format!("Unable to parse \"{name}\" as a package specifier"))?;
-            let pkg = runtime
-                .task_manager()
-                .block_on(BinaryPackage::from_registry(&specifier, runtime))
-                .with_context(|| format!("Unable to load \"{name}\""))?;
+            let pkg = {
+                let specifier = specifier.clone();
+                let inner_runtime = runtime.clone();
+                runtime
+                    .task_manager()
+                    .spawn_and_block_on(async move {
+                        BinaryPackage::from_registry(&specifier, inner_runtime.as_ref()).await
+                    })
+                    .with_context(|| format!("Unable to load \"{name}\""))?
+            };
             dependencies.push(pkg);
         }
 
@@ -461,17 +472,19 @@ impl PackageSource {
     /// internet.
     fn resolve_target(
         &self,
-        rt: &dyn Runtime,
+        rt: &Arc<dyn Runtime + Send + Sync>,
         pb: &ProgressBar,
     ) -> Result<ExecutableTarget, Error> {
         match self {
             PackageSource::File(path) => ExecutableTarget::from_file(path, rt, pb),
             PackageSource::Dir(d) => ExecutableTarget::from_dir(d, rt, pb),
             PackageSource::Package(pkg) => {
                 pb.set_message("Loading from the registry");
-                let pkg = rt
-                    .task_manager()
-                    .block_on(BinaryPackage::from_registry(pkg, rt))?;
+                let inner_pck = pkg.clone();
+                let inner_rt = rt.clone();
+                let pkg = rt.task_manager().spawn_and_block_on(async move {
+                    BinaryPackage::from_registry(&inner_pck, inner_rt.as_ref()).await
+                })?;
                 Ok(ExecutableTarget::Package(pkg))
             }
         }
@@ -544,23 +557,32 @@ enum ExecutableTarget {
 impl ExecutableTarget {
     /// Try to load a Wasmer package from a directory containing a `wasmer.toml`
     /// file.
-    fn from_dir(dir: &Path, runtime: &dyn Runtime, pb: &ProgressBar) -> Result<Self, Error> {
+    fn from_dir(
+        dir: &Path,
+        runtime: &Arc<dyn Runtime + Send + Sync>,
+        pb: &ProgressBar,
+    ) -> Result<Self, Error> {
         pb.set_message(format!("Loading \"{}\" into memory", dir.display()));
 
         let webc = construct_webc_in_memory(dir)?;
         let container = Container::from_bytes(webc)?;
 
         pb.set_message("Resolving dependencies");
-        let pkg = runtime
-            .task_manager()
-            .block_on(BinaryPackage::from_webc(&container, runtime))?;
+        let inner_runtime = runtime.clone();
+        let pkg = runtime.task_manager().spawn_and_block_on(async move {
+            BinaryPackage::from_webc(&container, inner_runtime.as_ref()).await
+        })?;
 
         Ok(ExecutableTarget::Package(pkg))
     }
 
     /// Try to load a file into something that can be used to run it.
     #[tracing::instrument(skip_all)]
-    fn from_file(path: &Path, runtime: &dyn Runtime, pb: &ProgressBar) -> Result<Self, Error> {
+    fn from_file(
+        path: &Path,
+        runtime: &Arc<dyn Runtime + Send + Sync>,
+        pb: &ProgressBar,
+    ) -> Result<Self, Error> {
         pb.set_message(format!("Loading from \"{}\"", path.display()));
 
         match TargetOnDisk::from_file(path)? {
@@ -573,7 +595,14 @@ impl ExecutableTarget {
                 let module_cache = runtime.module_cache();
                 let module_hash = ModuleHash::sha256(&wasm);
 
-                let module = match tasks.block_on(module_cache.load(module_hash, &engine)) {
+                let ret = {
+                    let module_cache = module_cache.clone();
+                    let engine = engine.clone();
+                    tasks.spawn_and_block_on(async move {
+                        module_cache.load(module_hash, &engine).await
+                    })
+                };
+                let module = match ret {
                     Ok(m) => m,
                     Err(e) => {
                         if !matches!(e, CacheError::NotFound) {
@@ -608,9 +637,11 @@ impl ExecutableTarget {
             TargetOnDisk::LocalWebc => {
                 let container = Container::from_disk(path)?;
                 pb.set_message("Resolving dependencies");
-                let pkg = runtime
-                    .task_manager()
-                    .block_on(BinaryPackage::from_webc(&container, runtime))?;
+
+                let inner_runtime = runtime.clone();
+                let pkg = runtime.task_manager().spawn_and_block_on(async move {
+                    BinaryPackage::from_webc(&container, inner_runtime.as_ref()).await
+                })?;
                 Ok(ExecutableTarget::Package(pkg))
             }
         }
@@ -784,13 +815,16 @@ fn get_exit_code(
 
 #[derive(Debug)]
 struct MonitoringRuntime<R> {
-    runtime: R,
+    runtime: Arc<R>,
     progress: ProgressBar,
 }
 
 impl<R> MonitoringRuntime<R> {
     fn new(runtime: R, progress: ProgressBar) -> Self {
-        MonitoringRuntime { runtime, progress }
+        MonitoringRuntime {
+            runtime: Arc::new(runtime),
+            progress,
+        }
     }
 }
 

lib/cli/src/commands/run/wasi.rs

@@ -28,7 +28,7 @@ use wasmer_wasix::{
             FileSystemSource, InMemorySource, MultiSource, PackageSpecifier, Source, WapmSource,
             WebSource,
         },
-        task_manager::tokio::TokioTaskManager,
+        task_manager::{tokio::TokioTaskManager, VirtualTaskManagerExt},
     },
     types::__WASI_STDIN_FILENO,
     wasmer_wasix_types::wasi::Errno,
@@ -169,10 +169,14 @@ impl Wasi {
         for name in &self.uses {
             let specifier = PackageSpecifier::parse(name)
                 .with_context(|| format!("Unable to parse \"{name}\" as a package specifier"))?;
-            let pkg = rt
-                .task_manager()
-                .block_on(BinaryPackage::from_registry(&specifier, &*rt))
-                .with_context(|| format!("Unable to load \"{name}\""))?;
+            let pkg = {
+                let inner_rt = rt.clone();
+                rt.task_manager()
+                    .spawn_and_block_on(async move {
+                        BinaryPackage::from_registry(&specifier, &*inner_rt).await
+                    })
+                    .with_context(|| format!("Unable to load \"{name}\""))?
+            };
             uses.push(pkg);
         }