apoc 0.9.1

Agentic process control for LLMs
Documentation
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)
        })
    }
}