Struct WarmPool 

pub struct WarmPool { /* private fields */ }

A pre-warmed pool of ready-to-use MicroVMs.

The pool maintains min_idle VMs in Ready state. When a VM is acquired, the pool spawns a replacement in the background. Idle VMs that exceed idle_ttl_secs are automatically evicted.

Usage

let pool = WarmPool::start(pool_config, box_config, emitter).await?;
let vm = pool.acquire().await?;  // Instant if pool has capacity
// ... use vm ...
pool.release(vm).await?;         // Return to pool or destroy
pool.drain().await?;             // Graceful shutdown

Implementations

impl WarmPool

pub async fn start( config: PoolConfig, box_config: BoxConfig, event_emitter: EventEmitter, ) -> Result<Self>

Create and start the warm pool.

Spawns min_idle VMs in the background and starts the replenishment/eviction loop.

pub async fn start_with_metrics( config: PoolConfig, box_config: BoxConfig, event_emitter: EventEmitter, metrics: Option<RuntimeMetrics>, ) -> Result<Self>

Create and start the warm pool with an optional shared metrics sink.

The sink is installed before the initial fill so the first pre-warmed VMs contribute boot, cache, and pool metrics. Self::start remains the compatibility entry point for callers that do not need metrics.

pub async fn start_with_metrics_and_boot_limiter( config: PoolConfig, box_config: BoxConfig, event_emitter: EventEmitter, metrics: Option<RuntimeMetrics>, global_boot_limiter: Option<Arc<Semaphore>>, ) -> Result<Self>

Create and start the warm pool with optional metrics and a shared daemon-wide boot limiter.

max_concurrent_boots still limits each pool independently. When a shared limiter is supplied, it additionally caps aggregate boots across all pools that use it (for example, a multi-image pool daemon).

pub async fn start_with_metrics_and_boot_limiter_first_ready( config: PoolConfig, box_config: BoxConfig, event_emitter: EventEmitter, metrics: Option<RuntimeMetrics>, global_boot_limiter: Option<Arc<Semaphore>>, ) -> Result<Self>

Create a warm pool with one ready VM on the critical path.

This is intended for lazy, multi-image daemons: the first request for a new pool can run as soon as one VM is ready while the maintenance loop fills the remaining min_idle capacity in the background. The regular Self::start_with_metrics_and_boot_limiter API keeps its eager-fill behavior for explicit pool startup.

pub fn set_metrics(&mut self, metrics: RuntimeMetrics)

Attach Prometheus metrics to this pool.

pub async fn acquire(&self) -> Result<VmManager>

Acquire a ready VM from the pool.

If an idle VM is available, returns it immediately. Otherwise, boots a new VM on demand (slower path).

pub async fn release(&self, vm: VmManager) -> Result<()>

Release a VM back to the pool.

If the pool is at capacity, the VM is destroyed instead.

pub async fn stats(&self) -> PoolStats

Get current pool statistics.

pub async fn idle_count(&self) -> usize

Get the number of idle VMs currently in the pool.

pub fn signal_shutdown(&self)

Signal the pool to shutdown. This signals the background task to stop replenishing and sets the shutdown flag. VMs will continue to exist until the pool is drained or dropped.

pub async fn drain(&mut self) -> Result<()>

Gracefully drain all VMs and stop the pool.

pub async fn drain_idle(&self) -> Result<()>

Destroy all idle VMs without consuming the pool (&self), so it can be shut down from behind an Arc (e.g. a daemon serving concurrent requests). This method signals and joins the background replenisher before taking the idle snapshot, then tears down VMs with bounded concurrency.