use std::collections::BTreeMap;
use std::time::{Duration, SystemTime};
use crate::error::{Error, ErrorKind, Result};
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Bucket {
pub name: String,
pub created: SystemTime,
}
#[derive(Clone, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub struct Object {
pub key: String,
pub is_prefix: bool,
pub version: Vec<u8>,
pub system: SystemMetadata,
pub custom: CustomMetadata,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct SystemMetadata {
pub created: Option<SystemTime>,
pub expires: Option<SystemTime>,
pub content_length: i64,
}
pub type CustomMetadata = BTreeMap<String, String>;
pub fn verify_custom_metadata(metadata: &CustomMetadata) -> Result<()> {
for (key, value) in metadata {
if key.is_empty() {
return Err(Error::new(
ErrorKind::MetadataInvalid,
"custom metadata contains an empty key",
));
}
if key.contains('\0') || value.contains('\0') {
return Err(Error::new(
ErrorKind::MetadataInvalid,
"custom metadata contains a NUL byte",
));
}
}
Ok(())
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ListBucketsOptions {
pub cursor: Option<String>,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct CreateBucketOptions {
pub object_lock_enabled: bool,
pub placement: Vec<u8>,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ListObjectsOptions {
pub prefix: String,
pub cursor: String,
pub recursive: bool,
pub system: bool,
pub custom: bool,
}
impl ListObjectsOptions {
pub fn validate(&self) -> Result<()> {
require_trailing_slash_if_nonempty("prefix", &self.prefix)
}
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct UploadOptions {
pub expires: Option<SystemTime>,
pub retention: Option<Retention>,
pub legal_hold: bool,
pub checksum: Option<ObjectChecksum>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DownloadOptions {
pub offset: i64,
pub length: i64,
pub version: Vec<u8>,
}
impl Default for DownloadOptions {
fn default() -> Self {
Self {
offset: 0,
length: -1,
version: Vec::new(),
}
}
}
impl DownloadOptions {
pub fn validate(&self) -> Result<()> {
if self.offset < 0 && self.length >= 0 {
return Err(Error::new(
ErrorKind::ObjectKeyInvalid,
"suffix requires length to be negative",
));
}
Ok(())
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum RetentionMode {
Governance,
Compliance,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Retention {
pub mode: RetentionMode,
pub retain_until: SystemTime,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct SetObjectRetentionOptions {
pub bypass_governance_retention: bool,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DefaultRetention {
pub mode: RetentionMode,
pub days: i32,
pub years: i32,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct BucketObjectLockConfiguration {
pub enabled: bool,
pub default_retention: Option<DefaultRetention>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub struct UploadInfo {
pub key: String,
pub upload_id: String,
pub system: SystemMetadata,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
#[non_exhaustive]
pub enum ObjectChecksumAlgorithm {
#[default]
None,
Crc32,
Crc32c,
Crc64Nvme,
Sha1,
Sha256,
}
impl ObjectChecksumAlgorithm {
pub(crate) fn to_proto(self) -> i32 {
use storj_proto::metainfo::ObjectChecksumAlgorithm as Proto;
match self {
Self::None => Proto::None as i32,
Self::Crc32 => Proto::Crc32 as i32,
Self::Crc32c => Proto::Crc32c as i32,
Self::Crc64Nvme => Proto::Crc64nvme as i32,
Self::Sha1 => Proto::Sha1 as i32,
Self::Sha256 => Proto::Sha256 as i32,
}
}
#[allow(dead_code)]
pub(crate) fn from_proto(value: i32) -> Self {
use storj_proto::metainfo::ObjectChecksumAlgorithm as Proto;
match Proto::try_from(value) {
Ok(Proto::None) => Self::None,
Ok(Proto::Crc32) => Self::Crc32,
Ok(Proto::Crc32c) => Self::Crc32c,
Ok(Proto::Crc64nvme) => Self::Crc64Nvme,
Ok(Proto::Sha1) => Self::Sha1,
Ok(Proto::Sha256) => Self::Sha256,
Err(_) => Self::None,
}
}
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ObjectChecksum {
pub algorithm: ObjectChecksumAlgorithm,
pub composite: bool,
pub value: Vec<u8>,
}
impl ObjectChecksum {
pub(crate) fn validate(&self, require_value: bool) -> Result<()> {
if self.algorithm == ObjectChecksumAlgorithm::None {
if self.composite {
return Err(Error::new(
ErrorKind::MetadataInvalid,
"checksum composite flag requires a checksum algorithm",
));
}
if !self.value.is_empty() {
return Err(Error::new(
ErrorKind::MetadataInvalid,
"checksum value requires a checksum algorithm",
));
}
} else if require_value && self.value.is_empty() {
return Err(Error::new(
ErrorKind::MetadataInvalid,
"checksum value is required when a checksum algorithm is set",
));
}
Ok(())
}
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct CommitUploadOptions {
pub custom_metadata: CustomMetadata,
pub checksum: Option<ObjectChecksum>,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ListUploadsOptions {
pub prefix: String,
pub cursor: String,
pub recursive: bool,
pub system: bool,
pub custom: bool,
}
impl ListUploadsOptions {
pub fn validate(&self) -> Result<()> {
let _ = &self.prefix;
Ok(())
}
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ListUploadPartsOptions {
pub cursor: u32,
}
#[derive(Clone, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub struct Part {
pub part_number: u32,
pub size: i64,
pub modified: SystemTime,
pub etag: Vec<u8>,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct Config {
pub tls_identity: Option<crate::config::TlsIdentity>,
pub transport: crate::TransportMode,
pub network: crate::NetworkOptions,
pub telemetry: Option<crate::Telemetry>,
pub user_agent: Option<String>,
pub dial_timeout: Option<Duration>,
pub message_timeout: Option<Duration>,
pub download_hedge_delay: Option<Duration>,
pub concurrent_segments: Option<usize>,
}
impl Config {
pub fn dial_timeout_or_default(&self) -> Duration {
match self.dial_timeout {
None | Some(Duration::ZERO) => {
Duration::from_secs(crate::constants::DEFAULT_DIAL_TIMEOUT_SECS)
}
Some(d) => d,
}
}
pub fn message_timeout_or_default(&self) -> Duration {
match self.message_timeout {
None | Some(Duration::ZERO) => storj_rpc::conn::DEFAULT_TIMEOUT,
Some(d) => d,
}
}
pub fn download_hedge_delay_or_default(&self) -> Duration {
self.download_hedge_delay.unwrap_or(Duration::from_secs(1))
}
#[must_use]
pub fn concurrent_segments_or_default(&self) -> usize {
match self.concurrent_segments {
None | Some(0) => crate::constants::DEFAULT_CONCURRENT_SEGMENTS,
Some(n) => n,
}
}
}
pub(crate) fn require_trailing_slash_if_nonempty(label: &str, value: &str) -> Result<()> {
if !value.is_empty() && !value.ends_with('/') {
return Err(Error::new(
ErrorKind::ObjectKeyInvalid,
format!("{label} must end with '/'"),
));
}
Ok(())
}
pub(crate) fn require_encryption_prefix(prefix: &str) -> Result<()> {
if prefix.is_empty() || !prefix.ends_with('/') {
return Err(Error::new(
ErrorKind::ObjectKeyInvalid,
"prefix must end with '/'",
));
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn download_options_default_is_whole_object() {
let d = DownloadOptions::default();
assert_eq!(d.offset, 0);
assert_eq!(d.length, -1);
assert!(d.version.is_empty());
assert!(d.validate().is_ok());
}
#[test]
fn download_suffix_ok() {
let d = DownloadOptions {
offset: -100,
length: -1,
version: Vec::new(),
};
assert!(d.validate().is_ok());
}
#[test]
fn download_negative_offset_positive_length_rejected() {
let d = DownloadOptions {
offset: -10,
length: 100,
version: Vec::new(),
};
let e = d.validate().unwrap_err();
assert_eq!(e.kind(), ErrorKind::ObjectKeyInvalid);
let zero = DownloadOptions {
offset: -10,
length: 0,
version: Vec::new(),
};
assert_eq!(
zero.validate().unwrap_err().kind(),
ErrorKind::ObjectKeyInvalid
);
}
#[test]
fn list_prefix_must_end_with_slash() {
let bad = ListObjectsOptions {
prefix: "logs".into(),
..Default::default()
};
assert_eq!(
bad.validate().unwrap_err().kind(),
ErrorKind::ObjectKeyInvalid
);
let ok = ListObjectsOptions {
prefix: "logs/".into(),
..Default::default()
};
assert!(ok.validate().is_ok());
let empty = ListObjectsOptions::default();
assert!(empty.validate().is_ok());
}
#[test]
fn dial_timeout_zero_is_twenty_seconds() {
let c = Config {
dial_timeout: Some(Duration::ZERO),
..Default::default()
};
assert_eq!(c.dial_timeout_or_default(), Duration::from_secs(20));
assert_eq!(
Config::default().dial_timeout_or_default(),
Duration::from_secs(20)
);
assert_eq!(Config::default().concurrent_segments_or_default(), 10);
assert_eq!(
Config {
concurrent_segments: Some(0),
..Default::default()
}
.concurrent_segments_or_default(),
10
);
assert_eq!(
Config {
concurrent_segments: Some(4),
..Default::default()
}
.concurrent_segments_or_default(),
4
);
}
#[test]
fn download_hedge_delay_preserves_zero_as_disabled() {
assert_eq!(
Config::default().download_hedge_delay_or_default(),
Duration::from_secs(1)
);
for delay in [Duration::ZERO, Duration::from_millis(500)] {
let config = Config {
download_hedge_delay: Some(delay),
..Default::default()
};
assert_eq!(config.download_hedge_delay_or_default(), delay);
}
}
#[test]
fn checksum_algorithm_proto_round_trip() {
for algo in [
ObjectChecksumAlgorithm::None,
ObjectChecksumAlgorithm::Crc32,
ObjectChecksumAlgorithm::Crc32c,
ObjectChecksumAlgorithm::Crc64Nvme,
ObjectChecksumAlgorithm::Sha1,
ObjectChecksumAlgorithm::Sha256,
] {
assert_eq!(ObjectChecksumAlgorithm::from_proto(algo.to_proto()), algo);
}
assert_eq!(
ObjectChecksumAlgorithm::default(),
ObjectChecksumAlgorithm::None
);
assert_eq!(
ObjectChecksumAlgorithm::from_proto(99),
ObjectChecksumAlgorithm::None
);
assert_eq!(UploadOptions::default().checksum, None);
assert_eq!(CommitUploadOptions::default().checksum, None);
}
}