use std::any::{Any, TypeId};
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
use crate::{HostRegistry, Libraries, Limits, SnapshotError};
#[derive(Clone, Default)]
pub struct HostEnv {
resources: HashMap<TypeId, Rc<dyn Any>>,
}
impl HostEnv {
pub fn new() -> Self {
Self::default()
}
pub fn insert<T: 'static>(&mut self, resource: T) {
self.resources.insert(TypeId::of::<T>(), Rc::new(resource));
}
pub fn get<T: 'static>(&self) -> Option<&T> {
self.resources.get(&TypeId::of::<T>())?.downcast_ref()
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ResolverPolicy {
Pure,
External,
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum Resolved {
Source(Vec<u8>),
Binary(Vec<u8>),
Native(String),
NotFound(Vec<u8>),
}
pub trait ModuleResolver: 'static {
fn resolve(&self, name: &[u8]) -> Resolved;
}
type Output = Rc<RefCell<crate::host::Output>>;
type Warnings = Rc<RefCell<crate::host::Warnings>>;
type Entropy = Rc<RefCell<crate::host::Entropy>>;
#[derive(Clone, Default)]
pub struct HostCapabilities {
pub(crate) output: Option<Output>,
pub(crate) warnings: Option<Warnings>,
pub(crate) entropy: Option<Entropy>,
pub(crate) module_resolver: Option<(ResolverPolicy, Rc<dyn ModuleResolver>)>,
pub(crate) env: HostEnv,
pub filesystem: Option<std::sync::Arc<dyn crate::Filesystem>>,
pub stdio: Option<std::sync::Arc<dyn crate::Stdio>>,
pub clock: Option<std::sync::Arc<dyn crate::Clock>>,
pub civil: Option<std::sync::Arc<dyn crate::CivilTime>>,
pub environment: Option<std::sync::Arc<dyn crate::Environment>>,
pub process: Option<std::sync::Arc<dyn crate::Process>>,
}
impl HostCapabilities {
pub fn filesystem(mut self, capability: std::sync::Arc<dyn crate::Filesystem>) -> Self {
self.filesystem = Some(capability);
self
}
pub fn stdio(mut self, capability: std::sync::Arc<dyn crate::Stdio>) -> Self {
self.stdio = Some(capability);
self
}
pub fn clock(mut self, capability: std::sync::Arc<dyn crate::Clock>) -> Self {
self.clock = Some(capability);
self
}
pub fn civil(mut self, capability: std::sync::Arc<dyn crate::CivilTime>) -> Self {
self.civil = Some(capability);
self
}
pub fn environment(mut self, capability: std::sync::Arc<dyn crate::Environment>) -> Self {
self.environment = Some(capability);
self
}
pub fn process(mut self, capability: std::sync::Arc<dyn crate::Process>) -> Self {
self.process = Some(capability);
self
}
pub fn sandbox() -> Self {
Self::default()
}
pub fn output(mut self, sink: impl FnMut(&[u8]) + 'static) -> Self {
self.output = Some(Rc::new(RefCell::new(Box::new(sink))));
self
}
pub fn warnings(mut self, sink: impl FnMut(&[u8], bool) + 'static) -> Self {
self.warnings = Some(Rc::new(RefCell::new(Box::new(sink))));
self
}
pub fn entropy(mut self, source: impl FnMut() -> i64 + 'static) -> Self {
self.entropy = Some(Rc::new(RefCell::new(Box::new(source))));
self
}
pub fn module_resolver(
mut self,
policy: ResolverPolicy,
resolver: impl ModuleResolver,
) -> Self {
self.module_resolver = Some((policy, Rc::new(resolver)));
self
}
pub fn host_env(mut self, env: HostEnv) -> Self {
self.env = env;
self
}
pub fn env(&self) -> &HostEnv {
&self.env
}
}
#[derive(Clone)]
#[non_exhaustive]
pub struct Host {
pub(crate) iteration_profile: crate::IterationProfile,
pub registry: HostRegistry,
pub limits: Limits,
pub effect_domain: u64,
pub capabilities: HostCapabilities,
pub libraries: Libraries,
pub memory_error_policy: super::MemoryErrorPolicy,
pub native_panic_policy: super::NativePanicPolicy,
}
impl Host {
pub fn iteration_profile(mut self, profile: crate::IterationProfile) -> Self {
self.iteration_profile = profile;
self
}
pub fn native_panic_policy(mut self, policy: super::NativePanicPolicy) -> Self {
self.native_panic_policy = policy;
self
}
pub fn memory_error_policy(mut self, policy: super::MemoryErrorPolicy) -> Self {
self.memory_error_policy = policy;
self
}
pub fn libraries(mut self, libraries: Libraries) -> Self {
self.libraries = libraries;
self
}
pub(crate) fn restore_registry(
&self,
symbols: &[String],
) -> std::result::Result<HostRegistry, SnapshotError> {
let mut all = HostRegistry::new();
Libraries::ALL.register(&mut all);
let mut allowed = HostRegistry::new();
self.libraries.register(&mut allowed);
for symbol in symbols {
if all.native_slot(symbol).is_some() && allowed.native_slot(symbol).is_none() {
return Err(SnapshotError::UnknownHostSymbol);
}
}
let mut registry = self.registry.clone();
registry.fill_missing_natives(&allowed);
Ok(registry)
}
pub fn filesystem(mut self, capability: std::sync::Arc<dyn crate::Filesystem>) -> Self {
self.capabilities = self.capabilities.filesystem(capability);
self
}
pub fn stdio(mut self, capability: std::sync::Arc<dyn crate::Stdio>) -> Self {
self.capabilities = self.capabilities.stdio(capability);
self
}
pub fn clock(mut self, capability: std::sync::Arc<dyn crate::Clock>) -> Self {
self.capabilities = self.capabilities.clock(capability);
self
}
pub fn civil(mut self, capability: std::sync::Arc<dyn crate::CivilTime>) -> Self {
self.capabilities = self.capabilities.civil(capability);
self
}
pub fn environment(mut self, capability: std::sync::Arc<dyn crate::Environment>) -> Self {
self.capabilities = self.capabilities.environment(capability);
self
}
pub fn process(mut self, capability: std::sync::Arc<dyn crate::Process>) -> Self {
self.capabilities = self.capabilities.process(capability);
self
}
pub fn new(registry: HostRegistry) -> Self {
Self {
registry,
iteration_profile: crate::IterationProfile::default(),
limits: Limits::default(),
effect_domain: 1,
capabilities: HostCapabilities::default(),
libraries: Libraries::ALL,
memory_error_policy: super::MemoryErrorPolicy::default(),
native_panic_policy: super::NativePanicPolicy::default(),
}
}
pub fn limits(mut self, limits: Limits) -> Self {
self.limits = limits;
self
}
pub fn effect_domain(mut self, domain: u64) -> Self {
self.effect_domain = domain;
self
}
pub fn capabilities(mut self, capabilities: HostCapabilities) -> Self {
self.capabilities = capabilities;
self
}
pub fn host_env(mut self, env: HostEnv) -> Self {
self.capabilities = self.capabilities.host_env(env);
self
}
pub fn output(mut self, sink: impl FnMut(&[u8]) + 'static) -> Self {
self.capabilities = self.capabilities.output(sink);
self
}
pub fn warnings(mut self, sink: impl FnMut(&[u8], bool) + 'static) -> Self {
self.capabilities = self.capabilities.warnings(sink);
self
}
pub fn entropy(mut self, source: impl FnMut() -> i64 + 'static) -> Self {
self.capabilities = self.capabilities.entropy(source);
self
}
pub fn module_resolver(
mut self,
policy: ResolverPolicy,
resolver: impl ModuleResolver,
) -> Self {
self.capabilities = self.capabilities.module_resolver(policy, resolver);
self
}
}
impl Default for Host {
fn default() -> Self {
Self::new(HostRegistry::new())
}
}