use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RetryAdviceReason {
Unknown,
Retrying,
Failed,
GateClosed,
StepUpRequired,
TenantMismatch,
InsufficientScope,
QuotaExceeded,
ProviderTimeout,
LocalVerifyFailed,
BillingPreflightFailed,
}
pub const RETRY_ADVICE_REASONS: [RetryAdviceReason; 11] = [
RetryAdviceReason::Unknown,
RetryAdviceReason::Retrying,
RetryAdviceReason::Failed,
RetryAdviceReason::GateClosed,
RetryAdviceReason::StepUpRequired,
RetryAdviceReason::TenantMismatch,
RetryAdviceReason::InsufficientScope,
RetryAdviceReason::QuotaExceeded,
RetryAdviceReason::ProviderTimeout,
RetryAdviceReason::LocalVerifyFailed,
RetryAdviceReason::BillingPreflightFailed,
];
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RetryAdvice {
pub retryable: bool,
#[serde(
rename = "retryAfter",
default,
skip_serializing_if = "Option::is_none"
)]
pub retry_after: Option<i64>,
#[serde(rename = "sameIdempotencyKeyRequired")]
pub same_idempotency_key_required: bool,
#[serde(rename = "manualActionRequired")]
pub manual_action_required: bool,
pub reason: RetryAdviceReason,
#[serde(
rename = "userMessage",
default,
skip_serializing_if = "Option::is_none"
)]
pub user_message: Option<String>,
#[serde(
rename = "developerMessage",
default,
skip_serializing_if = "Option::is_none"
)]
pub developer_message: Option<String>,
#[serde(
rename = "supportCode",
default,
skip_serializing_if = "Option::is_none"
)]
pub support_code: Option<String>,
}
pub fn retry_reason_for_oauth_error(oauth_error: &str) -> RetryAdviceReason {
match oauth_error {
"insufficient_scope" => RetryAdviceReason::InsufficientScope,
"invalid_token"
| "invalid_grant"
| "invalid_request"
| "access_denied"
| "unsupported_grant_type" => RetryAdviceReason::Failed,
_ => RetryAdviceReason::Unknown,
}
}
use crate::compliance::errors::{ComplianceErrorInfo, ComplianceErrorKey};
pub fn retry_reason_for_compliance_key(key: ComplianceErrorKey) -> RetryAdviceReason {
use ComplianceErrorKey as K;
use RetryAdviceReason as R;
match key {
K::ComplianceUnauthorized => R::Failed,
K::ComplianceInsufficientScope => R::InsufficientScope,
K::ComplianceStepUpRequired => R::StepUpRequired,
K::ComplianceTokenInvalid => R::Failed,
K::SubjectSnapshotRequired => R::Failed,
K::SubjectSnapshotNotFound => R::Failed,
K::SubjectSnapshotTenantMismatch => R::TenantMismatch,
K::EvidenceAssetNotFound => R::Failed,
K::EvidenceAssetHashMismatch => R::LocalVerifyFailed,
K::EvidenceAssetPayloadRequired => R::Failed,
K::TimestampTokenNotFound => R::Failed,
K::TimestampProviderFailed => R::Failed,
K::TimestampProviderUnknown => R::Unknown,
K::TimestampLocalVerifyFailed => R::LocalVerifyFailed,
K::TimestampProviderNotAvailable => R::ProviderTimeout,
K::EvidencePackageNotFound => R::Failed,
K::EvidencePackageTimestampRequired => R::Failed,
K::EvidencePackageManifestHashMismatch => R::LocalVerifyFailed,
K::ReportNotFound => R::Failed,
K::ReportAlreadyPublished => R::Failed,
K::ReportDraftRequired => R::Failed,
K::EvidenceVerifyTargetRequired => R::Failed,
K::EvidenceVerifyTargetNotFound => R::Failed,
K::ProviderRequestUnknownNoRetry => R::Unknown,
K::ProviderCallbackSourceInvalid => R::Failed,
K::ProviderNotConfigured => R::GateClosed,
K::ProviderRequestNotFound => R::Failed,
K::ProviderRequestIdempotencyRequired => R::Failed,
K::ProviderRequestStatusNotTerminal => R::Retrying,
K::EnvelopeNotFound => R::Failed,
K::EnvelopeTenantMismatch => R::TenantMismatch,
K::EnvelopeStateNotAllowed => R::Failed,
K::EnvelopeGateClosed => R::GateClosed,
K::ContractNotFound => R::Failed,
K::ContractHashMismatch => R::LocalVerifyFailed,
K::ProviderAuthorizationNotConfirmed => R::Failed,
K::EnvelopeEvidenceNotReady => R::Retrying,
K::SealAssetNotFound => R::Failed,
K::SealApprovalNotFound => R::Failed,
K::SealApprovalStateNotApproved => R::Failed,
K::SealApprovalExpired => R::Failed,
K::SealApprovalAlreadyUsed => R::Failed,
K::SealApprovalNonceUsed => R::Failed,
K::SealApprovalSealMismatch => R::Failed,
K::SealApprovalLocationMismatch => R::Failed,
K::SealApprovalTransactorMismatch => R::Failed,
K::SealApprovalContractHashMismatch => R::LocalVerifyFailed,
K::SealApprovalInvalidTransition => R::Failed,
K::SealUseAlreadyConsumed => R::Failed,
K::AuditChainTamperDetected => R::LocalVerifyFailed,
K::BillingCommitRequiresLocalVerify => R::LocalVerifyFailed,
K::BillingCommitRequiresProviderSuccess => R::BillingPreflightFailed,
K::BillingCallbackCannotCommit => R::BillingPreflightFailed,
K::BillingProviderUnknownNotCommittable => R::BillingPreflightFailed,
K::BillingS2sForbidden => R::Failed,
K::UnknownComplianceError => R::Unknown,
}
}
pub fn compliance_error_to_retry_advice(info: &ComplianceErrorInfo) -> RetryAdvice {
RetryAdvice {
retryable: info.retryable,
retry_after: None,
same_idempotency_key_required: !info.terminal,
manual_action_required: info.terminal || info.step_up_required,
reason: retry_reason_for_compliance_key(info.key),
user_message: None,
developer_message: Some(info.message.clone()),
support_code: Some(format!("compliance:{}", info.code)),
}
}
#[cfg(test)]
mod compliance_tests {
use super::*;
#[test]
fn step_up_key_maps() {
assert_eq!(
retry_reason_for_compliance_key(ComplianceErrorKey::ComplianceStepUpRequired),
RetryAdviceReason::StepUpRequired
);
assert_eq!(
retry_reason_for_compliance_key(ComplianceErrorKey::EnvelopeGateClosed),
RetryAdviceReason::GateClosed
);
assert_eq!(
retry_reason_for_compliance_key(ComplianceErrorKey::SubjectSnapshotTenantMismatch),
RetryAdviceReason::TenantMismatch
);
assert_eq!(
retry_reason_for_compliance_key(ComplianceErrorKey::UnknownComplianceError),
RetryAdviceReason::Unknown
);
}
#[test]
fn advice_terminal_sets_manual_and_drops_same_key() {
let info = ComplianceErrorInfo {
code: 1031004004,
message: "gate closed".to_string(),
key: ComplianceErrorKey::EnvelopeGateClosed,
retryable: false,
terminal: true,
step_up_required: false,
};
let advice = compliance_error_to_retry_advice(&info);
assert!(!advice.retryable);
assert!(advice.manual_action_required);
assert!(!advice.same_idempotency_key_required);
assert_eq!(advice.reason, RetryAdviceReason::GateClosed);
assert_eq!(
advice.support_code.as_deref(),
Some("compliance:1031004004")
);
}
#[test]
fn advice_step_up_requires_manual() {
let info = ComplianceErrorInfo {
code: 1031000013,
message: "step up".to_string(),
key: ComplianceErrorKey::ComplianceStepUpRequired,
retryable: false,
terminal: false,
step_up_required: true,
};
let advice = compliance_error_to_retry_advice(&info);
assert!(advice.manual_action_required);
assert!(advice.same_idempotency_key_required);
assert_eq!(advice.reason, RetryAdviceReason::StepUpRequired);
}
}