Files
crank/crates/crank-runtime/src/execution_failure.rs
T

238 lines
9.4 KiB
Rust

use crank_core::{
CorrelationContext, DispatchEvidence, ExecutionErrorCode, ExecutionFailure,
ProtocolAdapterError,
};
use crate::{RuntimeError, RuntimeOperation};
pub fn normalize_runtime_error(
error: &RuntimeError,
correlation: &CorrelationContext,
) -> ExecutionFailure {
normalize_runtime_error_with_effect(error, correlation, false)
}
pub fn normalize_runtime_error_for_operation(
error: &RuntimeError,
correlation: &CorrelationContext,
operation: &RuntimeOperation,
) -> ExecutionFailure {
let may_mutate = matches!(
&operation.target,
crank_core::Target::Rest(target)
if matches!(
target.method,
crank_core::HttpMethod::Post
| crank_core::HttpMethod::Put
| crank_core::HttpMethod::Patch
| crank_core::HttpMethod::Delete
)
);
normalize_runtime_error_with_effect(error, correlation, may_mutate)
}
fn normalize_runtime_error_with_effect(
error: &RuntimeError,
correlation: &CorrelationContext,
may_mutate: bool,
) -> ExecutionFailure {
let mut failure = ExecutionFailure::new(error_code(error), correlation.clone());
match error {
RuntimeError::ProtocolAdapter(
adapter @ ProtocolAdapterError::UnexpectedStatus { status, .. },
) => {
failure = failure.with_upstream_status(*status);
if may_mutate && ambiguous_after_dispatch(adapter) {
failure = failure.with_dispatch_uncertainty();
}
}
RuntimeError::ProtocolAdapter(adapter)
if may_mutate && ambiguous_after_dispatch(adapter) =>
{
failure = failure.with_dispatch_uncertainty();
}
RuntimeError::ExecutionDeadlineElapsed {
may_have_dispatched: true,
}
| RuntimeError::IdempotencyCompletionUnknown { .. } => {
failure = failure.with_dispatch_uncertainty();
}
RuntimeError::ConfirmationRequired {
confirmation_token,
expires_in_ms,
..
} => {
if let Ok(with_confirmation) = failure
.clone()
.try_with_confirmation(confirmation_token, *expires_in_ms)
{
failure = with_confirmation;
}
}
_ => {}
}
failure
}
fn ambiguous_after_dispatch(error: &ProtocolAdapterError) -> bool {
match error {
ProtocolAdapterError::Transport {
dispatch: DispatchEvidence::MayHaveDispatched,
}
| ProtocolAdapterError::Timeout {
dispatch: DispatchEvidence::MayHaveDispatched,
}
| ProtocolAdapterError::ResponseTooLarge {
dispatch: DispatchEvidence::MayHaveDispatched,
}
| ProtocolAdapterError::InvalidResponse {
dispatch: DispatchEvidence::MayHaveDispatched,
} => true,
ProtocolAdapterError::UnexpectedStatus {
status,
dispatch: DispatchEvidence::MayHaveDispatched,
} => matches!(status, 408 | 429 | 500..=599),
_ => false,
}
}
fn error_code(error: &RuntimeError) -> ExecutionErrorCode {
match error {
RuntimeError::InvalidExecutionRequest => ExecutionErrorCode::RuntimeInternal,
RuntimeError::ExecutionDeadlineElapsed { .. } => ExecutionErrorCode::UpstreamTimeout,
RuntimeError::Schema(_) | RuntimeError::InputSchema(_) => {
ExecutionErrorCode::InputSchemaInvalid
}
RuntimeError::OutputSchema(_) => ExecutionErrorCode::OutputSchemaInvalid,
RuntimeError::Mapping(_) | RuntimeError::InputMapping(_) => {
ExecutionErrorCode::InputMappingInvalid
}
RuntimeError::OutputMapping(_) => ExecutionErrorCode::OutputMappingInvalid,
RuntimeError::ProtocolAdapter(adapter) => protocol_error_code(adapter),
RuntimeError::UnsupportedProtocol { .. } => ExecutionErrorCode::ProtocolUnsupported,
RuntimeError::UnsupportedExecutionMode { .. } => {
ExecutionErrorCode::ExecutionModeUnsupported
}
RuntimeError::ConcurrencyLimitExceeded { .. } => ExecutionErrorCode::ExecutionOverloaded,
RuntimeError::InvalidPreparedRequest { .. } => ExecutionErrorCode::PreparedRequestInvalid,
RuntimeError::ConfirmationRequired { .. } => ExecutionErrorCode::ConfirmationRequired,
RuntimeError::InvalidConfirmationToken { .. } => ExecutionErrorCode::ConfirmationInvalid,
RuntimeError::ConfirmationStoreUnavailable { .. }
| RuntimeError::IdempotencyStoreUnavailable { .. } => {
ExecutionErrorCode::SafetyStoreUnavailable
}
RuntimeError::IdempotencyInProgress { .. } => ExecutionErrorCode::IdempotencyInProgress,
RuntimeError::IdempotencyConflict { .. } => ExecutionErrorCode::IdempotencyConflict,
RuntimeError::IdempotencyOutcomeUnknown { .. } => {
ExecutionErrorCode::IdempotencyOutcomeUnknown
}
RuntimeError::IdempotencyCompletionUnknown { .. } => {
ExecutionErrorCode::IdempotencyOutcomeUnknown
}
RuntimeError::MissingAuthProfile { .. } => ExecutionErrorCode::AuthProfileNotFound,
RuntimeError::InvalidAuthProfileConfig { .. } => ExecutionErrorCode::SecretInvalid,
RuntimeError::AuthorizationStoreUnavailable => ExecutionErrorCode::SafetyStoreUnavailable,
RuntimeError::MissingSecret { .. } | RuntimeError::MissingSecretVersion { .. } => {
ExecutionErrorCode::SecretNotFound
}
RuntimeError::InvalidAuthSecretValue { .. } | RuntimeError::SecretCrypto { .. } => {
ExecutionErrorCode::SecretInvalid
}
}
}
fn protocol_error_code(error: &ProtocolAdapterError) -> ExecutionErrorCode {
match error {
ProtocolAdapterError::UnsupportedMode { .. } => {
ExecutionErrorCode::ExecutionModeUnsupported
}
ProtocolAdapterError::InvalidConfiguration => {
ExecutionErrorCode::AdapterConfigurationInvalid
}
ProtocolAdapterError::InvalidPreparedRequest => ExecutionErrorCode::PreparedRequestInvalid,
ProtocolAdapterError::RequestTooLarge => ExecutionErrorCode::UpstreamRequestTooLarge,
ProtocolAdapterError::TargetRejected => ExecutionErrorCode::OutboundTargetRejected,
ProtocolAdapterError::Transport { .. } => ExecutionErrorCode::UpstreamTransportError,
ProtocolAdapterError::Timeout { .. } => ExecutionErrorCode::UpstreamTimeout,
ProtocolAdapterError::ResponseTooLarge { .. } => {
ExecutionErrorCode::UpstreamResponseTooLarge
}
ProtocolAdapterError::UnexpectedStatus { status, .. } => match status {
401 | 403 => ExecutionErrorCode::UpstreamAuthError,
404 => ExecutionErrorCode::UpstreamNotFound,
408 | 429 => ExecutionErrorCode::UpstreamRateLimited,
500..=599 => ExecutionErrorCode::UpstreamServerError,
_ => ExecutionErrorCode::UpstreamStatusError,
},
ProtocolAdapterError::InvalidResponse { .. } => ExecutionErrorCode::UpstreamStatusError,
}
}
#[cfg(test)]
mod tests {
use crank_core::{
CorrelationContext, DispatchEvidence, ExecutionErrorCode, OutcomeCertainty,
ProtocolAdapterError, Retryability,
};
use super::*;
#[test]
fn status_and_dispatch_evidence_drive_closed_semantics() {
let correlation = CorrelationContext::generate();
let rate_limit = normalize_runtime_error(
&RuntimeError::ProtocolAdapter(ProtocolAdapterError::UnexpectedStatus {
status: 429,
dispatch: DispatchEvidence::MayHaveDispatched,
}),
&correlation,
);
assert_eq!(
rate_limit.error_code(),
ExecutionErrorCode::UpstreamRateLimited
);
assert_eq!(rate_limit.upstream_status(), Some(429));
assert_eq!(rate_limit.retryability(), Retryability::AfterDelay);
assert_eq!(rate_limit.outcome_certainty(), OutcomeCertainty::Certain);
let ambiguous = normalize_runtime_error(
&RuntimeError::ProtocolAdapter(ProtocolAdapterError::Timeout {
dispatch: DispatchEvidence::MayHaveDispatched,
}),
&correlation,
);
assert_eq!(ambiguous.error_code(), ExecutionErrorCode::UpstreamTimeout);
assert_eq!(ambiguous.retryability(), Retryability::AfterDelay);
assert_eq!(ambiguous.outcome_certainty(), OutcomeCertainty::Certain);
}
#[test]
fn raw_internal_details_never_enter_normalized_failure() {
let canary = "story18-secret-url-canary";
let failure = normalize_runtime_error(
&RuntimeError::SecretCrypto {
operation: "decrypt",
details: canary.to_owned(),
},
&CorrelationContext::generate(),
);
assert_eq!(failure.error_code(), ExecutionErrorCode::SecretInvalid);
assert!(!format!("{failure:?}").contains(canary));
}
#[test]
fn authorization_store_failures_use_typed_safety_store_outcome() {
let failure = normalize_runtime_error(
&RuntimeError::AuthorizationStoreUnavailable,
&CorrelationContext::generate(),
);
assert_eq!(
failure.error_code(),
ExecutionErrorCode::SafetyStoreUnavailable
);
assert_eq!(failure.retryability(), Retryability::AfterDelay);
assert_eq!(failure.outcome_certainty(), OutcomeCertainty::Certain);
}
}