use std::fmt;
use serde::{Deserialize, Serialize};
use thiserror::Error;
use crate::diagnostics::{
Diagnostic, DiagnosticCode, DiagnosticEntity, DiagnosticSource, Severity,
};
use crate::ir::SourceLocation;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ExecutionDeadlines {
pub startup: u64,
pub cell: u64,
pub terminal_sync: u64,
pub interrupt: u64,
pub shutdown: u64,
pub termination: u64,
pub forced_exit: u64,
}
impl Default for ExecutionDeadlines {
fn default() -> Self {
Self {
startup: 30_000,
cell: 60_000,
terminal_sync: 5_000,
interrupt: 5_000,
shutdown: 5_000,
termination: 5_000,
forced_exit: 5_000,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ExecutionPhase {
Startup,
Cell,
TerminalSync,
Interrupt,
Shutdown,
Termination,
ForcedExit,
}
impl fmt::Display for ExecutionPhase {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Self::Startup => "startup",
Self::Cell => "cell execution",
Self::TerminalSync => "terminal synchronization",
Self::Interrupt => "interruption",
Self::Shutdown => "shutdown",
Self::Termination => "process termination",
Self::ForcedExit => "forced exit",
})
}
}
#[derive(Debug, Error, Clone, PartialEq, Eq)]
#[error("{kind}")]
pub struct ExecutionFailure {
pub kind: ExecutionFailureKind,
pub diagnostics: Vec<Diagnostic>,
pub cleanup_diagnostics: Vec<Diagnostic>,
}
#[derive(Debug, Error, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
pub enum ExecutionFailureKind {
#[error("The configured kernel could not be selected or started.")]
Startup,
#[error("Kernel communication or protocol validation failed.")]
Protocol,
#[error("The kernel requested interactive input.")]
InputRequested,
#[error("A cell failed without permission to continue.")]
CellError,
#[error("Execution timed out during {phase}.")]
Timeout {
phase: ExecutionPhase,
},
#[error("Page execution was canceled.")]
Cancelled,
#[error("Declared execution inputs changed during the page attempt.")]
InputChanged,
#[error("Cell output could not be validated.")]
OutputValidation,
#[error("A generated asset is outside its declared boundary.")]
AssetOutsideBoundary,
#[error("A generated asset is missing.")]
AssetMissing,
#[error("Execution assets conflict at the same content digest.")]
AssetCollision,
#[error("Execution cleanup could not be completed.")]
Cleanup,
}
impl ExecutionFailureKind {
pub const fn diagnostic_code(self) -> DiagnosticCode {
match self {
Self::Startup => DiagnosticCode::ExecutionStartupFailed,
Self::Protocol => DiagnosticCode::ExecutionProtocolFailed,
Self::InputRequested => DiagnosticCode::ExecutionInputRequested,
Self::CellError => DiagnosticCode::ExecutionCellFailed,
Self::Timeout { .. } => DiagnosticCode::ExecutionTimeout,
Self::Cancelled => DiagnosticCode::ExecutionCancelled,
Self::InputChanged => DiagnosticCode::ExecutionInputChanged,
Self::OutputValidation => DiagnosticCode::ExecutionOutputFailed,
Self::AssetOutsideBoundary => DiagnosticCode::GeneratedAssetOutsideBoundary,
Self::AssetMissing => DiagnosticCode::GeneratedAssetMissing,
Self::AssetCollision => DiagnosticCode::ExecutionAssetCollision,
Self::Cleanup => DiagnosticCode::ExecutionCleanupFailed,
}
}
pub fn to_diagnostic(
self,
collection: impl Into<String>,
source: SourceLocation,
) -> Diagnostic {
let mut diagnostic =
Diagnostic::new(self.diagnostic_code(), Severity::Error, self.to_string())
.with_entity(DiagnosticEntity::Content {
id: collection.into(),
})
.with_source(DiagnosticSource::Repository {
repository: source.repository,
path: source.path,
});
diagnostic.span = source.span;
diagnostic
}
}