dekopon-shell 0.28.0

Sandboxed bash-flavored script interpreter whose commands dispatch to Dekopon capabilities
Documentation
use std::{
    sync::{
        Arc,
        atomic::{AtomicU32, Ordering},
    },
    time::{Duration, Instant},
};

use crate::limits::LimitExceeded;

#[derive(Clone, Debug)]
pub struct CallBudget {
    used: Arc<AtomicU32>,
    maximum: u32,
}

impl CallBudget {
    #[must_use]
    pub fn new(maximum: u32) -> Self {
        Self {
            used: Arc::new(AtomicU32::new(0)),
            maximum,
        }
    }

    #[must_use]
    pub fn used(&self) -> u32 {
        self.used.load(Ordering::Relaxed)
    }

    #[must_use]
    pub const fn maximum(&self) -> u32 {
        self.maximum
    }

    pub(crate) fn charge(&self) -> Result<(), LimitExceeded> {
        self.used
            .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |used| {
                (used < self.maximum).then_some(used + 1)
            })
            .map(|_| ())
            .map_err(|_used| LimitExceeded::CapabilityCalls {
                maximum: self.maximum,
            })
    }
}

#[derive(Clone, Debug)]
pub struct TreeContext {
    deadline: Instant,
    timeout: Duration,
    calls: CallBudget,
}

impl TreeContext {
    #[must_use]
    pub fn new(timeout: Duration, calls: CallBudget) -> Self {
        let started = Instant::now();
        Self {
            deadline: started.checked_add(timeout).unwrap_or(started),
            timeout,
            calls,
        }
    }

    pub(crate) fn check_deadline(&self) -> Result<(), LimitExceeded> {
        if Instant::now() >= self.deadline {
            Err(LimitExceeded::Deadline {
                timeout_ms: self.timeout.as_millis(),
            })
        } else {
            Ok(())
        }
    }

    #[must_use]
    pub(crate) fn remaining(&self) -> Duration {
        self.deadline.saturating_duration_since(Instant::now())
    }

    #[must_use]
    pub(crate) fn calls(&self) -> &CallBudget {
        &self.calls
    }
}