text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>err!(
"journal restore error: failed to create remote connected socket - {err}"
)
})?;
Ok(())
}
}
<|fim_prefix|>use std::net::SocketAddr;
use wasmer_wasix_types::wasi::{Addressfamily, SockProto, Socktype};
use crate::{
fs::Kind,
net::s... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::net::Ipv4Addr;
use super::*;
impl JournalEffector {
pub fn save_sock_join_ipv4_multicast(
ctx: &mut FunctionEnvMut<'_, WasiEnv>,
fd: Fd,
multiaddr: Ipv4Addr,
iface: Ipv4Addr,
) -> anyhow::Result<()> {
Self::save_event(
ctx,
... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::net::Ipv6Addr;
use super::*;
impl JournalEffector {
pub fn save_sock_join_ipv<|fim_suffix|>ltiaddr}, iface={iface}) - {err}")
})?;
Ok(())
}
}
<|fim_middle|>6_multicast(
ctx: &mut FunctionEnvMut<'_, WasiEnv>,
fd: Fd,
multiaddr: Ipv6Addr,
... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>r.to_string()))
.map_err(|err| {
anyhow::format_err!(
"journal restore error: failed to leave ipv4 multicast (fd={fd}, multiaddr={multiaddr}, iface={iface}) - {err}")
})?;
Ok(())
}
}
<|fim_prefix|>use std::net::Ipv4Addr;
use super::*... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>asiEnv>,
fd: Fd,
multiaddr: Ipv6Addr,
iface: u32,
) -> anyhow::Result<()> {
crate::syscalls::sock_leave_multicast_v6_internal(ctx, fd, multiaddr, iface)
.map(|r| r.map_err(|err| err.to_string()))
.unwrap_or_else(|err| Err(err.to_string()))
... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use super::*;
impl JournalEffector {
pub fn save_sock_listen(
ctx: &mut FunctionEnvMut<'_, Wasi<|fim_suffix|> fd: Fd,
backlog: usize,
) -> anyhow::Result<()> {
Self::save_event(
ctx,
JournalEntry::SocketListenV1 {
fd,
... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use wasmer_wasix_types::wasi::{Addressfamily, SockProto, Socktype};
use super::*;
impl JournalEffector {
pub fn save_sock_open(
ctx: &mut FunctionEnvMut<'_, WasiEnv>,
af: Addressfamily,
ty: Socktype,
pt: SockProto,
fd: Fd,
) -> anyhow::Result<()> {
... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use super::*;
impl JournalEffector {
// Note: since the current implementation uses a pipe, we don't store the
// socket properties (domain, address family, etc.) in the journal.
// Once the sock_pair syscall is fixed, we should create a SocketPairV2
// entry that stores the socket proper... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use wasmer_wasix_<|fim_suffix|> .slice(&memory, sub)
.map_err(mem_error_to_wasi)?
.access()
.map_err(mem_error_to_wasi)?;
ctx.data()
.active_journal()?
.write(JournalEntry::SocketSendV1 {
... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use crate::syscalls::sock_send_file_internal;
use super::*;
impl JournalEffector {
pub fn save_sock_send_file<M: MemorySize>(
ctx: &mut FunctionEnvMut<'_, WasiEnv>,
socket_fd: Fd,
file_fd: Fd,
offset: Fi<|fim_suffix|>ize,
count: Filesize,
) -> anyhow::Resu... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::net::SocketAddr;
use wasmer_wasix_types::wasi::SiFlags;
use crate::syscalls::sock_send_to_internal;
use super::*;
impl JournalEffector {
pub fn save_sock_send_to<M: MemorySize>(
ctx: &FunctionEnvMut<'_, WasiEnv>,
fd: Fd,
sent: usize,
iovs: WasmPtr<__wasi_cio... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use wasmer_wasix_types::wasi::Sockoption;
use super::*;
impl JournalEffector {
pub fn save_sock_set_opt_flag(
ctx: &mut FunctionEnvMut<'_, WasiEnv>,
fd: Fd,
opt: Sockoption,
flag: bool,
) -> anyhow::Result<()> {
Self::save_event(ctx, JournalEntry::SocketSe... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use wasmer_wasix_types::wasi::Sockoption;
use super::*;
impl JournalEffector {
pub f<|fim_suffix|>pt={opt:?}, size={size}) - {err}"
)
})?;
Ok(())
}
}
<|fim_middle|>n save_sock_set_opt_size(
ctx: &mut FunctionEnvMut<'_, WasiEnv>,
fd: Fd,
... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>nyhow::format_err!(
"journal restore error: failed to set socket option (fd={fd}, opt={ty:?}, time={time:?}) - {err}"
)
})?;
Ok(())
}
}
<|fim_prefix|>use std::time::Duration;
use crate::n<|fim_middle|>et::socket::TimeType;
use super::*;
impl J... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::net::Shutdown;
use super::*;
impl JournalEffector {
pub fn save_sock_shutdown(
ctx: &mut FunctionEnvMut<'_, WasiEnv>,
fd: Fd,
shutdown: Shutdown,
) -> anyhow::Result<()> {
Self::save_event(
ctx,
JournalEntry::SocketShutdownV1 {
... | fim | wasmerio/wasmer | rust |
<|fim_suffix|><'_, WasiEnv>,
state: WasiTtyState,
) -> anyhow::Result<()> {
crate::syscalls::tty_set_internal(ctx, state).map_err(|err| {
anyhow::format_err!("journal restore error: failed to set tty - {err}")
})?;
Ok(())
}
}
<|fim_prefix|>use crate::WasiTtyState;
us... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use wasmer_wasix_types::wasi::Signal;
use super::*;
impl JournalEffector {
pub fn save_thread_exit(
env: &WasiEnv,
id: WasiThreadId,
<|fim_suffix|>ow::Result<()> {
env.active_journal()?
.write(JournalEntry::CloseThreadV1 {
id: id.raw(),
... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::sync::Arc;
use wasmer_wasix_types::wasix::ThreadStartType;
use crate::{
RewindState,
os::task::thread::{RewindResultType, WasiMemoryLayout},
syscalls::thread_spawn_internal_using_layout,
};
use super::*;
impl JournalEffector {
pub fn save_thread_state<M: MemorySize>(
c... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>#[derive(Debug,<|fim_suffix|>ne)]
pub struct JournalEffector {}
impl JournalEffector {}
<|fim_middle|> Clo<|endoftext|> | fim | wasmerio/wasmer | rust |
#[cfg(feature = "journal")]
mod effector;
#[cfg(not(feature = "journal"))]
#[path = "effector/unimplemented.rs"]
mod effector;
pub use effector::*;
pub use wasmer_journal::*;
<|endoftext|> | fim | wasmerio/wasmer | rust |
// FIXME: merge with ./lib.rs_upstream
#![allow(clippy::result_large_err)]
#![doc(html_favicon_url = "https://wasmer.io/images/icons/favicon-32x32.png")]
#![doc(html_logo_url = "https://github.com/wasmerio.png?size=200")]
#![cfg_attr(docsrs, feature(doc_cfg))]
//! Wasmer's WASI implementation
//!
//! Use `generate_im... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>//! Macros to simplify some common WASI-specific tasks.
/// Like the `try!` macro or `?` syntax: returns the value if the computation
/// succeeded or returns the error value.
macro_rules! wasi_try {
<|fim_suffix|>
macro_rules! get_input_str_ok {
($memory:expr, $data:expr, $len:expr) => {{ wasi_tr... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::{
mem::transmute,
net::{IpAddr, Ipv4Addr, Ipv6Addr},
time::Duration,
};
use virtual_net::{IpCidr, IpRoute, NetworkError};
use wasmer::{MemoryView, WasmPtr};
use wasmer_types::MemorySize;
use wasmer_wasix_types::{
types::{
__wasi_addr_ip4_t, __wasi_addr_ip6_t, __wasi_addr_... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::{
future::Future,
io,
mem::MaybeUninit,
net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
pin::Pin,
sync::{Arc, RwLock},
task::{Context, Poll},
time::Duration,
};
#[cfg(feature = "enable-serde")]
use serde_derive::{Deserialize, Serialize};
use virtual_mio::InterestHa... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::{any::Any, path::PathBuf, sync::Arc};
use crate::{
SpawnError,
bin_factory::spawn_exec_wasm,
os::task::{OwnedTaskStatus, TaskJoinHandle},
runtime::module_cache::HashedModuleData,
};
use shared_buffer::OwnedBuffer;
use virtual_fs::{AsyncRe<|fim_suffix|>tus::new_finished_with_code(... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>pub mod <|fim_suffix|><|fim_middle|>cmd_wasmer;
<|endoftext|> | fim | wasmerio/wasmer | rust |
<|fim_suffix|> Option<WasiEnv>,
) -> Result<TaskJoinHandle, SpawnError>;
}
#[derive(Debug, Clone)]
pub struct Commands {
commands: HashMap<String, Arc<dyn VirtualCommand + Send + Sync + 'static>>,
}
impl Commands {
fn new() -> Self {
Self {
commands: HashMap::new(),
}
}
... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>pub type Pid = u32;
pub fn is_mo<|fim_suffix|>("Open Mini")
|| user_agent.contains("IEMobile")
|| user_agent.contains("WPDesktop")
}
pub fn is_ssh(user_agent: &str) -> bool {
user_agent.contains("ssh")
}
<|fim_middle|>bile(user_agent: &str) -> bool {
user_agent.contains("Android"... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>= include_str!("txt/welcome_medium.txt");
pub const WELCOME_SMALL: &'static str = include_str!("txt/welcome_small.txt");
pub const ABOUT: &'static str = include_str!("txt/about.md");
pub const ABOUT_WASMER: &'static str = include_str!("txt/about_wasmer.md");
pub const HELP: &'static str =... | fim | wasmerio/wasmer | rust |
<|fim_suffix|> .unwrap();
assert_eq!(code.raw(), 78);
let mut out = String::new();
stdout_rx.read_to_string(&mut out).unwrap();
assert_eq!(out, "hello VAL1\n");
}
/// Regression test to ensure merging of multiple packages works correctly.
#[test]
#[ignore = "must b... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>//! Epoll runtime implementation for WASIX.
//!
//! This module centralizes epoll internals behind a small crate-internal API used
//! by `epoll_create`, `epoll_ctl`, and `epoll_wait`.
//!
//! ## Architecture
//!
//! The implementation uses:
//! - `EpollState`: global state for one epoll fd (`subscription... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>y::*;
<|fim_prefix|>pub mod common;
pub mod console;
pub(crate<|fim_middle|>) mod epoll;
pub mod tty;
pub mod command;
pub mod task;
pub use console::*;
pub use tt<|endoftext|> | fim | wasmerio/wasmer | rust |
<|fim_prefix|>pub const ERR_OK: u32 = 0;
pub const ERR_EPERM: u32 = 1; /* Operation not permitted */
pub const ERR_ENOENT: u32 = 2;
pub const ERR_ESRCH: u32 = 3; /* No such process */
pub const ERR_EINTR: u32 = 4; /* Interrupted system call */
pub const ERR_EIO: u32 = 5; /* I/O error */
pub const ERR_ENXIO: u32 = 6; /*... | fim | wasmerio/wasmer | rust |
use std::{
collections::HashMap,
pin::Pin,
sync::{
Arc,
atomic::{AtomicU32, Ordering},
},
task::{Context, Poll, Waker},
time::Duration,
};
use futures::{Future, FutureExt};
use wasmer_wasix_types::wasi::Snapshot0Clockid;
use crate::{VirtualTaskManager, WasiProcess, syscalls::pl... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::{
collections::HashMap,
sync::{
Arc, RwLock,
atomic::{AtomicUsize, Ordering},
},
time::Duration,
};
use crate::{WasiProcess, WasiProcessId};
use wasmer_types::ModuleHash;
#[derive(Debug, Clone)]
pub struct WasiControlPlane {
state: Arc<State>,
}
#[derive(Deb... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>//! OS task management for processes a<|fim_suffix|>rocess;
pub mod signal;
mod task_join_handle;
pub mod thread;
#[allow(unused_imports)]
pub(crate) use process::WasiProcessInner;
pub use task_join_handle::{
OwnedTaskStatus, TaskJoinHandle, TaskStatus, TaskTerminatedError, VirtualTaskHandle,
};
<|fi... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>f,
) -> std::pin::Pin<Box<dyn futures::Future<Output = ()> + Send + Sync>> {
use futures::Future;
use std::{
pin::Pin,
task::{Context, Poll},
};
struct Poller {
inner: LockableWasiProcessInner,
}
impl Future for Polle... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::{sync::Arc, time::Duration};
use wasmer_wasix_types::types::Signal;
#[derive(thiserror::Error, Debug)]
#[error("Signal could not be delivered")]
pub struct SignalDeliveryError;
/// Signal handles...well...they process signals
pub trait SignalHandlerAbi
where
Self: std::fmt::Debug,
{
//... | fim | wasmerio/wasmer | rust |
use std::{
pin::Pin,
sync::Arc,
task::{Context, Poll},
};
use wasmer_wasix_types::wasi::{Errno, ExitCode};
use crate::WasiRuntimeError;
use super::signal::{DynSignalHandlerAbi, default_signal_handler};
#[derive(Clone, Debug)]
pub enum TaskStatus {
Pending,
Running,
Finished(Result<ExitCode, ... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use super::{
control_plane::TaskCountGuard,
task_join_handle::{OwnedTaskStatus, TaskJoinHandle},
};
use crate::{
WasiRuntimeError,
os::task::process::{WasiProcessId, WasiProcessInner},
state::LinkError,
syscalls::HandleRewindType,
};
use bytes::{Bytes, BytesMut};
use serde::{Deseri... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::sync::{Arc, Mutex};
use futures::future::BoxFuture;
use virtual_fs::{AsyncWriteExt, NullFile, VirtualFile};
use wasmer_wasix_types::wasi::{Signal, Snapshot0Clockid};
use crate::syscalls::platform_clock_time_get;
use super::task::signal::SignalHandlerAbi;
const TTY_MOBILE_PAUSE: u128 = std::ti... | fim | wasmerio/wasmer | rust |
use super::TtyBridge;
use crate::WasiTtyState;
/// [`TtyBridge`] implementation for Unix systems.
#[derive(Debug, Default, Clone)]
pub struct SysTty;
impl TtyBridge for SysTty {
fn reset(&self) {
sys::reset().ok();
}
fn tty_get(&self) -> WasiTtyState {
let echo = sys::is_mode_echo();
... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::pin::Pin;
use bytes::Bytes;
use futures::Future;
use wasmer_wasix_types::{
wasi::Errno,
wasix::{ThreadStartType, WasiMemoryLayout},
};
<|fim_suffix|>ed at this point
pub trait RewindPostProcess {
/// Returns the serialized object that is returned on the rewind
fn finish(&mut self... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>
wasi_common::{
ExistingMountConflictBehavior, MAPPED_CURRENT_DIR_DEFAULT_PATH, MappedCommand,
MappedDirectory, MountedDirectory,
},
};
<|fim_prefix|>mod runner;
pub mod wasi;
mod wasi_comm<|fim_middle|>on;
pub use self::{
runner::Runner,<|endoftext|> | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::sync::Arc;
use anyhow::Error;
use webc::metadata::Command;
use crate::{Runtime, bin_factory::BinaryPackage};
/// Trait that all runners have to implement
pub trait Runner {
/// Returns whether the Runner wil<|fim_suffix|>
where
Self: Sized;
/// Run a command.
fn run_co... | fim | wasmerio/wasmer | rust |
//! WebC container support for running WASI modules
use std::{path::PathBuf, sync::Arc};
use anyhow::{Context, Error};
use tracing::Instrument;
use virtual_fs::{ArcBoxFile, FileSystem, VirtualFile};
use wasmer::{Engine, Module};
use wasmer_types::ModuleHash;
use webc::metadata::{Command, annotations::Wasi};
use crat... | fim | wasmerio/wasmer | rust |
<|fim_suffix|> async fn package_mount_paths_remain_writable() {
use virtual_fs::FileSystem;
let container = wasmer_package::utils::from_bytes(PYTHON).unwrap();
let pkg_mount = virtual_fs::WebcVolumeFileSystem::mount_all(&container);
let mount_fs = MountFileSystem::new();
mou... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>ng: DynVirtualNetworking) -> Self {
self.networking.replace(networking);
self
}
pub fn with_http_client(mut self, http_client: DynHttpClient) -> Self {
self.http_client.replace(http_client);
self
}
pub fn with_package_loader(
mut self,
pack... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use wasmer::{Engine, Module};
use crate::runtime::module_cache::{CacheError, ModuleCache, ModuleHash};
/// [`FallbackCache`] is a combinator for the [`ModuleCache`] trait that enables
/// the chaining of two caching strategies together, typically via
/// [`ModuleCache::with_fallback()`].
///
/// All ope... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::path::{Path, PathBuf};
use std::sync::Arc;
use tempfile::NamedTempFile;
use tokio::io::AsyncWriteExt;
use wasmer::{Engine, Module};
use crate::runtime::module_cache::{CacheError, ModuleCache, ModuleHash};
use crate::runtime::task_manager::tokio::TokioTaskManager;
/// A cache that saves modules... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>h::new(&wasm);
Self { hash, wasm }
}
/// Create new [`HashedModuleData`] from the given [`BinaryPackageCommand`](crate::bin_factory::BinaryPackageCommand).
///
/// This is very cheap, as the hash is already available in the command.
pub fn from_command(command: &BinaryPackageC... | fim | wasmerio/wasmer | rust |
<|fim_suffix|> Get a [`ModuleCache`] which should be good enough for most in-memory use
/// cases.
///
/// # Platform-specific Notes
///
/// This will use the [`ThreadLocalCache`] when running in the browser. Each
/// thread lives in a separate worker, so sharing compiled modules in the
/// browser requires using a cu... | fim | wasmerio/wasmer | rust |
use std::sync::Arc;
use wasmer_types::UserAbort;
/// Progress during module loading.
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum ModuleLoadProgress {
/// Module was found in local cache.
LocalCacheHit,
/// Module is being downloaded.
DownloadingModule(DownloadProgress),
/// Module artifact ... | fim | wasmerio/wasmer | rust |
<|fim_suffix|> let key = ModuleHash::from_bytes([0; _]);
cache.save(key, &engine, &module).await.unwrap();
let round_tripped = cache.load(key, &engine).await.unwrap();
let exports: Vec<_> = round_tripped
.exports()
.map(|export| export.name().to_string())
... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::{cell::RefCell, collections::HashMap};
use wasmer::{Engine, Module};
use crate::runtime::module_cache::{CacheError, ModuleCache};
use wasmer_types::ModuleHash;
std::thread_local! {
static CACHED_MODULES: RefCell<HashMap<(ModuleHash, String), Module>>
= RefCell::new(HashMap::new());... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::{fmt::Debug, ops::Deref, path::PathBuf};
use wasmer::{Engine, Module};
use wasmer_types::ModuleHash;
use crate::runtime::module_cache::{FallbackCache, progress::ModuleLoadProgressReporter};
/// A cache for compiled WebAssembly modules.
///
/// ## Deterministic ID
///
/// Implementations are en... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::{
collections::HashMap,
io::{ErrorKind, Read, Write as _},
path::PathBuf,
sync::{Arc, RwLock},
};
use anyhow::{Context, Error, bail};
use bytes::Bytes;
use http::{HeaderMap, Method};
use tempfile::NamedTempFile;
use url::Url;
use wasmer_package::{
package::WasmerPackageError,... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::{
collections::{BTreeMap, HashMap, HashSet},
path::{Path, PathBuf},
sync::Arc,
};
use anyhow::{Context, Error};
use futures::{StreamExt, TryStreamExt};
use once_cell::sync::OnceCell;
use petgraph::visit::EdgeRef;
use virtual_fs::{FileSystem, WebcVolumeFileSystem};
use wasmer_config::... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>pub mod builtin_loader;
mod load_package_tree;
mod types;
mod uns<|fim_suffix|>ckageLoader, types::to_module_hash, unsupported::UnsupportedPackageLoader,
};
<|fim_middle|>upported;
pub use self::{
builtin_loader::BuiltinPackageLoader, load_package_tree::load_package_tree,
types::Pa<|endoftext|> | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::{fmt::Debug, ops::Deref};
use anyhow::Error;
use webc::Container;
use crate::{
bin_factory::BinaryPackage,
runtime::resolver::{PackageSummary, Resolution},
};
pub fn to_module_hash(value: webc::metadata::AtomSignature) -> wasmer_types::ModuleHash {
match value {
webc::metad... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use anyhow::Error;
use webc::Container;
use crate::{
bin_factory::BinaryPackage,
runtime::{
package_loader::PackageLoa<|fim_suffix|>Clone, thiserror::Error)]
#[error("Loading of packages is not supported in this runtime (no PackageLoader configured)")]
struct Unsupported;
<|fim_middle|>de... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>ebc: "https://storage.googleapis.com/wapm-registry-prod/webc/wasmer/wasmer-pack-cli/0.6.0/wasmer-pack-cli-0.6.0.webc"
.parse()
.unwrap(),
webc_sha256: WebcHash::from_bytes([
126, 26, 221, 22, 64, 208, 3, 127, 246, ... | fim | wasmerio/wasmer | rust |
use anyhow::Context;
use wasmer_config::package::{PackageHash, PackageId, PackageSource};
use wasmer_package::utils::from_disk;
use crate::runtime::resolver::{
DistributionInfo, PackageInfo, PackageSummary, QueryError, Source, WebcHash,
};
/// A [`Source`] that knows how to query files on the filesystem.
#[derive... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::{
collections::{BTreeMap, HashMap, VecDeque},
fs::File,
path::{Path, PathBuf},
}<|fim_suffix|>:NoMatches {
query: package.clone(),
archived_versions: Vec::new(),
}),
PackageSource::Url(_) | PackageSource::Path(_) => E... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>
/// Parse a sha256 hash from a hex-encoded string.
pub fn parse_hex(hex_str: &str) -> Result<Self, hex::FromHexError> {
let mut hash = [0_u8; 32];
hex::decode_to_slice(hex_str, &mut hash)?;
Ok(Self(hash))
}
pub fn for_file(path: &Path) -> Result<Self, std::io::Err... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>mod backend_source;
mod filesystem_source;
mod in_memory_source;
mod inputs;
mod multi_source;
mod outputs;
mod resolve;
mod source;
pub(crate) mod utils;
mod web_source;
pub use self::{
backend_source::BackendSource,
filesystem_source::FileSystemSource,
in_memory_source::InMemorySource,
... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::sync::Arc;
use wasmer_config::package::PackageSource;
use crate::runtime::resolver::{PackageSummary, QueryError, Source};
/// A [`Source`] that works by querying multiple [`Source`]s in succession.
///
/// # Error Handling
///
/// A [`Source`] implementation can return certain non-fatal errors... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::{collections::BTreeMap, ops::Index, path::PathBuf};
use petgraph::{
graph::{DiGraph, NodeIndex},
visit::EdgeRef,
};
use wasmer_config::package::PackageId;
use crate::runtime::resolver::{DistributionInfo, PackageInfo};
#[derive(Debug, Clone)]
pub struct Resolution {
pub package: Res... | fim | wasmerio/wasmer | rust |
use std::{
collections::{BTreeMap, HashSet, VecDeque},
path::PathBuf,
};
use petgraph::{
graph::{DiGraph, NodeIndex},
visit::EdgeRef,
};
use semver::Version;
use wasmer_config::package::{PackageId, PackageSource};
use crate::runtime::resolver::{
DependencyGraph, ItemLocation, PackageInfo, PackageS... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>rce,
archived_versions: Vec<semver::Version>,
},
Timeout {
query: PackageSource,
},
Other {
query: PackageSource,
// Arc to make it cloneable
// Cloning is important for some use-cases.
error: Arc<anyhow::Error>,
},
}
impl QueryError {
... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::path::{Path, PathBuf};
use anyhow::Error;
use http::{HeaderMap, StatusCode};
use url::Url;
use crate::http::{HttpResponse, USER_AGENT};
/// Polyfill for [`Url::from_file_path()`] that works on `wasm32-unknown-unknown`.
pub(crate) fn url_from_file_path(path: impl AsRef<Path>) -> Option<Url> {
... | fim | wasmerio/wasmer | rust |
use std::{
io::Write,
path::{Path, PathBuf},
sync::Arc,
time::{Duration, SystemTime},
};
use anyhow::{Context, Error};
use http::Method;
use sha2::{Digest, Sha256};
use tempfile::NamedTempFile;
use url::Url;
use wasmer_config::package::{PackageHash, PackageId, PackageSource};
use wasmer_package::utils:... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>// TODO: should be behind a different , tokio specific feature flag.
#[cfg(feature = "sys-thread")]
pub mod tokio;
use std::ops::Deref;
use std::task::{Context, Poll};
use std::{pin::Pin, time::Duration};
use bytes::Bytes;
use derive_more::Debug;
use futures::future::BoxFuture;
use futures::{Future, Try... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::sync::Mutex;
use std::{num::NonZeroUsize, pin::Pin, sync::Arc, time::Duration};
use futures::{Future, future::BoxFuture};
use tokio::runtime::{Handle, Runtime};
use virtual_mio::block_on;
use crate::runtime::{SpawnType, task_manager::TaskWasmCallbacks};
use crate::{WasiFunctionEnv, os::task::th... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>//! Builder system for configuring a [`WasiState`] and creating it.
use std::{
collections::{HashMap, HashSet},
path::{Path, PathBuf},
sync::Arc,
};
use rand::RngExt;
use thiserror::Error;
use virtual_fs::{
ArcFile, FileSystem, FsError, MountFileSystem, RootFileSystemBuilder, VirtualFile... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>nt
let entrypoint_result = entrypoint.await;
// If that function returns, we need to resume the main context with an error
// Take the underlying error, or create a new error if the context returned a value
let entrypoint_result = entrypoint_result.map_or_e... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>#[cfg(feature = "journal")]
use crate::journal::{DynJournal, JournalEffector, SnapshotTrigger};
use crate::{
Runtime, VirtualTaskManager, WasiControlPlane, WasiEnvBuilder, WasiError, WasiFunctionEnv,
WasiResult, WasiRuntimeError, WasiStateCreationError, WasiThreadError, WasiVFork,
bin_factory:... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>&self,
store: &mut impl AsStoreMut,
module: &Module,
) -> Result<Imports, WasiError> {
let wasi_versions =
get_wasi_versions(module, false).ok_or(WasiError::UnknownWasiVersion)?;
let mut resolver = Imports::new();
for version in wasi_versions.iter()... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>rdMemory<'a> = &'a Memory;
/// This pointer provides global access to some instance handles
#[derive(Debug, Clone, Default)]
pub(crate) struct WasiInstanceHandlesPointer {
inner: Option<WasiModuleTreeHandles>,
}
impl WasiInstanceHandlesPointer {
pub fn get(&self) -> Option<&WasiModuleTreeHandles>... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>mod global;
mod thread_local;
#[cfg(any(feature = "sys", feature = "sys-minimal"))]
pub(crate) use global::*;
#[cfg(feature = "js")]
pub(crate) use thread_local::*;
use tracing::{error, trace};
use wasmer::{
AsStoreMut, AsStoreRef, Function, FunctionEnvMut, Global, Instance, Memory, MemoryView, Modu... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>is one provides
/// mutable access
pub(crate) struct WasiInstanceGuardMut<'a> {
// the order is very important as the first value is
// dropped before the reference count is dropped
borrow: RefMut<'static, WasiModuleTreeHandles>,
_pointer: &'a WasiInstanceHandlesPointer,
_inner: Rc<Ref... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::collections::HashMap;
use tracing::warn;
use wasmer::Module;
use super::LinkError;
#[derive(Debug, Clone)]
pub struct DylinkInfo {
pub mem_info: wasmparser::MemInfo,
pub needed: Vec<String>,
pub import_metadata: HashMap<(String, String), wasmparser::SymbolFlags>,
pub export_met... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::path::PathBuf;
use crate::SpawnError;
use virtual_fs::FsError;
use wasmer::{ExportError, ExternType, InstantiationError, MemoryError, RuntimeError};
use super::ModuleHandle;
#[derive(thiserror::Error, Debug)]
pub enum LinkError {
#[error("Cannot access linker through a dead instance group"... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>_self_from_extern(export).unwrap().clone(),
))
}
ty @ ExternType::Global(_) => {
let global = Global::get_self_from_extern(export).unwrap();
let value = match global.get(store) {
Value::I32(value) => value as u64,
... | fim | wasmerio/wasmer | rust |
<|fim_suffix|> .get_function(import.name())
.expect("Internal error: failed to get exported function")
.clone()
}
// We may be loading a module tree, and the instance from which... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>or: module {resolved_from:?} not loaded by this group")
});
let func = instance.exports.get_function(name).unwrap_or_else(|e| {
panic!("Internal error: failed to resolve exported function {name}: {e:?}")
});
self.place_in_function_table_at(store, func.clone(),... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::{
collections::HashMap,
sync::{Arc, Barrier},
};
use tracing::trace;
use wasmer::{AsStoreMut, FunctionEnv, Global, Instance, Memory, Table, Tag};
use crate::{WasiEnv, import_object_for_all_wasi_versions};
use super::{
DlModule, DlOperation, DylinkInfo, InProgressLinkState, InProgre... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::{collections::HashMap, path::PathBuf};
use derive_more::Debug;
use wasmer::{Function, FunctionType, Global, Module};
use super::{DylinkInfo, ModuleHandle};
#[derive(Debug)]
pub(super) enum PartiallyResolvedExport {
Function(Function),
Global(u64),
Tls {
// The offset relati... | fim | wasmerio/wasmer | rust |
<|fim_suffix|> // Put the name in the linker state - the actual DlModule must be
// constructed later by the instance group once table addresses are
// allocated for the module.
// TODO: allocate table here (at least logically)?
self.side_modules_by_name
.insert(module_nam... | fim | wasmerio/wasmer | rust |
<|fim_suffix|> .iter()
.map(|path| Cow::Borrowed(Path::new(path))),
);
let mut errors: Vec<(PathBuf, FsError)> = Vec::new();
for path in search_paths {
let full_path = path.join(module_path);
trace!(search_path = ?path, full_path = ?full_pat... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use std::cmp::{Ord, PartialEq, PartialOrd};
use tracing::trace;
use wasmer::{AsStoreMut, Memory, MemoryError};
const WASM_PAGE_SIZE: u32 = wasmer::WASM_PAGE_SIZE as u32;
struct AllocatedPage {
// The base_ptr is mutable, and will move forward as memory is allocated from the page.
base_ptr: u32,... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>// TODO: The linker *can* exist in the runtime, since technically, there's nothing that
// prevents us from having a non-WASIX linker. However, there is currently no use-case
// for a non-WASIX linker, so we'll refrain from making it generic for the time being.
//! Linker for loading and linking dynamic ... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>//! Shared dynamic-link state for every [`super::super::Linker`] clone.
//!
//! Owns [`LinkerState`] behind [`RwLock`], the topology [`TopologyCoordinator`], and the
//! `dl_operation_pending` [`AtomicBool`] used to coordinate [`LinkerShared::synchronize_link_operation`]
//! with followers. Prefer these h... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>//! Dynamic-linking (`Dl*`) synchronization for the WASIX [`super::Linker`].
//!
//! Instance groups run on different OS threads and share one [`super::LinkerState`] behind an
//! [`std::sync::RwLock`]. Operations that change “who exists” or “what every group must agree on”
//! must coordinate with both t... | fim | wasmerio/wasmer | rust |
<|fim_suffix|> }),
}
}
/// Grants the topology lease if idle; otherwise [`None`] (caller should retry after cooperation + backoff).
pub(super) fn try_acquire(&self) -> Option<TopologyToken> {
let mut guard = self.inner.gate.lock().unwrap_or_else(|e| e.into_inner());
if guard.ac... | fim | wasmerio/wasmer | rust |
use std::{fmt::Display, path::Path};
use wasmer::{Instance, Memory, SharedMemory, Table, TableType};
use super::{sync::LinkerShared, sync::TopologyToken};
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ModuleHandle(pub(super) u32);
impl From<ModuleHandle> for u32 {
fn from(handle... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use tracing::trace;
use<|fim_suffix|>Global, LinkError> {
let ExternType::Global(GlobalType { ty, mutability }) = import.ty() else {
return Err(LinkError::BadImport(
import.module().to_string(),
import.name().to_string(),
import.ty().clone(),
));
... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>
// Implementations of direct to FS calls so that we can easily change their implementation
impl WasiState {
pub(crate) fn fs_read_dir<P: AsRef<Path>>(
&self,
path: P,
) -> Result<virtual_fs::ReadDir, Errno> {
self.fs
.root_fs
.read_dir(path.as_ref()... | fim | wasmerio/wasmer | rust |
<|fim_suffix|>e_poll_events(pes: PollEventSet) -> PollEventIter {
PollEventIter { pes, i: 0 }
}
#[allow(dead_code)]
impl PollEventBuilder {
pub fn new() -> PollEventBuilder {
PollEventBuilder { inner: 0 }
}
pub fn add(mut self, event: PollEvent) -> PollEventBuilder {
self.inner |= even... | fim | wasmerio/wasmer | rust |
<|fim_prefix|>use super::*;
impl<'a> JournalSyscallPlayer<'a, '_> {
#[allow(clippy::result_large_err)]
pub(crate) unsafe fn action_close_thread(
&mut self,
id: u32,
exit_code: Option<ExitCode>,
differ_ethereal: Option<&mut Vec<JournalEntry<'a>>>,
) -> Result<(), WasiRuntimeE... | fim | wasmerio/wasmer | rust |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.