use super::*;
#[derive(Debug, Error)]
pub enum RuntimeError {
#[error("auth error: {0}")]
Auth(#[from] AuthError),
#[error("access denied for {principal} {action} on {resource}; explicit_deny={explicit_deny}")]
AccessDenied {
principal: String,
action: String,
resource: String,
explicit_deny: bool,
},
#[error("SigV4 authentication failed: {0}")]
SigV4Authentication(String),
#[error("authorization query parameters error: {0}")]
AuthorizationQueryParametersError(String),
#[error("authorization header malformed: {0}")]
AuthorizationHeaderMalformed(String),
#[error("invalid access key id: {0}")]
InvalidAccessKeyId(String),
#[error("expired token: {0}")]
ExpiredToken(String),
#[error("invalid token: {0}")]
InvalidToken(String),
#[error("request time too skewed: {0}")]
RequestTimeTooSkewed(String),
#[error("invalid bucket name: {0}")]
InvalidBucketName(String),
#[error("invalid object key: {0}")]
InvalidObjectKey(String),
#[error("invalid multi-object delete request: {0}")]
InvalidMultiObjectDelete(String),
#[error("bucket already exists: {0}")]
BucketAlreadyExists(String),
#[error("bucket is not empty: {0}")]
BucketNotEmpty(String),
#[error("no such bucket: {0}")]
NoSuchBucket(String),
#[error("no such key: {0}")]
NoSuchKey(String),
#[error("no such version {version_id} for {bucket}/{key}")]
NoSuchVersion {
bucket: String,
key: String,
version_id: String,
},
#[error("object is locked: {0}")]
ObjectLocked(#[from] LockError),
#[error("kms error: {0}")]
Kms(#[from] KmsError),
#[error("snapshot serialization failed: {0}")]
SnapshotSerialize(serde_json::Error),
#[error("snapshot deserialization failed: {0}")]
SnapshotDeserialize(serde_json::Error),
#[error("snapshot I/O failed: {0}")]
SnapshotIo(String),
#[error("unsupported runtime snapshot schema version: {0}")]
UnsupportedSnapshotSchema(u32),
#[error(
"runtime snapshot next_version {next_version} is behind highest version {highest_version}"
)]
InvalidSnapshotVersionCounter {
next_version: u64,
highest_version: u64,
},
#[error(
"runtime snapshot next_upload {next_upload} is behind highest upload {highest_upload}"
)]
InvalidSnapshotUploadCounter {
next_upload: u64,
highest_upload: u64,
},
#[error("runtime snapshot next_event {next_event} is behind highest event {highest_event}")]
InvalidSnapshotEventCounter { next_event: u64, highest_event: u64 },
#[error("invalid multipart part number: {0}")]
InvalidPartNumber(String),
#[error("no such multipart upload: {0}")]
NoSuchUpload(String),
#[error("multipart upload has no parts: {0}")]
NoMultipartParts(String),
#[error("multipart upload {upload_id} is missing part {part_number}")]
MissingMultipartPart { upload_id: String, part_number: u16 },
#[error("multipart upload {upload_id} part {part_number} etag does not match")]
MultipartEtagMismatch { upload_id: String, part_number: u16 },
#[error("invalid range: {0}")]
InvalidRange(String),
#[error("invalid conditional header {name}: {value}")]
InvalidConditionalHeader { name: String, value: String },
#[error("invalid list parameter {name}: {value}")]
InvalidListParameter { name: String, value: String },
#[error("invalid bucket versioning status: {0}")]
InvalidBucketVersioningStatus(String),
#[error("invalid digest in {header}: {value}")]
InvalidDigest { header: String, value: String },
#[error("invalid metadata directive: {0}")]
InvalidMetadataDirective(String),
#[error("invalid object attributes request: {0}")]
InvalidObjectAttributesRequest(String),
#[error("checksum mismatch for {header}")]
BadDigest { header: String },
#[error("invalid storage commit log: {0}")]
InvalidStorageCommitLog(String),
#[error("cors request is not allowed: {0}")]
CorsNotAllowed(String),
#[error("invalid CORS rule: {0}")]
InvalidCorsRule(String),
#[error("bucket website configuration does not exist for {0}")]
NoSuchWebsiteConfiguration(String),
#[error("invalid website configuration: {0}")]
InvalidWebsiteConfiguration(String),
#[error("invalid bucket logging configuration: {0}")]
InvalidBucketLogging(String),
#[error("bucket policy does not exist for {0}")]
NoSuchBucketPolicy(String),
#[error("invalid bucket policy: {0}")]
InvalidBucketPolicy(String),
#[error("invalid bucket ABAC configuration: {0}")]
InvalidBucketAbac(String),
#[error("invalid request payment configuration: {0}")]
InvalidRequestPaymentConfiguration(String),
#[error("invalid accelerate configuration: {0}")]
InvalidAccelerateConfiguration(String),
#[error("invalid create session request: {0}")]
InvalidCreateSession(String),
#[error("invalid public access block configuration: {0}")]
InvalidPublicAccessBlockConfiguration(String),
#[error("public access block configuration does not exist for {0}")]
NoSuchPublicAccessBlockConfiguration(String),
#[error("invalid bucket metadata configuration: {0}")]
InvalidBucketMetadataConfiguration(String),
#[error("bucket metadata configuration does not exist for {0}")]
NoSuchBucketMetadataConfiguration(String),
#[error("invalid bucket metadata table configuration: {0}")]
InvalidBucketMetadataTableConfiguration(String),
#[error("bucket metadata table configuration does not exist for {0}")]
NoSuchBucketMetadataTableConfiguration(String),
#[error("bucket metadata table API is not available for {0}")]
BucketMetadataTableApiNotAvailable(String),
#[error("invalid metrics configuration: {0}")]
InvalidMetricsConfiguration(String),
#[error("metrics configuration does not exist for {bucket} with id {id}")]
NoSuchMetricsConfiguration { bucket: String, id: String },
#[error("too many configurations for {0}")]
TooManyConfigurations(String),
#[error("invalid analytics configuration: {0}")]
InvalidAnalyticsConfiguration(String),
#[error("analytics configuration does not exist for {bucket} with id {id}")]
NoSuchAnalyticsConfiguration { bucket: String, id: String },
#[error("invalid inventory configuration: {0}")]
InvalidInventoryConfiguration(String),
#[error("inventory configuration does not exist for {bucket} with id {id}")]
NoSuchInventoryConfiguration { bucket: String, id: String },
#[error("invalid intelligent-tiering configuration: {0}")]
InvalidIntelligentTieringConfiguration(String),
#[error("intelligent-tiering configuration does not exist for {bucket} with id {id}")]
NoSuchIntelligentTieringConfiguration { bucket: String, id: String },
#[error("bucket tag set does not exist for {0}")]
NoSuchTagSet(String),
#[error("invalid object tagging: {0}")]
InvalidTagging(String),
#[error("object lock configuration does not exist for {0}")]
ObjectLockConfigurationNotFound(String),
#[error("invalid object lock configuration: {0}")]
InvalidObjectLockConfiguration(String),
#[error("invalid legal hold: {0}")]
InvalidLegalHold(String),
#[error("invalid retention: {0}")]
InvalidRetention(String),
#[error("bucket encryption configuration does not exist for {0}")]
NoSuchBucketEncryption(String),
#[error("invalid server-side encryption: {0}")]
InvalidEncryption(String),
#[error("unsupported server-side encryption: {0}")]
UnsupportedEncryption(String),
#[error("unsupported storage backend: {0}")]
UnsupportedStorageBackend(String),
#[error("unsupported replication strategy: {0}")]
UnsupportedReplicationStrategy(String),
#[error("unsupported erasure coding profile: {0}")]
UnsupportedErasureCodingProfile(String),
#[error("invalid erasure coding layout: {0}")]
InvalidErasureCodingLayout(String),
#[error("unsupported placement domain: {0}")]
UnsupportedPlacementDomain(String),
#[error("invalid placement policy: {0}")]
InvalidPlacementPolicy(String),
#[error("unsupported consistency model: {0}")]
UnsupportedConsistencyModel(String),
#[error("invalid consistency policy: {0}")]
InvalidConsistencyPolicy(String),
#[error("unsupported metadata architecture: {0}")]
UnsupportedMetadataArchitecture(String),
#[error("invalid metadata architecture policy: {0}")]
InvalidMetadataArchitecturePolicy(String),
#[error("unsupported object layout: {0}")]
UnsupportedObjectLayout(String),
#[error("invalid object layout policy: {0}")]
InvalidObjectLayoutPolicy(String),
#[error("unsupported small-object optimization: {0}")]
UnsupportedSmallObjectOptimization(String),
#[error("invalid small-object optimization policy: {0}")]
InvalidSmallObjectOptimizationPolicy(String),
#[error("unsupported large-object optimization: {0}")]
UnsupportedLargeObjectOptimization(String),
#[error("invalid large-object optimization policy: {0}")]
InvalidLargeObjectOptimizationPolicy(String),
#[error("bucket lifecycle configuration does not exist for {0}")]
NoSuchLifecycleConfiguration(String),
#[error("invalid lifecycle configuration: {0}")]
InvalidLifecycleConfiguration(String),
#[error("invalid notification configuration: {0}")]
InvalidNotificationConfiguration(String),
#[error("bucket replication configuration does not exist for {0}")]
NoSuchBucketReplication(String),
#[error("invalid replication configuration: {0}")]
InvalidReplicationConfiguration(String),
#[error("ACLs are not supported in BucketOwnerEnforced mode: {0}")]
AccessControlListNotSupported(String),
#[error("invalid ownership controls: {0}")]
InvalidOwnershipControls(String),
#[error("invalid bucket location: {0}")]
InvalidBucketLocation(String),
#[error("operator action denied for {principal} {action} on {resource}")]
OperatorActionDenied {
principal: String,
action: String,
resource: String,
},
#[error(
"quota exceeded for {scope} {resource}: {metric} limit {limit} would be exceeded by {attempted}"
)]
QuotaExceeded {
scope: String,
resource: String,
metric: String,
limit: u64,
attempted: u64,
},
#[error("service-specific runtime error feature: {0}")]
ServiceSpecificErrorFeature(&'static str),
}