mod config;
mod pool;
mod session;
mod snapshot;
mod wire;
use std::sync::{Arc, Mutex};
use std::time::Duration;
use tokio_util::sync::CancellationToken;
use crate::engine::{EngineControl, EngineFuture, VmEngine};
use crate::model::{ExecutionStartInput, IsolationStatus, IsolationWarmupInput, ProviderError};
use crate::registry::EventSink;
pub struct NativeVzEngine {
configured_bundle: Mutex<Option<String>>,
snapshot_restore: Mutex<bool>,
pool: pool::NativeVmPool,
}
impl NativeVzEngine {
pub fn from_environment() -> Self {
Self {
configured_bundle: Mutex::new(std::env::var("APOC_EXECUTOR_VM_BUNDLE").ok()),
snapshot_restore: Mutex::new(false),
pool: pool::NativeVmPool::new(),
}
}
fn configured_bundle(&self) -> Option<String> {
self.configured_bundle.lock().unwrap().clone()
}
fn snapshot_restore(&self) -> bool {
*self.snapshot_restore.lock().unwrap()
}
fn status_for(&self, reference: Option<&str>) -> Result<IsolationStatus, ProviderError> {
let mut status = match reference {
Some(reference) => config::ResolvedLaunch::status(reference, self.snapshot_restore())?,
None => IsolationStatus::uninitialized(),
};
let pool = self.pool.status();
status.idle_drain_seconds = Some(self.pool.idle_drain_seconds());
status.drained = Some(pool.idle == 0 && pool.in_flight == 0);
status.pool = Some(pool);
Ok(status)
}
}
impl VmEngine for NativeVzEngine {
fn status(&self) -> Result<IsolationStatus, ProviderError> {
let reference = self.configured_bundle();
self.status_for(reference.as_deref())
}
fn warmup<'a>(
&'a self,
request: IsolationWarmupInput,
) -> EngineFuture<'a, Result<IsolationStatus, ProviderError>> {
Box::pin(async move {
let configured = self.configured_bundle();
let reference = request
.vm_bundle
.as_deref()
.or(configured.as_deref())
.ok_or_else(|| {
ProviderError::new(
"IMAGE_UNAVAILABLE",
"Set APOC_EXECUTOR_VM_BUNDLE or pass vm_bundle",
)
})?;
let mut launch = config::ResolvedLaunch::resolve(
&ExecutionStartInput {
protocol_version: 1,
request_id: "__apoc_pool_warmup__".to_string(),
argv: vec!["/bin/true".to_string()],
shell: false,
cwd: Some("/".to_string()),
env: Vec::new(),
tty: false,
timeout_ms: Some(request.timeout_ms.max(1)),
image_ref: Some(reference.to_string()),
vm_bundle: None,
workspace: None,
memory_mb: None,
cpu_count: None,
pids_max: None,
network: Some("none".to_string()),
exports: Vec::new(),
},
configured.as_deref(),
)?;
self.pool.configure(
request.pool_size,
launch.memory_mb,
request.max_pool_memory_mb,
request.idle_drain_seconds,
);
launch.set_snapshot_restore(request.snapshot_restore);
*self.configured_bundle.lock().unwrap() = Some(reference.to_string());
*self.snapshot_restore.lock().unwrap() = request.snapshot_restore;
if request.snapshot_restore {
session::ensure_snapshot(&launch, &CancellationToken::new()).await?;
}
self.pool
.warmup(launch, Duration::from_millis(request.timeout_ms.max(1)))
.await?;
self.status()
})
}
fn drain(&self) -> EngineFuture<'_, Result<IsolationStatus, ProviderError>> {
Box::pin(async move {
self.pool.drain().await?;
self.status()
})
}
fn launch<'a>(
&'a self,
request: ExecutionStartInput,
events: EventSink,
cancellation: CancellationToken,
) -> EngineFuture<'a, Result<Arc<dyn EngineControl>, ProviderError>> {
Box::pin(async move {
let configured = self.configured_bundle();
let mut launch = config::ResolvedLaunch::resolve(&request, configured.as_deref())?;
launch.set_snapshot_restore(self.snapshot_restore());
*self.configured_bundle.lock().unwrap() = request
.image_ref
.clone()
.or(request.vm_bundle.clone())
.or(configured);
self.pool.configure(None, launch.memory_mb, None, None);
let mut checkout = self.pool.checkout(&launch, &cancellation).await?;
let release = checkout.take_release();
let control: Arc<dyn EngineControl> =
session::NativeSession::from_prepared(checkout.vm, launch, events, release)?;
Ok(control)
})
}
}