use serde::{Deserialize, Serialize};
use std::{
collections::BTreeMap,
sync::{
Arc, Mutex,
atomic::{AtomicBool, Ordering},
},
time::{Duration, Instant},
};
use tokio::sync::Notify;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
#[non_exhaustive]
pub enum WasiVersion {
V0_3,
V0_2,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
#[non_exhaustive]
pub enum WasiProfile {
Cli0_3,
Cli0_2,
Http0_3,
Http0_2,
}
impl WasiProfile {
pub(crate) const ALL: [Self; 4] = [Self::Cli0_3, Self::Cli0_2, Self::Http0_3, Self::Http0_2];
pub(crate) const fn cache_id(self) -> &'static str {
match self {
Self::Cli0_3 => "wasi-cli-command-0.3.0",
Self::Cli0_2 => "wasi-cli-command-0.2",
Self::Http0_3 => "wasi-http-service-0.3.0",
Self::Http0_2 => "wasi-http-proxy-0.2",
}
}
#[must_use]
pub const fn version(self) -> WasiVersion {
match self {
Self::Cli0_3 | Self::Http0_3 => WasiVersion::V0_3,
Self::Cli0_2 | Self::Http0_2 => WasiVersion::V0_2,
}
}
#[must_use]
pub const fn is_command(self) -> bool {
matches!(self, Self::Cli0_3 | Self::Cli0_2)
}
#[must_use]
pub const fn is_http(self) -> bool {
matches!(self, Self::Http0_3 | Self::Http0_2)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
#[non_exhaustive]
pub enum PackageTier {
Cold,
DiskAot,
Warmish,
Warm,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
#[non_exhaustive]
pub enum InvocationState {
Running,
PauseRequested,
PausedResident,
Evicted,
Finished,
}
#[derive(Debug, Clone)]
pub struct CommandInput {
pub stdin: Vec<u8>,
pub args: Vec<String>,
pub env: BTreeMap<String, String>,
pub timeout: Duration,
pub cancellation: CancellationToken,
}
impl Default for CommandInput {
fn default() -> Self {
Self {
stdin: Vec::new(),
args: Vec::new(),
env: BTreeMap::new(),
timeout: Duration::from_secs(30),
cancellation: CancellationToken::new(),
}
}
}
impl CommandInput {
#[must_use]
pub fn new(stdin: impl Into<Vec<u8>>) -> Self {
Self {
stdin: stdin.into(),
..Self::default()
}
}
#[must_use]
pub fn with_args(mut self, args: impl IntoIterator<Item = impl Into<String>>) -> Self {
self.args = args.into_iter().map(Into::into).collect();
self
}
#[must_use]
pub fn with_env(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
self.env.insert(key.into(), value.into());
self
}
#[must_use]
pub const fn with_timeout(mut self, timeout: Duration) -> Self {
self.timeout = timeout;
self
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct CommandOutput {
pub stdout: Vec<u8>,
pub stderr: Vec<u8>,
pub exit_code: u8,
pub wasi_version: WasiVersion,
pub measurement: crate::RunMeasurement,
}
#[derive(Debug, Clone, Default)]
pub struct CancellationToken(Arc<CancellationState>);
#[derive(Debug, Default)]
struct CancellationState {
cancelled: AtomicBool,
notify: Notify,
}
impl CancellationToken {
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn cancel(&self) {
self.0.cancelled.store(true, Ordering::Release);
self.0.notify.notify_waiters();
}
#[must_use]
pub fn is_cancelled(&self) -> bool {
self.0.cancelled.load(Ordering::Acquire)
}
pub(crate) async fn cancelled(&self) {
loop {
let notified = self.0.notify.notified();
if self.is_cancelled() {
return;
}
notified.await;
}
}
}
#[derive(Debug, Clone, Default)]
pub struct PauseToken(Arc<PauseState>);
#[derive(Debug, Default)]
struct PauseState {
paused: AtomicBool,
resident: AtomicBool,
evicted: AtomicBool,
timing: Mutex<PauseTiming>,
notify: Notify,
}
#[derive(Debug, Default)]
struct PauseTiming {
completed: Duration,
paused_at: Option<Instant>,
}
impl PauseToken {
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub(crate) fn pause(&self) {
let mut timing = self.timing();
if !self.0.paused.swap(true, Ordering::AcqRel) {
self.0.resident.store(false, Ordering::Release);
timing.paused_at = Some(Instant::now());
}
}
pub(crate) fn resume(&self) -> bool {
if self.is_evicted() {
return false;
}
let mut timing = self.timing();
if self.0.paused.swap(false, Ordering::AcqRel) {
self.0.resident.store(false, Ordering::Release);
if let Some(started) = timing.paused_at.take() {
timing.completed = timing.completed.saturating_add(started.elapsed());
}
self.0.notify.notify_waiters();
}
true
}
#[must_use]
pub fn is_paused(&self) -> bool {
self.0.paused.load(Ordering::Acquire)
}
pub(crate) fn is_evicted(&self) -> bool {
self.0.evicted.load(Ordering::Acquire)
}
pub(crate) fn is_resident(&self) -> bool {
self.0.resident.load(Ordering::Acquire)
}
pub(crate) fn mark_resident(&self) {
if self.is_paused() && !self.is_evicted() {
self.0.resident.store(true, Ordering::Release);
self.0.notify.notify_waiters();
}
}
pub(crate) fn total_paused(&self) -> Duration {
let timing = self.timing();
timing.completed.saturating_add(
timing
.paused_at
.map_or(Duration::ZERO, |started| started.elapsed()),
)
}
pub(crate) async fn wait(&self, cancellation: &CancellationToken, resident_ttl: Duration) {
loop {
let notified = self.0.notify.notified();
if !self.is_paused() || cancellation.is_cancelled() {
return;
}
let remaining = {
let timing = self.timing();
timing.paused_at.map_or(resident_ttl, |started| {
resident_ttl.saturating_sub(started.elapsed())
})
};
if remaining.is_zero() {
self.evict(cancellation);
return;
}
tokio::select! {
() = notified => {}
() = cancellation.cancelled() => return,
() = tokio::time::sleep(remaining) => {
if self.is_paused() {
self.evict(cancellation);
}
return;
}
}
}
}
fn evict(&self, cancellation: &CancellationToken) {
self.0.evicted.store(true, Ordering::Release);
self.0.resident.store(false, Ordering::Release);
cancellation.cancel();
self.0.notify.notify_waiters();
}
fn timing(&self) -> std::sync::MutexGuard<'_, PauseTiming> {
self.0
.timing
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
}
}