deno.land / x / wasm@wasmer-sdk-v0.6.0 / src / options.rs
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269use std::{collections::BTreeMap, sync::Arc};
use anyhow::Context;use js_sys::Array;use virtual_fs::TmpFileSystem;use wasm_bindgen::{prelude::wasm_bindgen, JsCast, JsValue, UnwrapThrowExt};use wasmer_wasix::WasiEnvBuilder;
use crate::{runtime::Runtime, utils::Error, Directory, DirectoryInit, JsRuntime, StringOrBytes};
#[wasm_bindgen]extern "C" { /// A proxy for `Option<&Runtime>`. #[wasm_bindgen] pub(crate) type OptionalRuntime;
#[wasm_bindgen] type OptionalDirectories;}
#[wasm_bindgen(typescript_custom_section)]const TYPE_DEFINITIONS: &'static str = r#"/** * Common options used when running a WASIX program. */type CommonOptions = { /** Additional command-line arguments to be passed to the program. */ args?: string[]; /** Environment variables to set. */ env?: Record<string, string>; /** The standard input stream. */ stdin?: string | Uint8Array; /** * Directories that should be mounted inside the WASIX instance. * * This maps mount locations to the {@link Directory} being mounted. As a * shortcut, if {@link DirectoryInit} is provided, a new {@link Directory} * will be instantiated and mounted. * * Avoid mounting directly to `"/"` as it may clobber a package's bundled * files. */ mount?: Record<string, DirectoryInit | Directory>;};
/** * Configuration used when starting a WASIX program with {@link runWasix}. */export type RunOptions = CommonOptions & { /** The name of the program being run (passed in as arg 0) */ program?: string; /** * The WASIX runtime to use. * * Providing a `Runtime` allows multiple WASIX instances to share things * like caches and threadpools. If not provided, a default `Runtime` will be * created. */ runtime?: Runtime;};
/** * Options used when running a command from a WASIX package with * {@link Command.run}. */export type SpawnOptions = CommonOptions & { /** * Packages that should also be loaded into the WASIX environment. */ uses?: string[];}"#;
#[wasm_bindgen]extern "C" { #[wasm_bindgen(typescript_type = "CommonOptions", extends = js_sys::Object)] pub type CommonOptions;
#[wasm_bindgen(method, getter)] fn args(this: &CommonOptions) -> Option<Array>;
#[wasm_bindgen(method, getter)] fn env(this: &CommonOptions) -> JsValue;
#[wasm_bindgen(method, getter)] fn stdin(this: &CommonOptions) -> Option<StringOrBytes>;
#[wasm_bindgen(method, getter)] fn mount(this: &CommonOptions) -> OptionalDirectories;}
impl CommonOptions { pub(crate) fn parse_args(&self) -> Result<Vec<String>, Error> { match self.args() { Some(args) => crate::utils::js_string_array(args), None => Ok(Vec::new()), } }
pub(crate) fn parse_env(&self) -> Result<BTreeMap<String, String>, Error> { match self.env().dyn_ref() { Some(env) => { let vars = crate::utils::js_record_of_strings(env)?; Ok(vars.into_iter().collect()) } None => Ok(BTreeMap::new()), } }
pub(crate) fn read_stdin(&self) -> Option<Vec<u8>> { self.stdin().map(|s| s.as_bytes()) }
pub(crate) fn mounted_directories(&self) -> Result<Vec<(String, Directory)>, Error> { let Ok(obj) = self.mount().dyn_into::<js_sys::Object>() else { return Ok(Vec::new()); };
let entries = crate::utils::object_entries(&obj)?; let mut mounted_directories = Vec::new();
for (key, value) in &entries { let key = String::from(key.clone());
// Note: the value is a `Directory | DirectoryInit`
let value = if let Ok(dir) = Directory::try_from(value) { dir } else if value.is_object() { // looks like we were given parameters for initializing a // Directory and need to call the constructor ourselves let init: &DirectoryInit = value.unchecked_ref(); Directory::new(Some(init.clone()))? } else { unreachable!(); }; mounted_directories.push((key, value)); }
Ok(mounted_directories) }}
impl Default for CommonOptions { fn default() -> Self { // Note: all fields are optional, so it's fine to use an empty object. CommonOptions { obj: js_sys::Object::new(), } }}
#[wasm_bindgen]extern "C" { #[wasm_bindgen(typescript_type = "RunOptions", extends = CommonOptions)] #[derive(Default)] pub type RunOptions;
#[wasm_bindgen(method, getter)] pub(crate) fn program(this: &RunOptions) -> JsValue;
#[wasm_bindgen(method, getter)] pub(crate) fn runtime(this: &RunOptions) -> OptionalRuntime;
}
impl RunOptions { /// Propagate any provided options to the [`WasiEnvBuilder`], returning /// streams that can be used for stdin/stdout/stderr. pub(crate) fn configure_builder( &self, builder: &mut WasiEnvBuilder, ) -> Result< ( Option<web_sys::WritableStream>, web_sys::ReadableStream, web_sys::ReadableStream, ), Error, > { for arg in self.parse_args()? { builder.add_arg(arg); }
for (key, value) in self.parse_env()? { builder.add_env(key, value); }
let stdin = match self.read_stdin() { Some(stdin) => { let f = virtual_fs::StaticFile::new(stdin); builder.set_stdin(Box::new(f)); None } None => { let (f, stdin) = crate::streams::input_pipe(); builder.set_stdin(Box::new(f)); Some(stdin) } };
let (stdout_file, stdout) = crate::streams::output_pipe(); builder.set_stdout(Box::new(stdout_file));
let (stderr_file, stderr) = crate::streams::output_pipe(); builder.set_stderr(Box::new(stderr_file));
let fs = self.filesystem()?; builder.set_fs(Box::new(fs)); builder.add_preopen_dir("/")?;
Ok((stdin, stdout, stderr)) }
pub(crate) fn filesystem(&self) -> Result<TmpFileSystem, Error> { let root = TmpFileSystem::new();
for (dest, fs) in self.mounted_directories()? { tracing::trace!(%dest, ?fs, "Mounting directory");
let fs = Arc::new(fs) as Arc<_>; root.mount(dest.as_str().into(), &fs, "/".into()) .with_context(|| format!("Unable to mount to \"{dest}\""))?; }
tracing::trace!(?root, "Initialized the filesystem");
Ok(root) }}
impl OptionalRuntime { pub(crate) fn as_runtime(&self) -> Option<JsRuntime> { let js_value: &JsValue = self.as_ref();
if js_value.is_undefined() { None } else { let rt = JsRuntime::try_from(js_value).expect_throw("Expected a runtime"); Some(rt) } }
/// Use [`OptionalRuntime::as_runtime()`] to resolve the instance, getting /// a reference to the global [`Runtime`] if one wasn't provided. pub(crate) fn resolve(&self) -> Result<JsRuntime, Error> { match self.as_runtime() { Some(rt) => Ok(rt), None => Runtime::lazily_initialized().map(JsRuntime::from), } }}
#[wasm_bindgen]extern "C" { #[wasm_bindgen(typescript_type = "SpawnOptions", extends = CommonOptions)] #[derive(Default)] pub type SpawnOptions;
#[wasm_bindgen(method, getter)] pub(crate) fn command(this: &SpawnOptions) -> JsValue;
#[wasm_bindgen(method, getter)] pub(crate) fn uses(this: &SpawnOptions) -> Option<js_sys::Array>;
#[wasm_bindgen(method, getter)] pub(crate) fn runtime(this: &SpawnOptions) -> OptionalRuntime;}
wasm
Version Info
4 months ago
