use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use bytes::Bytes;
use tokio::sync::Semaphore;
use wasmtime::component::Linker;
use wasmtime::Engine;
use crate::cache;
use crate::kv::{KvStore, MemKv};
use crate::registry::{self, ComponentCache, Loaded, Lookup};
use crate::sandbox::{self, EpochTicker, Failure};
use crate::types::{valid_name, HostCtx};
use crate::{Error, InvokeError, Limits, MeterSink, PublishError, Usage};
const MIB: usize = 1024 * 1024;
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct RuntimeConfig {
pub modules_dir: PathBuf,
pub allow_private_egress: bool,
pub memory_budget_bytes: usize,
pub max_in_flight_per_tenant: usize,
pub max_output_bytes: usize,
pub component_cache_entries: usize,
pub component_cache_bytes: usize,
pub compile_concurrency: usize,
}
impl RuntimeConfig {
pub fn new(modules_dir: impl Into<PathBuf>) -> Self {
let cores = std::thread::available_parallelism().map_or(1, |n| n.get());
Self {
modules_dir: modules_dir.into(),
allow_private_egress: false,
memory_budget_bytes: 1024 * MIB,
max_in_flight_per_tenant: 32,
max_output_bytes: 8 * MIB,
component_cache_entries: 256,
component_cache_bytes: 512 * MIB,
compile_concurrency: (cores / 2).max(1),
}
}
}
#[must_use]
pub struct RuntimeBuilder {
cfg: RuntimeConfig,
kv: Option<Arc<dyn KvStore>>,
meter: Option<Arc<dyn MeterSink>>,
}
impl RuntimeBuilder {
pub fn kv(mut self, kv: Arc<dyn KvStore>) -> Self {
self.kv = Some(kv);
self
}
pub fn meter(mut self, sink: Arc<dyn MeterSink>) -> Self {
self.meter = Some(sink);
self
}
pub fn build(self) -> Result<Runtime, Error> {
let cfg = self.cfg;
if cfg.memory_budget_bytes < MIB {
return Err(Error::Config("memory_budget_bytes must be at least 1 MiB"));
}
if cfg.max_in_flight_per_tenant == 0 {
return Err(Error::Config("max_in_flight_per_tenant must be at least 1"));
}
if cfg.component_cache_entries == 0 {
return Err(Error::Config("component_cache_entries must be at least 1"));
}
if cfg.compile_concurrency == 0 {
return Err(Error::Config("compile_concurrency must be at least 1"));
}
std::fs::create_dir_all(&cfg.modules_dir)?;
let engine = sandbox::build_engine()?;
let linker = Arc::new(sandbox::build_linker(&engine)?);
let http_client = sandbox::build_http_client(cfg.allow_private_egress)
.map_err(|e| Error::Internal(format!("failed to build http client: {e}")))?;
let components = ComponentCache::new(
engine.clone(),
linker.clone(),
cfg.modules_dir.clone(),
cfg.component_cache_entries,
cfg.component_cache_bytes,
);
let ticker = EpochTicker::spawn(engine.clone())?;
Ok(Runtime(Arc::new(Inner {
admission: Arc::new(Semaphore::new(cfg.memory_budget_bytes / MIB)),
compile_slots: Arc::new(Semaphore::new(cfg.compile_concurrency)),
in_flight: Mutex::new(HashMap::new()),
kv: self.kv.unwrap_or_else(|| Arc::new(MemKv::new())),
meter: self.meter,
http_client,
components,
linker,
engine,
cfg,
_ticker: ticker,
})))
}
}
impl std::fmt::Debug for RuntimeBuilder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RuntimeBuilder")
.field("cfg", &self.cfg)
.field("custom_kv", &self.kv.is_some())
.field("meter", &self.meter.is_some())
.finish()
}
}
struct Inner {
cfg: RuntimeConfig,
engine: Engine,
linker: Arc<Linker<HostCtx>>,
kv: Arc<dyn KvStore>,
meter: Option<Arc<dyn MeterSink>>,
http_client: reqwest::Client,
components: ComponentCache,
admission: Arc<Semaphore>,
in_flight: Mutex<HashMap<String, usize>>,
compile_slots: Arc<Semaphore>,
_ticker: EpochTicker,
}
#[derive(Clone)]
pub struct Runtime(Arc<Inner>);
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct Staged {
pub digest: String,
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct Invocation {
pub output: Vec<u8>,
pub usage: Usage,
}
impl Runtime {
pub fn new(cfg: RuntimeConfig) -> Result<Self, Error> {
Self::builder(cfg).build()
}
pub fn builder(cfg: RuntimeConfig) -> RuntimeBuilder {
RuntimeBuilder {
cfg,
kv: None,
meter: None,
}
}
pub fn engine(&self) -> &Engine {
&self.0.engine
}
pub async fn stage(&self, wasm: Bytes) -> Result<Staged, PublishError> {
let inner = self.0.clone();
let permit = inner
.compile_slots
.clone()
.acquire_owned()
.await
.map_err(|_| {
PublishError::Registry(Error::Internal("compile semaphore closed".into()))
})?;
tokio::task::spawn_blocking(move || {
let _permit = permit;
let modules_dir = &inner.cfg.modules_dir;
let cwasm_dir = registry::cwasm_dir(modules_dir);
let (component, digest, fresh) = cache::compile(&inner.engine, &wasm, &cwasm_dir)
.map_err(|e| match e {
Error::Wasmtime(e) => PublishError::Compile(e),
other => into_publish_err(other),
})?;
sandbox::typecheck_component(&inner.linker, &component)
.map_err(PublishError::ImportMismatch)?;
if fresh {
cache::persist_cwasm(&component, &inner.engine, &cwasm_dir, &digest)
.map_err(into_publish_err)?;
} else if let Err(e) =
registry::touch(&cwasm_dir.join(cache::cache_file_name(&inner.engine, &digest)))
{
tracing::warn!(%digest, error = %e, "could not refresh .cwasm mtime");
}
registry::write_wasm_source(modules_dir, &digest, &wasm).map_err(into_publish_err)?;
Ok(Staged { digest })
})
.await
.map_err(|e| PublishError::Registry(Error::Internal(format!("stage task failed: {e}"))))?
}
pub async fn activate(
&self,
tenant: &str,
func: &str,
staged: &Staged,
) -> Result<(), PublishError> {
if !valid_name(tenant) || !valid_name(func) {
return Err(PublishError::InvalidName);
}
let inner = self.0.clone();
let (tenant, func, digest) = (tenant.to_owned(), func.to_owned(), staged.digest.clone());
tokio::task::spawn_blocking(move || {
registry::write_pointer(&inner.cfg.modules_dir, &tenant, &func, &digest)
})
.await
.map_err(|e| PublishError::Registry(Error::Internal(format!("activate task failed: {e}"))))?
.map_err(into_publish_err)
}
pub async fn active(&self, tenant: &str, func: &str) -> Result<Option<Staged>, PublishError> {
if !valid_name(tenant) || !valid_name(func) {
return Err(PublishError::InvalidName);
}
let inner = self.0.clone();
let (tenant, func) = (tenant.to_owned(), func.to_owned());
let digest = tokio::task::spawn_blocking(move || {
registry::read_pointer(&inner.cfg.modules_dir, &tenant, &func)
})
.await
.map_err(|e| PublishError::Registry(Error::Internal(format!("active task failed: {e}"))))?
.map_err(into_publish_err)?;
Ok(digest.map(|digest| Staged { digest }))
}
pub async fn deactivate(&self, tenant: &str, func: &str) -> Result<(), PublishError> {
if !valid_name(tenant) || !valid_name(func) {
return Err(PublishError::InvalidName);
}
let inner = self.0.clone();
let (tenant, func) = (tenant.to_owned(), func.to_owned());
tokio::task::spawn_blocking(move || {
registry::remove_pointer(&inner.cfg.modules_dir, &tenant, &func)
})
.await
.map_err(|e| {
PublishError::Registry(Error::Internal(format!("deactivate task failed: {e}")))
})?
.map_err(into_publish_err)
}
pub async fn activate_digest(
&self,
tenant: &str,
func: &str,
digest: &str,
) -> Result<(), PublishError> {
if !valid_name(tenant) || !valid_name(func) {
return Err(PublishError::InvalidName);
}
if !cache::is_valid_digest(digest) {
return Err(PublishError::Registry(Error::Corrupt(
"invalid digest: expected 64 lowercase hex characters".into(),
)));
}
if !registry::wasm_exists(&self.0.cfg.modules_dir, digest) {
return Err(PublishError::Registry(Error::NotFound(format!(
"no staged component with digest {digest}"
))));
}
self.activate(
tenant,
func,
&Staged {
digest: digest.to_owned(),
},
)
.await
}
pub async fn publish(
&self,
tenant: &str,
func: &str,
wasm: Bytes,
) -> Result<Staged, PublishError> {
if !valid_name(tenant) || !valid_name(func) {
return Err(PublishError::InvalidName);
}
let staged = self.stage(wasm).await?;
self.activate(tenant, func, &staged).await?;
Ok(staged)
}
pub async fn invoke(
&self,
tenant: &str,
func: &str,
input: Vec<u8>,
limits: &Limits,
) -> Result<Invocation, InvokeError> {
if !valid_name(tenant) || !valid_name(func) {
return Err(InvokeError::InvalidName);
}
validate_limits(limits)?;
let inner = self.0.clone();
let _slot = TenantSlot::acquire(&inner, tenant).ok_or(InvokeError::TenantBusy)?;
let weight = limits.mem_cap_bytes.div_ceil(MIB).max(1);
let weight = u32::try_from(weight)
.ok()
.filter(|w| (*w as usize) <= inner.cfg.memory_budget_bytes / MIB)
.ok_or(InvokeError::Overloaded)?;
let _admission = inner
.admission
.clone()
.try_acquire_many_owned(weight)
.map_err(|_| InvokeError::Overloaded)?;
let pre = {
let lookup = {
let inner = inner.clone();
let (t, f) = (tenant.to_owned(), func.to_owned());
tokio::task::spawn_blocking(move || inner.components.lookup(&t, &f))
.await
.map_err(|e| {
InvokeError::Load(Error::Internal(format!("resolve task failed: {e}")))
})?
.map_err(InvokeError::Load)?
};
match lookup {
Lookup::NotFound => return Err(InvokeError::NotFound),
Lookup::Hit(pre) => pre,
Lookup::Miss(digest) => {
let loaded = {
let (inner, digest) = (inner.clone(), digest.clone());
tokio::task::spawn_blocking(move || inner.components.load_existing(&digest))
.await
.map_err(|e| {
InvokeError::Load(Error::Internal(format!("load task failed: {e}")))
})?
.map_err(InvokeError::Load)?
};
match loaded {
Loaded::Ready(pre) => pre,
Loaded::NeedsCompile => {
let permit =
inner.compile_slots.clone().acquire_owned().await.map_err(
|_| {
InvokeError::Load(Error::Internal(
"compile semaphore closed".into(),
))
},
)?;
let inner = inner.clone();
tokio::task::spawn_blocking(move || {
let _permit = permit;
inner.components.get_or_load(&digest)
})
.await
.map_err(|e| {
InvokeError::Load(Error::Internal(format!(
"recompile task failed: {e}"
)))
})?
.map_err(InvokeError::Load)?
}
}
}
}
};
let ctx = HostCtx::new(
tenant.to_owned(),
func.to_owned(),
inner.kv.clone(),
limits.allowed_hosts.clone(),
inner.cfg.allow_private_egress,
inner.http_client.clone(),
limits.mem_cap_bytes,
);
let ticks = Arc::new(AtomicU64::new(0));
let started = Instant::now();
let mut meter = MeterGuard {
sink: inner.meter.as_deref(),
tenant,
func,
ticks: &ticks,
started,
done: false,
};
let run = sandbox::run(&pre, ctx, &input, limits.cpu_budget_ms, ticks.clone()).await;
let usage = Usage::new(
ticks.load(Ordering::Relaxed) * (sandbox::EPOCH_TICK_MS * 1000),
started.elapsed().as_micros() as u64,
run.mem_peak,
);
let limit = inner.cfg.max_output_bytes;
let result = match run.result {
Ok(output) if output.len() > limit => Err(InvokeError::OutputTooLarge { usage, limit }),
Ok(output) => Ok(Invocation { output, usage }),
Err(Failure::CpuBudget) => Err(InvokeError::CpuBudgetExceeded {
usage,
budget_ms: limits.cpu_budget_ms,
}),
Err(Failure::MemCap { cap_bytes }) => {
Err(InvokeError::MemoryCapExceeded { usage, cap_bytes })
}
Err(Failure::WallClock) => Err(InvokeError::WallClockTimeout { usage }),
Err(Failure::Trap(source)) => Err(InvokeError::GuestTrap { usage, source }),
};
meter.finish(usage, result.is_ok());
result
}
pub async fn gc(&self, grace: Duration) -> Result<usize, Error> {
let inner = self.0.clone();
tokio::task::spawn_blocking(move || {
registry::gc_unreferenced_blobs(&inner.cfg.modules_dir, &inner.engine, grace)
})
.await
.map_err(|e| Error::Internal(format!("gc task failed: {e}")))?
}
}
impl std::fmt::Debug for Runtime {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Runtime")
.field("modules_dir", &self.0.cfg.modules_dir)
.finish_non_exhaustive()
}
}
fn validate_limits(l: &Limits) -> Result<(), crate::ConfigError> {
use crate::types::{validate_cpu_budget_ms, validate_mem_cap_bytes};
validate_cpu_budget_ms(i64::try_from(l.cpu_budget_ms).unwrap_or(i64::MAX))?;
validate_mem_cap_bytes(i64::try_from(l.mem_cap_bytes).unwrap_or(i64::MAX))
}
fn into_publish_err(e: Error) -> PublishError {
match e {
Error::Io(e) => PublishError::Io(e),
other => PublishError::Registry(other),
}
}
struct TenantSlot {
inner: Arc<Inner>,
tenant: String,
}
impl TenantSlot {
fn acquire(inner: &Arc<Inner>, tenant: &str) -> Option<Self> {
let mut map = inner.in_flight.lock().unwrap_or_else(|p| p.into_inner());
match map.get_mut(tenant) {
Some(n) if *n >= inner.cfg.max_in_flight_per_tenant => return None,
Some(n) => *n += 1,
None => {
map.insert(tenant.to_owned(), 1);
}
}
Some(Self {
inner: inner.clone(),
tenant: tenant.to_owned(),
})
}
}
impl Drop for TenantSlot {
fn drop(&mut self) {
let mut map = self
.inner
.in_flight
.lock()
.unwrap_or_else(|p| p.into_inner());
if let Some(n) = map.get_mut(&self.tenant) {
*n -= 1;
if *n == 0 {
map.remove(&self.tenant);
}
}
}
}
struct MeterGuard<'a> {
sink: Option<&'a dyn MeterSink>,
tenant: &'a str,
func: &'a str,
ticks: &'a AtomicU64,
started: Instant,
done: bool,
}
impl MeterGuard<'_> {
fn finish(&mut self, usage: Usage, ok: bool) {
self.done = true;
if let Some(sink) = self.sink {
sink.record(self.tenant, self.func, usage, ok);
}
}
}
impl Drop for MeterGuard<'_> {
fn drop(&mut self) {
if self.done {
return;
}
if let Some(sink) = self.sink {
let usage = Usage::new(
self.ticks.load(Ordering::Relaxed) * (sandbox::EPOCH_TICK_MS * 1000),
self.started.elapsed().as_micros() as u64,
0,
);
sink.record(self.tenant, self.func, usage, false);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
const TEST_GUEST_WASM: &[u8] = include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/tests/fixtures/test_guest.wasm"
));
#[tokio::test]
async fn ticker_stops_after_last_clone_is_dropped() {
let dir = tempfile::tempdir().unwrap();
let rt = Runtime::new(RuntimeConfig::new(dir.path())).unwrap();
let stopped = rt.0._ticker.stop_flag();
let weak = Arc::downgrade(&rt.0);
let clone = rt.clone();
drop(rt);
assert!(!stopped.load(Ordering::Relaxed), "a clone is still alive");
assert!(weak.upgrade().is_some());
clone
.publish("t", "f", Bytes::from_static(TEST_GUEST_WASM))
.await
.unwrap();
clone
.invoke("t", "f", b"x".to_vec(), &Limits::default())
.await
.unwrap();
drop(clone);
assert!(stopped.load(Ordering::Relaxed), "ticker must stop");
assert!(weak.upgrade().is_none(), "no leaked Arc<Inner>");
}
#[tokio::test]
async fn cold_load_from_cwasm_does_not_wait_for_compile_permit() {
let dir = tempfile::tempdir().unwrap();
let mut cfg = RuntimeConfig::new(dir.path());
cfg.compile_concurrency = 1;
let first = Runtime::new(cfg.clone()).unwrap();
first
.publish("t", "f", Bytes::from_static(TEST_GUEST_WASM))
.await
.unwrap();
drop(first);
let rt = Runtime::new(cfg).unwrap();
let _held = rt.0.compile_slots.clone().acquire_owned().await.unwrap();
let out = tokio::time::timeout(
Duration::from_secs(10),
rt.invoke("t", "f", b"x".to_vec(), &Limits::default()),
)
.await
.expect("cold load queued behind the compile permit")
.unwrap();
assert_eq!(out.output, b"x");
}
}