use serde::{Deserialize, Serialize};
use crate::api::ApiErrorResponse;
use crate::metadata::{ReadMetadata, WriteMetadata};
pub const MAX_BATCH_OPERATIONS: usize = 1000;
pub const MAX_BATCH_PART_SIZE: usize = 1024 * 1024;
pub const MAX_DESCRIPTOR_SIZE: usize = 64 * 1024;
pub const PAYLOAD_SUFFIX: &str = ".payload";
pub fn payload_part_name(index: usize) -> String {
format!("{index}{PAYLOAD_SUFFIX}")
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum OperationKind {
Get,
Head,
Delete,
Insert,
#[serde(other)]
Unknown,
}
impl OperationKind {
pub const fn as_str(self) -> &'static str {
match self {
Self::Get => "get",
Self::Head => "head",
Self::Delete => "delete",
Self::Insert => "insert",
Self::Unknown => "unknown",
}
}
}
impl From<&str> for OperationKind {
fn from(name: &str) -> Self {
match name {
"get" => Self::Get,
"head" => Self::Head,
"delete" => Self::Delete,
"insert" => Self::Insert,
_ => Self::Unknown,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "lowercase")]
pub enum Descriptor {
Get {
key: String,
},
Head {
key: String,
},
Delete {
key: String,
},
Insert {
#[serde(default, skip_serializing_if = "Option::is_none")]
key: Option<String>,
#[serde(default)]
metadata: WriteMetadata,
},
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResultPart {
pub status: u16,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub kind: Option<OperationKind>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<ReadMetadata>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<ApiErrorResponse>,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn result_part_with_unknown_kind_is_readable() {
let json = r#"{"status":200,"kind":"copy","key":"a"}"#;
let result: ResultPart = serde_json::from_str(json).unwrap();
assert_eq!(result.status, 200);
assert_eq!(result.kind, Some(OperationKind::Unknown));
assert_eq!(result.key.as_deref(), Some("a"));
}
#[test]
fn kind_from_name() {
assert_eq!(OperationKind::from("get"), OperationKind::Get);
assert_eq!(OperationKind::from("head"), OperationKind::Head);
assert_eq!(OperationKind::from("delete"), OperationKind::Delete);
assert_eq!(OperationKind::from("insert"), OperationKind::Insert);
assert_eq!(OperationKind::from("copy"), OperationKind::Unknown);
}
}