use aws_smithy_types::error::operation::BuildError;
use std::cmp;
use crate::types::ByteSize;
mod runtime;
pub use runtime::{
ConcurrencyMode, Managed, MemoryBudgetConfig, MemoryConfig, RuntimeConfig, TargetThroughput,
};
mod diagnostics;
pub(crate) use diagnostics::{
DiagnosticsConfig, MemoryDiagnosticsConfig, TransferDiagnosticsConfig,
};
mod loader;
pub use loader::ConfigLoader;
pub(crate) mod user_agent;
pub(crate) const MIN_MULTIPART_PART_SIZE: ByteSize = ByteSize::mib(5);
#[non_exhaustive]
#[derive(Debug, Clone, Default)]
pub enum PartSize {
#[default]
Auto,
Target(ByteSize),
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub enum ReadAhead {
#[default]
Auto,
Parts(usize),
}
pub struct S3ClientConfig {
pub(crate) config: aws_sdk_s3::Config,
}
impl S3ClientConfig {
pub fn new(config: impl Into<Self>) -> Self {
config.into()
}
pub(crate) fn from_sdk_builder(builder: aws_sdk_s3::config::Builder) -> Self {
Self {
config: builder.build(),
}
}
}
impl From<&aws_types::SdkConfig> for S3ClientConfig {
fn from(sdk_config: &aws_types::SdkConfig) -> Self {
Self::from_sdk_builder(aws_sdk_s3::config::Builder::from(sdk_config))
}
}
#[cfg(feature = "sdk-v1")]
impl From<aws_sdk_s3::config::Builder> for S3ClientConfig {
fn from(builder: aws_sdk_s3::config::Builder) -> Self {
Self::from_sdk_builder(builder)
}
}
impl std::fmt::Debug for S3ClientConfig {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("S3ClientConfig").finish_non_exhaustive()
}
}
#[derive(Debug)]
pub(crate) enum S3ClientSource {
Provided(aws_sdk_s3::Client),
FromConfig(Box<S3ClientConfig>),
}
#[derive(Debug)]
pub struct Config {
multipart_threshold: PartSize,
target_part_size: PartSize,
concurrency: ConcurrencyMode,
runtime_config: RuntimeConfig,
read_ahead: ReadAhead,
memory: MemoryConfig,
diagnostics: DiagnosticsConfig,
s3_client_source: Option<S3ClientSource>,
machine_profile: Option<crate::runtime::platform::MachineProfile>,
pub(crate) network_interfaces: Vec<String>,
}
impl Config {
pub fn builder() -> Builder {
Builder::default()
}
pub fn multipart_threshold(&self) -> &PartSize {
&self.multipart_threshold
}
pub fn part_size(&self) -> &PartSize {
&self.target_part_size
}
pub fn concurrency(&self) -> &ConcurrencyMode {
&self.concurrency
}
pub(crate) fn throughput_target_gbps(&self) -> Option<f64> {
match &self.concurrency {
ConcurrencyMode::TargetThroughput(target) => Some(target.as_gbps()),
_ => None,
}
}
pub fn runtime_config(&self) -> &RuntimeConfig {
&self.runtime_config
}
#[cfg(not(target_family = "wasm"))]
pub(crate) fn managed_config_mut(&mut self) -> Option<&mut Managed> {
self.runtime_config.managed_config_mut()
}
pub fn read_ahead(&self) -> &ReadAhead {
&self.read_ahead
}
pub fn memory(&self) -> &MemoryConfig {
&self.memory
}
pub(crate) fn diagnostics(&self) -> DiagnosticsConfig {
self.diagnostics
}
pub(crate) fn machine_profile(&self) -> Option<&crate::runtime::platform::MachineProfile> {
self.machine_profile.as_ref()
}
pub(crate) fn runtime_http(
&self,
max_connections_per_host: usize,
) -> Option<crate::runtime::RuntimeHttpOptions> {
if cfg!(target_family = "wasm") {
return None;
}
match self.s3_client_source.as_ref()? {
S3ClientSource::FromConfig(config)
if self.runtime_config.managed_config().is_some()
&& config.config.http_client().is_none() =>
{
Some(crate::runtime::RuntimeHttpOptions {
network_interfaces: self.network_interfaces.clone(),
max_connections_per_host,
})
}
_ => None,
}
}
pub(crate) fn take_s3_client_source(&mut self) -> S3ClientSource {
self.s3_client_source
.take()
.expect("s3 client source already taken")
}
}
#[derive(Debug, Default)]
pub struct Builder {
multipart_threshold_part_size: PartSize,
target_part_size: PartSize,
concurrency: ConcurrencyMode,
runtime_config: RuntimeConfig,
read_ahead: ReadAhead,
memory: MemoryConfig,
diagnostics: Option<DiagnosticsConfig>,
client: Option<aws_sdk_s3::Client>,
s3_client_config: Option<S3ClientConfig>,
machine_profile: Option<crate::runtime::platform::MachineProfile>,
}
impl Builder {
pub fn multipart_threshold(self, threshold: PartSize) -> Self {
let threshold = match threshold {
PartSize::Target(part_size) => {
PartSize::Target(cmp::max(part_size, MIN_MULTIPART_PART_SIZE))
}
tps => tps,
};
self.set_multipart_threshold(threshold)
}
pub fn part_size(self, part_size: PartSize) -> Self {
let threshold = match part_size {
PartSize::Target(part_size) => {
PartSize::Target(cmp::max(part_size, MIN_MULTIPART_PART_SIZE))
}
tps => tps,
};
self.set_target_part_size(threshold)
}
pub(crate) fn set_multipart_threshold(mut self, threshold: PartSize) -> Self {
self.multipart_threshold_part_size = threshold;
self
}
pub(crate) fn set_target_part_size(mut self, threshold: PartSize) -> Self {
self.target_part_size = threshold;
self
}
pub fn concurrency(mut self, mode: ConcurrencyMode) -> Self {
self.concurrency = mode;
self
}
pub fn runtime_config(mut self, config: RuntimeConfig) -> Self {
self.set_runtime_config(Some(config));
self
}
pub fn set_runtime_config(&mut self, config: Option<RuntimeConfig>) -> &mut Self {
self.runtime_config = config.unwrap_or_default();
self
}
pub fn read_ahead(mut self, mode: ReadAhead) -> Self {
self.read_ahead = mode;
self
}
pub fn memory(mut self, memory: MemoryConfig) -> Self {
self.memory = memory;
self
}
#[cfg(test)]
pub(crate) fn diagnostics_for_test(
mut self,
memory: MemoryDiagnosticsConfig,
transfer_detail_level: u64,
) -> Self {
self.diagnostics = Some(DiagnosticsConfig::for_test(memory, transfer_detail_level));
self
}
#[cfg(test)]
pub(crate) fn sdk_client(mut self, client: aws_sdk_s3::Client) -> Self {
self.client = Some(client);
self
}
pub fn s3_config(mut self, config: impl Into<S3ClientConfig>) -> Self {
self.s3_client_config = Some(config.into());
self
}
pub(crate) fn machine_profile(
mut self,
profile: Option<crate::runtime::platform::MachineProfile>,
) -> Self {
self.machine_profile = profile;
self
}
pub fn build(self) -> Result<Config, BuildError> {
let s3_client_source = match (self.client, self.s3_client_config) {
(Some(client), _) => S3ClientSource::Provided(client),
(None, Some(config)) => S3ClientSource::FromConfig(Box::new(config)),
(None, None) => {
return Err(BuildError::missing_field(
"s3_config",
"S3 client configuration is required",
))
}
};
Ok(Config {
multipart_threshold: self.multipart_threshold_part_size,
target_part_size: self.target_part_size,
concurrency: self.concurrency,
runtime_config: self.runtime_config,
read_ahead: self.read_ahead,
memory: self.memory,
diagnostics: self.diagnostics.unwrap_or_else(DiagnosticsConfig::from_env),
s3_client_source: Some(s3_client_source),
machine_profile: self.machine_profile,
network_interfaces: Vec::new(),
})
}
}
#[cfg(test)]
mod tests {
use super::*;
fn s3_config_builder() -> aws_sdk_s3::config::Builder {
aws_sdk_s3::config::Builder::new()
}
#[test]
fn s3_client_config_converts_from_sdk_config_and_builder() {
let region = aws_types::region::Region::from_static("us-west-2");
let sdk_config = aws_types::SdkConfig::builder()
.region(region.clone())
.build();
let from_sdk = S3ClientConfig::from(&sdk_config);
assert_eq!(from_sdk.config.region(), Some(®ion));
let builder = s3_config_builder().region(region.clone());
#[cfg(feature = "sdk-v1")]
let from_builder = S3ClientConfig::new(builder);
#[cfg(not(feature = "sdk-v1"))]
let from_builder = S3ClientConfig::from_sdk_builder(builder);
assert_eq!(from_builder.config.region(), Some(®ion));
}
#[test]
fn runtime_http_present_for_s3_config() {
let config = Config::builder()
.s3_config(S3ClientConfig::from_sdk_builder(s3_config_builder()))
.build()
.expect("valid config");
let http = config.runtime_http(64).expect("runtime HTTP enabled");
assert!(http.network_interfaces.is_empty());
assert_eq!(http.max_connections_per_host, 64);
}
#[test]
fn runtime_http_absent_without_runtime_transport() {
let shared = Config::builder()
.s3_config(S3ClientConfig::from_sdk_builder(s3_config_builder()))
.runtime_config(RuntimeConfig::multi_thread_tokio())
.build()
.expect("valid config");
assert!(shared.runtime_http(64).is_none());
let configured = Config::builder()
.s3_config(S3ClientConfig::from_sdk_builder(
aws_smithy_mocks::mock_client!(aws_sdk_s3, [])
.config()
.to_builder(),
))
.build()
.expect("valid config");
assert!(configured.runtime_http(64).is_none());
let provided = Config::builder()
.sdk_client(aws_smithy_mocks::mock_client!(aws_sdk_s3, []))
.build()
.expect("valid config");
assert!(provided.runtime_http(64).is_none());
}
#[test]
fn build_without_s3_config_is_an_error() {
let error = Config::builder()
.build()
.expect_err("s3_config is required");
assert!(
error.to_string().contains("s3_config"),
"error does not name the missing field: {error}"
);
}
}