use crate::io::walk::FsWalker;
use crate::types::FailedTransferPolicy;
use aws_smithy_types::error::operation::BuildError;
use std::path::{Path, PathBuf};
#[non_exhaustive]
#[derive(Clone, Debug)]
pub struct UploadObjectsInput {
pub bucket: Option<String>,
pub source: Option<PathBuf>,
pub walker: Option<FsWalker>,
pub key_prefix: Option<String>,
pub delimiter: Option<String>,
pub failure_policy: FailedTransferPolicy,
pub max_concurrent_uploads: usize,
}
impl UploadObjectsInput {
pub fn builder() -> UploadObjectsInputBuilder {
UploadObjectsInputBuilder::default()
}
pub fn bucket(&self) -> Option<&str> {
self.bucket.as_deref()
}
pub fn source(&self) -> Option<&Path> {
self.source.as_deref()
}
pub fn walker(&self) -> Option<&FsWalker> {
self.walker.as_ref()
}
pub fn key_prefix(&self) -> Option<&str> {
self.key_prefix.as_deref()
}
pub fn delimiter(&self) -> Option<&str> {
self.delimiter.as_deref()
}
pub fn failure_policy(&self) -> &FailedTransferPolicy {
&self.failure_policy
}
pub fn max_concurrent_uploads(&self) -> usize {
self.max_concurrent_uploads
}
}
#[non_exhaustive]
#[derive(Clone, Default, Debug)]
pub struct UploadObjectsInputBuilder {
pub(crate) bucket: Option<String>,
pub(crate) source: Option<PathBuf>,
pub(crate) walker: Option<FsWalker>,
pub(crate) key_prefix: Option<String>,
pub(crate) delimiter: Option<String>,
pub(crate) failure_policy: FailedTransferPolicy,
pub(crate) max_concurrent_uploads: Option<usize>,
}
impl UploadObjectsInputBuilder {
pub fn build(self) -> Result<UploadObjectsInput, BuildError> {
if self.bucket.is_none() {
return Err(BuildError::missing_field("bucket", "A bucket is required"));
}
if self.source.is_none() {
return Err(BuildError::missing_field(
"source",
"Source directory to upload is required",
));
}
Ok(UploadObjectsInput {
bucket: self.bucket,
source: self.source,
walker: self.walker,
key_prefix: self.key_prefix,
delimiter: self.delimiter,
failure_policy: self.failure_policy,
max_concurrent_uploads: self
.max_concurrent_uploads
.map(|n| n.max(1))
.unwrap_or(crate::operation::DEFAULT_MAX_CONCURRENT_CHILDREN),
})
}
pub fn bucket(mut self, input: impl Into<String>) -> Self {
self.bucket = Some(input.into());
self
}
pub fn set_bucket(mut self, input: Option<String>) -> Self {
self.bucket = input;
self
}
pub fn get_bucket(&self) -> Option<&str> {
self.bucket.as_deref()
}
pub fn source(mut self, input: impl Into<PathBuf>) -> Self {
self.source = Some(input.into());
self
}
pub fn set_source(mut self, input: Option<PathBuf>) -> Self {
self.source = input;
self
}
pub fn get_source(&self) -> Option<&Path> {
self.source.as_deref()
}
pub fn walker(mut self, input: FsWalker) -> Self {
self.walker = Some(input);
self
}
pub fn set_walker(mut self, input: Option<FsWalker>) -> Self {
self.walker = input;
self
}
pub fn get_walker(&self) -> Option<&FsWalker> {
self.walker.as_ref()
}
pub fn key_prefix(mut self, input: impl Into<String>) -> Self {
self.key_prefix = Some(input.into());
self
}
pub fn set_key_prefix(mut self, input: Option<String>) -> Self {
self.key_prefix = input;
self
}
pub fn get_key_prefix(&self) -> Option<&str> {
self.key_prefix.as_deref()
}
pub fn delimiter(mut self, input: impl Into<String>) -> Self {
self.delimiter = Some(input.into());
self
}
pub fn set_delimiter(mut self, input: Option<String>) -> Self {
self.delimiter = input;
self
}
pub fn get_delimiter(&self) -> Option<&str> {
self.delimiter.as_deref()
}
pub fn failure_policy(mut self, input: FailedTransferPolicy) -> Self {
self.failure_policy = input;
self
}
pub fn set_failure_policy(mut self, input: Option<FailedTransferPolicy>) -> Self {
self.failure_policy = input.unwrap_or_default();
self
}
pub fn get_failure_policy(&self) -> &FailedTransferPolicy {
&self.failure_policy
}
pub fn max_concurrent_uploads(mut self, input: usize) -> Self {
self.max_concurrent_uploads = Some(input);
self
}
pub fn set_max_concurrent_uploads(mut self, input: Option<usize>) -> Self {
self.max_concurrent_uploads = input;
self
}
pub fn get_max_concurrent_uploads(&self) -> Option<usize> {
self.max_concurrent_uploads
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn max_concurrent_uploads_zero_clamped_to_one() {
let input = UploadObjectsInputBuilder::default()
.bucket("test-bucket")
.source("/tmp/test")
.max_concurrent_uploads(0)
.build()
.expect("valid input");
assert_eq!(
1,
input.max_concurrent_uploads(),
"an explicit 0 must be clamped to 1 to avoid wedging the transfer"
);
}
#[test]
fn max_concurrent_uploads_none_uses_default() {
let input = UploadObjectsInputBuilder::default()
.bucket("test-bucket")
.source("/tmp/test")
.build()
.expect("valid input");
assert_eq!(
crate::operation::DEFAULT_MAX_CONCURRENT_CHILDREN,
input.max_concurrent_uploads(),
);
}
#[test]
fn max_concurrent_uploads_nonzero_preserved() {
let input = UploadObjectsInputBuilder::default()
.bucket("test-bucket")
.source("/tmp/test")
.max_concurrent_uploads(4)
.build()
.expect("valid input");
assert_eq!(4, input.max_concurrent_uploads());
}
#[test]
fn set_failure_policy_replaces_and_none_restores_default() {
let builder = UploadObjectsInput::builder()
.bucket("test-bucket")
.source("/tmp/test")
.set_failure_policy(Some(FailedTransferPolicy::Continue));
assert_eq!(
builder.get_failure_policy(),
&FailedTransferPolicy::Continue
);
let input = builder
.set_failure_policy(None)
.build()
.expect("valid input");
assert_eq!(input.failure_policy(), &FailedTransferPolicy::Abort);
}
}