You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@opendal.apache.org by xu...@apache.org on 2026/03/18 10:48:30 UTC
(opendal-reqsign) 01/01: refactor(aws-v4): migrate default credential builder
This is an automated email from the ASF dual-hosted git repository.
xuanwo pushed a commit to branch xuanwo/default-provider-api-aws-v4
in repository https://gitbox.apache.org/repos/asf/opendal-reqsign.git
commit 5f92f48ad31ece6d34e040161787e36396fd330e
Author: Xuanwo <gi...@xuanwo.io>
AuthorDate: Wed Mar 18 18:48:16 2026 +0800
refactor(aws-v4): migrate default credential builder
---
services/aws-v4/src/lib.rs | 12 +
services/aws-v4/src/provide_credential/default.rs | 331 ++++++++++------------
2 files changed, 158 insertions(+), 185 deletions(-)
diff --git a/services/aws-v4/src/lib.rs b/services/aws-v4/src/lib.rs
index 9d3eb26..4179ed9 100644
--- a/services/aws-v4/src/lib.rs
+++ b/services/aws-v4/src/lib.rs
@@ -100,6 +100,18 @@
//! .with_profile("production"));
//! ```
//!
+//! ### Customizing DefaultCredentialProvider Slots
+//!
+//! ```no_run
+//! use reqsign_aws_v4::{DefaultCredentialProvider, ProfileCredentialProvider};
+//!
+//! let provider = DefaultCredentialProvider::builder()
+//! .no_env()
+//! .profile(ProfileCredentialProvider::new().with_profile("production"))
+//! .no_imds()
+//! .build();
+//! ```
+//!
//! ### Custom Credential Provider
//!
//! You can create custom credential providers by implementing the `ProvideCredential` trait:
diff --git a/services/aws-v4/src/provide_credential/default.rs b/services/aws-v4/src/provide_credential/default.rs
index adde860..8f57472 100644
--- a/services/aws-v4/src/provide_credential/default.rs
+++ b/services/aws-v4/src/provide_credential/default.rs
@@ -86,190 +86,127 @@ impl DefaultCredentialProvider {
/// Builder for `DefaultCredentialProvider`.
///
-/// Use `configure_*` to customize provider behavior and `disable_*(bool)` to
-/// include or exclude providers from the default chain. Call `build()` to
-/// construct the provider.
-#[derive(Default)]
+/// Use `slot(provider)` to override a default slot and `no_slot()` to remove it
+/// from the default chain. Call `build()` to construct the provider.
pub struct DefaultCredentialProviderBuilder {
env: Option<EnvCredentialProvider>,
profile: Option<ProfileCredentialProvider>,
#[cfg(not(target_arch = "wasm32"))]
sso: Option<SSOCredentialProvider>,
- assume_role: Option<AssumeRoleWithWebIdentityCredentialProvider>,
+ web_identity: Option<AssumeRoleWithWebIdentityCredentialProvider>,
#[cfg(not(target_arch = "wasm32"))]
process: Option<ProcessCredentialProvider>,
ecs: Option<ECSCredentialProvider>,
imds: Option<IMDSv2CredentialProvider>,
}
+impl Default for DefaultCredentialProviderBuilder {
+ fn default() -> Self {
+ Self {
+ env: Some(EnvCredentialProvider::default()),
+ profile: Some(ProfileCredentialProvider::default()),
+ #[cfg(not(target_arch = "wasm32"))]
+ sso: Some(SSOCredentialProvider::default()),
+ web_identity: Some(AssumeRoleWithWebIdentityCredentialProvider::default()),
+ #[cfg(not(target_arch = "wasm32"))]
+ process: Some(ProcessCredentialProvider::default()),
+ ecs: Some(ECSCredentialProvider::default()),
+ imds: Some(IMDSv2CredentialProvider::default()),
+ }
+ }
+}
+
impl DefaultCredentialProviderBuilder {
/// Create a new builder with default state.
pub fn new() -> Self {
Self::default()
}
- /// Configure the environment credential provider.
- pub fn configure_env<F>(mut self, f: F) -> Self
- where
- F: FnOnce(EnvCredentialProvider) -> EnvCredentialProvider,
- {
- let p = self.env.take().unwrap_or_default();
- self.env = Some(f(p));
+ /// Override the environment credential provider slot.
+ pub fn env(mut self, provider: EnvCredentialProvider) -> Self {
+ self.env = Some(provider);
self
}
- /// Disable (true) or ensure enabled (false) the environment provider.
- pub fn disable_env(mut self, disable: bool) -> Self {
- if disable {
- self.env = None;
- } else if self.env.is_none() {
- self.env = Some(EnvCredentialProvider::new());
- }
+ /// Remove the environment credential provider from the chain.
+ pub fn no_env(mut self) -> Self {
+ self.env = None;
self
}
- /// Configure the profile credential provider.
- pub fn configure_profile<F>(mut self, f: F) -> Self
- where
- F: FnOnce(ProfileCredentialProvider) -> ProfileCredentialProvider,
- {
- let p = self.profile.take().unwrap_or_default();
- self.profile = Some(f(p));
+ /// Override the profile credential provider slot.
+ pub fn profile(mut self, provider: ProfileCredentialProvider) -> Self {
+ self.profile = Some(provider);
self
}
- /// Disable (true) or ensure enabled (false) the profile provider.
- pub fn disable_profile(mut self, disable: bool) -> Self {
- if disable {
- self.profile = None;
- } else if self.profile.is_none() {
- self.profile = Some(ProfileCredentialProvider::new());
- }
+ /// Remove the profile credential provider from the chain.
+ pub fn no_profile(mut self) -> Self {
+ self.profile = None;
self
}
- /// Configure the SSO credential provider.
- ///
- /// This customizes how AWS SSO (IAM Identity Center) credentials are
- /// discovered and exchanged from local SSO caches. Typical use cases
- /// include setting an alternative endpoint for testing, or overriding the
- /// profile-derived values. This method is only available for non-wasm32
- /// targets where process and filesystem access is supported.
+ /// Override the SSO credential provider slot.
#[cfg(not(target_arch = "wasm32"))]
- pub fn configure_sso<F>(mut self, f: F) -> Self
- where
- F: FnOnce(SSOCredentialProvider) -> SSOCredentialProvider,
- {
- let p = self.sso.take().unwrap_or_default();
- self.sso = Some(f(p));
+ pub fn sso(mut self, provider: SSOCredentialProvider) -> Self {
+ self.sso = Some(provider);
self
}
- /// Disable (true) or ensure enabled (false) the SSO provider.
- ///
- /// Use this to explicitly remove SSO from the default credential
- /// resolution chain (disable = true) or ensure it participates (disable = false).
- /// This is useful in controlled environments (e.g., CI) or when SSO is
- /// not configured. Only available on non-wasm32 targets.
+ /// Remove the SSO credential provider from the chain.
#[cfg(not(target_arch = "wasm32"))]
- pub fn disable_sso(mut self, disable: bool) -> Self {
- if disable {
- self.sso = None;
- } else if self.sso.is_none() {
- self.sso = Some(SSOCredentialProvider::new());
- }
+ pub fn no_sso(mut self) -> Self {
+ self.sso = None;
self
}
- /// Configure the web-identity assume-role credential provider.
- pub fn configure_assume_role<F>(mut self, f: F) -> Self
- where
- F: FnOnce(
- AssumeRoleWithWebIdentityCredentialProvider,
- ) -> AssumeRoleWithWebIdentityCredentialProvider,
- {
- let p = self.assume_role.take().unwrap_or_default();
- self.assume_role = Some(f(p));
+ /// Override the web-identity credential provider slot.
+ pub fn web_identity(mut self, provider: AssumeRoleWithWebIdentityCredentialProvider) -> Self {
+ self.web_identity = Some(provider);
self
}
- /// Disable (true) or ensure enabled (false) the assume role provider.
- pub fn disable_assume_role(mut self, disable: bool) -> Self {
- if disable {
- self.assume_role = None;
- } else if self.assume_role.is_none() {
- self.assume_role = Some(AssumeRoleWithWebIdentityCredentialProvider::new());
- }
+ /// Remove the web-identity credential provider from the chain.
+ pub fn no_web_identity(mut self) -> Self {
+ self.web_identity = None;
self
}
- /// Configure the external process credential provider.
- ///
- /// This allows overriding the profile-derived command used to obtain
- /// credentials via `credential_process`. Only available on non-wasm32
- /// targets.
+ /// Override the external process credential provider slot.
#[cfg(not(target_arch = "wasm32"))]
- pub fn configure_process<F>(mut self, f: F) -> Self
- where
- F: FnOnce(ProcessCredentialProvider) -> ProcessCredentialProvider,
- {
- let p = self.process.take().unwrap_or_default();
- self.process = Some(f(p));
+ pub fn process(mut self, provider: ProcessCredentialProvider) -> Self {
+ self.process = Some(provider);
self
}
- /// Disable (true) or ensure enabled (false) the process provider.
- ///
- /// Use this to explicitly remove the external process credential source
- /// (disable = true) or ensure it participates (disable = false). This is
- /// only meaningful on non-wasm32 targets.
+ /// Remove the external process credential provider from the chain.
#[cfg(not(target_arch = "wasm32"))]
- pub fn disable_process(mut self, disable: bool) -> Self {
- if disable {
- self.process = None;
- } else if self.process.is_none() {
- self.process = Some(ProcessCredentialProvider::new());
- }
+ pub fn no_process(mut self) -> Self {
+ self.process = None;
self
}
- /// Configure the ECS (container/task) credential provider.
- pub fn configure_ecs<F>(mut self, f: F) -> Self
- where
- F: FnOnce(ECSCredentialProvider) -> ECSCredentialProvider,
- {
- let p = self.ecs.take().unwrap_or_default();
- self.ecs = Some(f(p));
+ /// Override the ECS credential provider slot.
+ pub fn ecs(mut self, provider: ECSCredentialProvider) -> Self {
+ self.ecs = Some(provider);
self
}
- /// Disable (true) or ensure enabled (false) the ECS provider.
- pub fn disable_ecs(mut self, disable: bool) -> Self {
- if disable {
- self.ecs = None;
- } else if self.ecs.is_none() {
- self.ecs = Some(ECSCredentialProvider::new());
- }
+ /// Remove the ECS credential provider from the chain.
+ pub fn no_ecs(mut self) -> Self {
+ self.ecs = None;
self
}
- /// Configure the EC2 IMDSv2 credential provider.
- pub fn configure_imds<F>(mut self, f: F) -> Self
- where
- F: FnOnce(IMDSv2CredentialProvider) -> IMDSv2CredentialProvider,
- {
- let p = self.imds.take().unwrap_or_default();
- self.imds = Some(f(p));
+ /// Override the EC2 IMDSv2 credential provider slot.
+ pub fn imds(mut self, provider: IMDSv2CredentialProvider) -> Self {
+ self.imds = Some(provider);
self
}
- /// Disable (true) or ensure enabled (false) the IMDSv2 provider.
- pub fn disable_imds(mut self, disable: bool) -> Self {
- if disable {
- self.imds = None;
- } else if self.imds.is_none() {
- self.imds = Some(IMDSv2CredentialProvider::new());
- }
+ /// Remove the EC2 IMDSv2 credential provider from the chain.
+ pub fn no_imds(mut self) -> Self {
+ self.imds = None;
self
}
@@ -279,50 +216,36 @@ impl DefaultCredentialProviderBuilder {
if let Some(p) = self.env {
chain = chain.push(p);
- } else {
- chain = chain.push(EnvCredentialProvider::new());
}
if let Some(p) = self.profile {
chain = chain.push(p);
- } else {
- chain = chain.push(ProfileCredentialProvider::new());
}
#[cfg(not(target_arch = "wasm32"))]
{
if let Some(p) = self.sso {
chain = chain.push(p);
- } else {
- chain = chain.push(SSOCredentialProvider::new());
}
}
- if let Some(p) = self.assume_role {
+ if let Some(p) = self.web_identity {
chain = chain.push(p);
- } else {
- chain = chain.push(AssumeRoleWithWebIdentityCredentialProvider::new());
}
#[cfg(not(target_arch = "wasm32"))]
{
if let Some(p) = self.process {
chain = chain.push(p);
- } else {
- chain = chain.push(ProcessCredentialProvider::new());
}
}
if let Some(p) = self.ecs {
chain = chain.push(p);
- } else {
- chain = chain.push(ECSCredentialProvider::new());
}
if let Some(p) = self.imds {
chain = chain.push(p);
- } else {
- chain = chain.push(IMDSv2CredentialProvider::new());
}
DefaultCredentialProvider::with_chain(chain)
@@ -361,7 +284,17 @@ mod tests {
envs: HashMap::new(),
});
- let l = DefaultCredentialProvider::new();
+ let builder = DefaultCredentialProvider::builder()
+ .no_profile()
+ .no_web_identity()
+ .no_ecs()
+ .no_imds();
+ #[cfg(not(target_arch = "wasm32"))]
+ let builder = builder.no_sso().no_process();
+ #[cfg(target_arch = "wasm32")]
+ let builder = builder;
+
+ let l = builder.build();
let x = l.provide_credential(&ctx).await.expect("load must succeed");
assert!(x.is_none());
}
@@ -393,6 +326,45 @@ mod tests {
assert_eq!("secret_access_key", x.secret_access_key);
}
+ #[tokio::test]
+ async fn test_default_credential_provider_no_env_removes_slot() {
+ let _ = env_logger::builder().is_test(true).try_init();
+
+ let ctx = Context::new()
+ .with_file_read(TokioFileRead)
+ .with_http_send(ReqwestHttpSend::default())
+ .with_env(OsEnv);
+ let ctx = ctx.with_env(StaticEnv {
+ home_dir: None,
+ envs: HashMap::from_iter([
+ (AWS_ACCESS_KEY_ID.to_string(), "access_key_id".to_string()),
+ (
+ AWS_SECRET_ACCESS_KEY.to_string(),
+ "secret_access_key".to_string(),
+ ),
+ ]),
+ });
+
+ let builder = DefaultCredentialProvider::builder()
+ .no_env()
+ .no_profile()
+ .no_imds()
+ .no_ecs()
+ .no_web_identity();
+ #[cfg(not(target_arch = "wasm32"))]
+ let builder = builder.no_sso().no_process();
+ #[cfg(target_arch = "wasm32")]
+ let builder = builder;
+
+ let provider = builder.build();
+
+ let cred = provider
+ .provide_credential(&ctx)
+ .await
+ .expect("load must succeed");
+ assert!(cred.is_none());
+ }
+
#[tokio::test]
async fn test_credential_profile_loader_from_config() {
let _ = env_logger::builder().is_test(true).try_init();
@@ -508,7 +480,7 @@ mod tests {
}
#[tokio::test]
- async fn test_default_credential_provider_configure_imds() {
+ async fn test_default_credential_provider_no_profile_removes_slot() {
let _ = env_logger::builder().is_test(true).try_init();
let ctx = Context::new()
@@ -517,31 +489,40 @@ mod tests {
.with_env(OsEnv);
let ctx = ctx.with_env(StaticEnv {
home_dir: None,
- envs: HashMap::new(),
+ envs: HashMap::from_iter([
+ (
+ AWS_CONFIG_FILE.to_string(),
+ format!(
+ "{}/testdata/default_config",
+ env::current_dir()
+ .expect("current_dir must exist")
+ .to_string_lossy()
+ ),
+ ),
+ (
+ AWS_SHARED_CREDENTIALS_FILE.to_string(),
+ format!(
+ "{}/testdata/not_exist",
+ env::current_dir()
+ .expect("current_dir must exist")
+ .to_string_lossy()
+ ),
+ ),
+ ]),
});
- // Build a custom chain with IMDS disabled
- let mut chain = ProvideCredentialChain::new()
- .push(EnvCredentialProvider::new())
- .push(ProfileCredentialProvider::new());
-
+ let builder = DefaultCredentialProvider::builder()
+ .no_profile()
+ .no_imds()
+ .no_ecs()
+ .no_web_identity();
#[cfg(not(target_arch = "wasm32"))]
- {
- chain = chain.push(SSOCredentialProvider::new());
- }
+ let builder = builder.no_sso().no_process();
+ #[cfg(target_arch = "wasm32")]
+ let builder = builder;
- chain = chain.push(AssumeRoleWithWebIdentityCredentialProvider::new());
+ let provider = builder.build();
- #[cfg(not(target_arch = "wasm32"))]
- {
- chain = chain.push(ProcessCredentialProvider::new());
- }
-
- chain = chain.push(ECSCredentialProvider::new());
-
- let provider = DefaultCredentialProvider::with_chain(chain);
-
- // Even though IMDS is the last provider, it should return None when disabled
let cred = provider
.provide_credential(&ctx)
.await
@@ -550,7 +531,7 @@ mod tests {
}
#[tokio::test]
- async fn test_default_credential_provider_configure_profile() {
+ async fn test_default_credential_provider_custom_profile_slot() {
let _ = env_logger::builder().is_test(true).try_init();
let ctx = Context::new()
@@ -570,34 +551,14 @@ mod tests {
.to_string_lossy()
);
- let mut chain = ProvideCredentialChain::new().push(EnvCredentialProvider::new());
-
- chain = chain.push(ProfileCredentialProvider::new().with_config_file(custom_config));
-
- #[cfg(not(target_arch = "wasm32"))]
- {
- chain = chain.push(SSOCredentialProvider::new());
- }
-
- chain = chain.push(AssumeRoleWithWebIdentityCredentialProvider::new());
-
- #[cfg(not(target_arch = "wasm32"))]
- {
- chain = chain.push(ProcessCredentialProvider::new());
- }
-
- chain = chain
- .push(ECSCredentialProvider::new())
- .push(IMDSv2CredentialProvider::new());
-
- let provider = DefaultCredentialProvider::with_chain(chain);
+ let provider = DefaultCredentialProvider::builder()
+ .profile(ProfileCredentialProvider::new().with_config_file(custom_config))
+ .build();
- // Should load from the custom config
let cred = provider
.provide_credential(&ctx)
.await
.expect("load must succeed");
- // The testdata/default_config has credentials
let cred = cred.expect("credential should exist");
assert_eq!("config_access_key_id", cred.access_key_id);
assert_eq!("config_secret_access_key", cred.secret_access_key);