diff --git a/README.md b/README.md index 1e60a136..405e70a1 100644 --- a/README.md +++ b/README.md @@ -22,15 +22,14 @@ The simplest way to use `reqsign` is with the default signers provided by each s ```rust use anyhow::Result; -use reqsign::aws; +use reqsign::{aws, default_context}; #[tokio::main] async fn main() -> Result<()> { - // Create a default signer for S3 in us-east-1 - // This will automatically: - // - Load credentials from environment variables, config files, or IAM roles - // - Set up the default HTTP client and file reader - let signer = aws::default_signer("s3", "us-east-1"); + // Create a default runtime context (HTTP client, file reader, OS env, command execution) + let ctx = default_context(); + // Create a default signer for S3 in us-east-1 using the supplied context + let signer = aws::default_signer(ctx, "s3", "us-east-1"); // Build your request let mut req = http::Request::builder() @@ -100,15 +99,15 @@ async fn main() -> Result<()> { You can also customize the default signers using the `with_*` methods: ```rust -use reqsign::aws; +use reqsign::{aws, default_context}; use reqsign_aws_v4::StaticCredentialProvider; // Start with default signer and customize specific components -let signer = aws::default_signer("s3", "us-east-1") +let ctx = default_context(); +let signer = aws::default_signer(ctx, "s3", "us-east-1") .with_credential_provider(StaticCredentialProvider::new( "my-access-key", "my-secret-key", - None, // Optional session token )); ``` @@ -121,24 +120,28 @@ For server applications that already hold an OIDC assertion, see ```rust use reqsign::aws::v4a::{SigningRegionSet, default_signer}; +use reqsign::default_context; +let ctx = default_context(); let region_set = SigningRegionSet::new("us-east-1,us-west-2")?; -let signer = default_signer("s3", region_set); +let signer = default_signer(ctx, "s3", region_set); # Ok::<(), reqsign_core::Error>(()) ``` #### Azure Storage ```rust -use reqsign::azure; +use reqsign::{azure, default_context}; + +let ctx = default_context(); // Default signer for Azure Storage -let signer = azure::default_signer(); +let signer = azure::default_signer(ctx.clone()); // With custom credentials use reqsign_azure_storage::StaticCredentialProvider; -let signer = azure::default_signer() - .with_credential_provider(StaticCredentialProvider::new( +let signer = azure::default_signer(ctx) + .with_credential_provider(StaticCredentialProvider::new_shared_key( "account-name", "account-key", )); @@ -147,19 +150,21 @@ let signer = azure::default_signer() #### Google Cloud ```rust -use reqsign::google; +use reqsign::{default_context, google}; // Default signer for Google Cloud Storage -let signer = google::default_signer("storage.googleapis.com"); +let ctx = default_context(); +let signer = google::default_signer(ctx, "storage.googleapis.com"); ``` #### Aliyun OSS ```rust -use reqsign::aliyun; +use reqsign::{aliyun, default_context}; // Default signer for Aliyun OSS -let signer = aliyun::default_signer("mybucket"); +let ctx = default_context(); +let signer = aliyun::default_signer(ctx, "mybucket"); ``` ## Features diff --git a/core/src/signer.rs b/core/src/signer.rs index 168bf9f9..9e7da99c 100644 --- a/core/src/signer.rs +++ b/core/src/signer.rs @@ -65,10 +65,10 @@ impl Signer { } } - /// Replace the context while keeping the credential provider, request signer, - /// and shared credential cache. + /// Replace the context and create an isolated empty credential cache. pub fn with_context(mut self, ctx: Context) -> Self { self.ctx = ctx; + self.credential = Arc::new(Mutex::new(None)); self } @@ -83,7 +83,8 @@ impl Signer { self } - /// Replace the request signer while keeping context and credential provider. + /// Replace only the request signer, retaining the context, credential provider, + /// and shared credential cache. pub fn with_request_signer(mut self, signer: impl SignRequest) -> Self { self.builder = Arc::new(signer); self @@ -180,12 +181,12 @@ impl Signer { mod tests { use super::*; use crate::time::Timestamp; - use crate::{ErrorKind, ProvideCredential, SignRequest}; + use crate::{ErrorKind, ProvideCredential, SignRequest, StaticEnv}; use asyncband::oneshot; use futures::future::{join_all, pending}; use futures::poll; use http::{HeaderValue, Method, Request, Version}; - use std::collections::VecDeque; + use std::collections::{HashMap, VecDeque}; use std::sync::Mutex as StdMutex; use std::sync::atomic::{AtomicUsize, Ordering}; @@ -868,7 +869,7 @@ mod tests { let with_provider = signer.clone().with_credential_provider(StaticProvider); assert!(Arc::ptr_eq(&signer.credential, &clone.credential)); - assert!(Arc::ptr_eq(&signer.credential, &with_context.credential)); + assert!(!Arc::ptr_eq(&signer.credential, &with_context.credential)); assert!(Arc::ptr_eq( &signer.credential, &with_request_signer.credential @@ -876,6 +877,79 @@ mod tests { assert!(!Arc::ptr_eq(&signer.credential, &with_provider.credential)); } + #[test] + fn with_context_isolates_credential_cache() { + #[derive(Debug)] + struct EnvGenerationProvider { + calls: Arc, + base: Timestamp, + } + + impl ProvideCredential for EnvGenerationProvider { + type Credential = ExpiringCredential; + + async fn provide_credential(&self, ctx: &Context) -> Result> { + self.calls.fetch_add(1, Ordering::SeqCst); + let generation = ctx + .env_var("GENERATION") + .expect("generation env must be set") + .parse::() + .expect("generation env must be u8"); + Ok(Some(ExpiringCredential { + generation, + fresh: true, + expires_at: self.base + Duration::from_secs(60), + required_until: self.base + Duration::from_secs(10), + })) + } + } + + fn context_with_generation(generation: u8) -> Context { + Context::new().with_env(StaticEnv { + home_dir: None, + envs: HashMap::from([("GENERATION".to_string(), generation.to_string())]), + }) + } + + futures::executor::block_on(async { + let base = Timestamp::from_second(975).expect("timestamp must be valid"); + let calls = Arc::new(AtomicUsize::new(0)); + let signer_a = Signer::new( + context_with_generation(1), + EnvGenerationProvider { + calls: calls.clone(), + base, + }, + OperationSigner, + ); + + let mut req_a = request_parts(); + signer_a + .sign(&mut req_a, None) + .await + .expect("initial sign under context 1 must succeed"); + assert_eq!(req_a.headers["x-credential-generation"], "1"); + assert_eq!(calls.load(Ordering::SeqCst), 1); + + let signer_b = signer_a.clone().with_context(context_with_generation(2)); + let mut req_b = request_parts(); + signer_b + .sign(&mut req_b, None) + .await + .expect("sign after with_context must reload under context 2"); + assert_eq!(req_b.headers["x-credential-generation"], "2"); + assert_eq!(calls.load(Ordering::SeqCst), 2); + + let mut req_a_again = request_parts(); + signer_a + .sign(&mut req_a_again, None) + .await + .expect("original signer must retain its isolated cache"); + assert_eq!(req_a_again.headers["x-credential-generation"], "1"); + assert_eq!(calls.load(Ordering::SeqCst), 2); + }); + } + #[test] fn cancelled_refresh_releases_lock_and_waiter_retries() { futures::executor::block_on(async { diff --git a/docs/caller-provided-subject-tokens.md b/docs/caller-provided-subject-tokens.md index 15f9ce0a..01a3cef0 100644 --- a/docs/caller-provided-subject-tokens.md +++ b/docs/caller-provided-subject-tokens.md @@ -15,7 +15,7 @@ credential chain. Create a new provider and signer for each independently authenticated request identity. Cloned signers share their exchanged-credential cache, while -`Signer::with_credential_provider` creates a new empty cache. +`Signer::with_context` and `Signer::with_credential_provider` create a new empty cache. ```rust use reqsign::{Context, Signer, time::Timestamp}; diff --git a/reqsign/README.md b/reqsign/README.md index 9cc7d482..d706bef0 100644 --- a/reqsign/README.md +++ b/reqsign/README.md @@ -59,15 +59,14 @@ The easiest way to get started is using the default signers provided for each se ```rust,ignore use anyhow::Result; -use reqsign::aws; +use reqsign::{aws, default_context}; #[tokio::main] async fn main() -> Result<()> { - // Create a default signer for AWS S3 in us-east-1 - // This will automatically: - // - Set up HTTP client and file reader - // - Load credentials from environment, config files, or instance metadata - let signer = aws::default_signer("s3", "us-east-1"); + // Create a default runtime context (HTTP client, file reader, OS env, command execution) + let ctx = default_context(); + // Create a default signer for AWS S3 in us-east-1 using the supplied context + let signer = aws::default_signer(ctx, "s3", "us-east-1"); // Build and sign a request let mut req = http::Request::builder() @@ -136,14 +135,12 @@ You can customize the default signers using the `with_*` methods: use reqsign::aws; use reqsign::aws::StaticCredentialProvider; -// Start with default signer and customize components -let signer = aws::default_signer("s3", "us-east-1") +// Pass a custom context directly and customize components as needed +let signer = aws::default_signer(my_custom_context, "s3", "us-east-1") .with_credential_provider(StaticCredentialProvider::new( "my-access-key", "my-secret-key", - None, // Optional session token - )) - .with_context(my_custom_context); + )); ``` For server applications that already hold an OIDC assertion, see @@ -152,33 +149,35 @@ For server applications that already hold an OIDC assertion, see ### Examples for Other Services ```rust,ignore +let ctx = reqsign::default_context(); + // Azure Storage use reqsign::azure; -let signer = azure::default_signer(); +let signer = azure::default_signer(ctx.clone()); // Google Cloud use reqsign::google; -let signer = google::default_signer("storage.googleapis.com"); +let signer = google::default_signer(ctx.clone(), "storage.googleapis.com"); // Aliyun OSS use reqsign::aliyun; -let signer = aliyun::default_signer("mybucket"); +let signer = aliyun::default_signer(ctx.clone(), "mybucket"); // Huawei Cloud OBS use reqsign::huaweicloud; -let signer = huaweicloud::default_signer("mybucket"); +let signer = huaweicloud::default_signer(ctx.clone(), "mybucket"); // OpenStack Keystone use reqsign::openstack; -let signer = openstack::default_signer(); +let signer = openstack::default_signer(ctx.clone()); // Tencent COS use reqsign::tencent; -let signer = tencent::default_signer(); +let signer = tencent::default_signer(ctx.clone()); // Oracle Cloud use reqsign::oracle; -let signer = oracle::default_signer(); +let signer = oracle::default_signer(ctx); ``` ## Feature Flags diff --git a/reqsign/examples/aws.rs b/reqsign/examples/aws.rs index 93ec32aa..d9d294a8 100644 --- a/reqsign/examples/aws.rs +++ b/reqsign/examples/aws.rs @@ -20,9 +20,10 @@ use anyhow::Result; #[tokio::main] async fn main() -> Result<()> { // ANCHOR: quickstart - use reqsign::aws; + use reqsign::{aws, default_context}; // Create a default signer for S3 in us-east-1 - let signer = aws::default_signer("s3", "us-east-1"); + let ctx = default_context(); + let signer = aws::default_signer(ctx, "s3", "us-east-1"); // Build a request let mut req = http::Request::builder() diff --git a/reqsign/examples/azure.rs b/reqsign/examples/azure.rs index 30555ba5..6d7e7abf 100644 --- a/reqsign/examples/azure.rs +++ b/reqsign/examples/azure.rs @@ -20,9 +20,10 @@ use anyhow::Result; #[tokio::main] async fn main() -> Result<()> { // ANCHOR: quickstart - use reqsign::azure; + use reqsign::{azure, default_context}; // Create a default signer for Azure Storage - let signer = azure::default_signer(); + let ctx = default_context(); + let signer = azure::default_signer(ctx); // Build a request let mut req = http::Request::builder() diff --git a/reqsign/examples/google.rs b/reqsign/examples/google.rs index 64d7341a..81e620d0 100644 --- a/reqsign/examples/google.rs +++ b/reqsign/examples/google.rs @@ -20,9 +20,10 @@ use anyhow::Result; #[tokio::main] async fn main() -> Result<()> { // ANCHOR: quickstart - use reqsign::google; + use reqsign::{default_context, google}; // Create a default signer for Google Cloud Storage - let signer = google::default_signer("storage.googleapis.com"); + let ctx = default_context(); + let signer = google::default_signer(ctx, "storage.googleapis.com"); // Build a request let mut req = http::Request::builder() diff --git a/reqsign/examples/presign.rs b/reqsign/examples/presign.rs index 0a3973b4..a37a5e1e 100644 --- a/reqsign/examples/presign.rs +++ b/reqsign/examples/presign.rs @@ -15,12 +15,13 @@ // specific language governing permissions and limitations // under the License. -use reqsign::aws; +use reqsign::{aws, default_context}; use std::time::Duration; #[tokio::main] async fn main() -> anyhow::Result<()> { - let signer = aws::default_signer("s3", "us-east-1"); + let ctx = default_context(); + let signer = aws::default_signer(ctx, "s3", "us-east-1"); let mut req = http::Request::get("https://s3.amazonaws.com/my-bucket/report.csv") .body(())? .into_parts() diff --git a/reqsign/examples/s3_express_sign.rs b/reqsign/examples/s3_express_sign.rs index 8e0d68fe..0ba2976c 100644 --- a/reqsign/examples/s3_express_sign.rs +++ b/reqsign/examples/s3_express_sign.rs @@ -19,6 +19,7 @@ use reqsign::aws::{ self, DefaultCredentialProvider, S3ExpressSessionGrant, S3ExpressSessionMode, S3ExpressSessionProvider, }; +use reqsign::default_context; #[tokio::main] async fn main() -> anyhow::Result<()> { @@ -28,7 +29,8 @@ async fn main() -> anyhow::Result<()> { ) .with_region("us-west-2") .with_grant(S3ExpressSessionGrant::new(S3ExpressSessionMode::ReadOnly)); - let signer = aws::default_signer("s3express", "us-west-2").with_credential_provider(provider); + let signer = aws::default_signer(default_context(), "s3express", "us-west-2") + .with_credential_provider(provider); let mut req = http::Request::get( "https://my-bucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com/object", ) diff --git a/reqsign/examples/static_credentials.rs b/reqsign/examples/static_credentials.rs index 3e6c9aa3..52c598ec 100644 --- a/reqsign/examples/static_credentials.rs +++ b/reqsign/examples/static_credentials.rs @@ -19,7 +19,8 @@ async fn main() -> anyhow::Result<()> { // ANCHOR: static use reqsign::aws::{self, StaticCredentialProvider}; - let signer = aws::default_signer("s3", "us-east-1").with_credential_provider( + let ctx = reqsign::default_context(); + let signer = aws::default_signer(ctx.clone(), "s3", "us-east-1").with_credential_provider( StaticCredentialProvider::new("AKIDEXAMPLE", "example-secret-key"), ); // ANCHOR_END: static @@ -30,7 +31,7 @@ async fn main() -> anyhow::Result<()> { ); // ANCHOR_END: chain let _custom_chain_signer = - aws::default_signer("s3", "us-east-1").with_credential_provider(provider); + aws::default_signer(ctx, "s3", "us-east-1").with_credential_provider(provider); let mut req = http::Request::get("https://s3.amazonaws.com/my-bucket/my-object") .body(())? diff --git a/reqsign/src/aliyun.rs b/reqsign/src/aliyun.rs index dc311902..0eb2965a 100644 --- a/reqsign/src/aliyun.rs +++ b/reqsign/src/aliyun.rs @@ -23,27 +23,25 @@ // Re-export all Aliyun OSS signing types pub use reqsign_aliyun_oss::*; -#[cfg(feature = "default-context")] -use crate::{Signer, default_context}; +use crate::{Context, Signer}; /// Default Aliyun OSS Signer type with commonly used components -#[cfg(feature = "default-context")] pub type DefaultSigner = Signer; -/// Create a default Aliyun OSS signer with standard configuration +/// Create a default Aliyun OSS signer with the supplied runtime context. /// /// This function creates a signer with: -/// - Default context (with Tokio file reader, reqwest HTTP client, OS environment) +/// - The caller-supplied [`Context`] (for example `reqsign::default_context()` when `default-context` is enabled) /// - Default credential provider (reads from env vars, config files, ECS metadata, etc.) /// - Request signer for the specified bucket /// /// # Example /// /// ```no_run -/// # #[tokio::main] -/// # async fn main() -> reqsign_core::Result<()> { -/// // Create a signer for Aliyun OSS bucket -/// let signer = reqsign::aliyun::default_signer("mybucket"); +/// # #[cfg(feature = "default-context")] +/// # async fn example() -> reqsign_core::Result<()> { +/// let ctx = reqsign::default_context(); +/// let signer = reqsign::aliyun::default_signer(ctx, "mybucket"); /// /// // Sign a request /// let mut req = http::Request::builder() @@ -53,14 +51,12 @@ pub type DefaultSigner = Signer; /// .unwrap() /// .into_parts() /// .0; -/// +/// /// signer.sign(&mut req, None).await?; /// # Ok(()) /// # } /// ``` -#[cfg(feature = "default-context")] -pub fn default_signer(bucket: &str) -> DefaultSigner { - let ctx = default_context(); +pub fn default_signer(ctx: Context, bucket: &str) -> DefaultSigner { let provider = DefaultCredentialProvider::new(); let signer = RequestSigner::new(bucket); Signer::new(ctx, provider, signer) diff --git a/reqsign/src/aws.rs b/reqsign/src/aws.rs index fb8f228e..82dbe5a4 100644 --- a/reqsign/src/aws.rs +++ b/reqsign/src/aws.rs @@ -25,20 +25,17 @@ pub mod v4 { pub use reqsign_aws_v4::*; - #[cfg(feature = "default-context")] - use crate::{Signer, default_context}; + use crate::{Context, Signer}; /// Default SigV4 signer type. - #[cfg(feature = "default-context")] pub type DefaultSigner = Signer; - /// Create a default SigV4 signer for an AWS service and region. + /// Create a default SigV4 signer for an AWS service and region using the supplied context. /// - /// The signer uses the default context and AWS credential provider chain. - #[cfg(feature = "default-context")] - pub fn default_signer(service: &str, region: &str) -> DefaultSigner { + /// The signer uses the caller-supplied [`Context`] and AWS credential provider chain. + pub fn default_signer(ctx: Context, service: &str, region: &str) -> DefaultSigner { Signer::new( - default_context(), + ctx, DefaultCredentialProvider::new(), RequestSigner::new(service, region), ) @@ -54,20 +51,21 @@ pub use v4::*; pub mod v4a { pub use reqsign_aws_v4a::*; - #[cfg(feature = "default-context")] - use crate::{Signer, default_context}; + use crate::{Context, Signer}; /// Default SigV4a signer type. - #[cfg(feature = "default-context")] pub type DefaultSigner = Signer; - /// Create a default SigV4a signer for an AWS service and signing region set. + /// Create a default SigV4a signer for an AWS service and signing region set using the supplied context. /// - /// The signer uses the default context and AWS credential provider chain. - #[cfg(feature = "default-context")] - pub fn default_signer(service: &str, region_set: SigningRegionSet) -> DefaultSigner { + /// The signer uses the caller-supplied [`Context`] and AWS credential provider chain. + pub fn default_signer( + ctx: Context, + service: &str, + region_set: SigningRegionSet, + ) -> DefaultSigner { Signer::new( - default_context(), + ctx, DefaultCredentialProvider::new(), RequestSigner::new(service, region_set), ) diff --git a/reqsign/src/azure.rs b/reqsign/src/azure.rs index e385d48e..dea87495 100644 --- a/reqsign/src/azure.rs +++ b/reqsign/src/azure.rs @@ -55,27 +55,25 @@ // Re-export all Azure Storage signing types pub use reqsign_azure_storage::*; -#[cfg(feature = "default-context")] -use crate::{Signer, default_context}; +use crate::{Context, Signer}; /// Default Azure Storage Signer type with commonly used components -#[cfg(feature = "default-context")] pub type DefaultSigner = Signer; -/// Create a default Azure Storage signer with standard configuration +/// Create a default Azure Storage signer with the supplied runtime context. /// /// This function creates a signer with: -/// - Default context (with Tokio file reader, reqwest HTTP client, OS environment) +/// - The caller-supplied [`Context`] (for example `reqsign::default_context()` when `default-context` is enabled) /// - Default credential provider (reads from env vars, managed identity, CLI, etc.) /// - Request signer for Azure Storage /// /// # Example /// /// ```no_run -/// # #[tokio::main] -/// # async fn main() -> reqsign_core::Result<()> { -/// // Create a signer for Azure Storage -/// let signer = reqsign::azure::default_signer(); +/// # #[cfg(feature = "default-context")] +/// # async fn example() -> reqsign_core::Result<()> { +/// let ctx = reqsign::default_context(); +/// let signer = reqsign::azure::default_signer(ctx); /// /// // Sign a request /// let mut req = http::Request::builder() @@ -85,7 +83,7 @@ pub type DefaultSigner = Signer; /// .unwrap() /// .into_parts() /// .0; -/// +/// /// signer.sign(&mut req, None).await?; /// # Ok(()) /// # } @@ -96,10 +94,12 @@ pub type DefaultSigner = Signer; /// You can customize the signer using the `with_*` methods: /// /// ```no_run +/// # #[cfg(feature = "default-context")] /// # async fn example() -> reqsign_core::Result<()> { /// use reqsign::azure::{default_signer, StaticCredentialProvider}; /// -/// let signer = default_signer() +/// let ctx = reqsign::default_context(); +/// let signer = default_signer(ctx) /// .with_credential_provider(StaticCredentialProvider::new_shared_key( /// "myaccount", /// "my-account-key", @@ -107,9 +107,7 @@ pub type DefaultSigner = Signer; /// # Ok(()) /// # } /// ``` -#[cfg(feature = "default-context")] -pub fn default_signer() -> DefaultSigner { - let ctx = default_context(); +pub fn default_signer(ctx: Context) -> DefaultSigner { let provider = DefaultCredentialProvider::new(); let signer = RequestSigner::new(); Signer::new(ctx, provider, signer) diff --git a/reqsign/src/google.rs b/reqsign/src/google.rs index 8fa4670d..38f229da 100644 --- a/reqsign/src/google.rs +++ b/reqsign/src/google.rs @@ -71,27 +71,25 @@ // Re-export all Google Cloud signing types pub use reqsign_google::*; -#[cfg(feature = "default-context")] -use crate::{Signer, default_context}; +use crate::{Context, Signer}; /// Default Google Cloud Signer type with commonly used components -#[cfg(feature = "default-context")] pub type DefaultSigner = Signer; -/// Create a default Google Cloud signer with standard configuration +/// Create a default Google Cloud signer with the supplied runtime context. /// /// This function creates a signer with: -/// - Default context (with Tokio file reader, reqwest HTTP client, OS environment) +/// - The caller-supplied [`Context`] (for example `reqsign::default_context()` when `default-context` is enabled) /// - Default credential provider (reads from env vars, service account, metadata server, etc.) /// - Request signer for the specified service /// /// # Example /// /// ```no_run -/// # #[tokio::main] -/// # async fn main() -> reqsign_core::Result<()> { -/// // Create a signer for Google Cloud Storage -/// let signer = reqsign::google::default_signer("storage.googleapis.com"); +/// # #[cfg(feature = "default-context")] +/// # async fn example() -> reqsign_core::Result<()> { +/// let ctx = reqsign::default_context(); +/// let signer = reqsign::google::default_signer(ctx, "storage.googleapis.com"); /// /// // Sign a request /// let mut req = http::Request::builder() @@ -101,7 +99,7 @@ pub type DefaultSigner = Signer; /// .unwrap() /// .into_parts() /// .0; -/// +/// /// signer.sign(&mut req, None).await?; /// # Ok(()) /// # } @@ -112,6 +110,7 @@ pub type DefaultSigner = Signer; /// You can customize the signer using the `with_*` methods: /// /// ```no_run +/// # #[cfg(feature = "default-context")] /// # async fn example() -> reqsign_core::Result<()> { /// use reqsign::google::{default_signer, StaticCredentialProvider}; /// @@ -127,14 +126,13 @@ pub type DefaultSigner = Signer; /// "token_uri": "https://oauth2.googleapis.com/token" /// }"#; /// -/// let signer = default_signer("storage.googleapis.com") +/// let ctx = reqsign::default_context(); +/// let signer = default_signer(ctx, "storage.googleapis.com") /// .with_credential_provider(StaticCredentialProvider::new(service_account_json)); /// # Ok(()) /// # } /// ``` -#[cfg(feature = "default-context")] -pub fn default_signer(service: &str) -> DefaultSigner { - let ctx = default_context(); +pub fn default_signer(ctx: Context, service: &str) -> DefaultSigner { let provider = DefaultCredentialProvider::new(); let signer = RequestSigner::new(service); Signer::new(ctx, provider, signer) diff --git a/reqsign/src/huaweicloud.rs b/reqsign/src/huaweicloud.rs index e2bd380a..55d165a0 100644 --- a/reqsign/src/huaweicloud.rs +++ b/reqsign/src/huaweicloud.rs @@ -23,27 +23,25 @@ // Re-export all Huawei Cloud OBS signing types pub use reqsign_huaweicloud_obs::*; -#[cfg(feature = "default-context")] -use crate::{Signer, default_context}; +use crate::{Context, Signer}; /// Default Huawei Cloud OBS Signer type with commonly used components -#[cfg(feature = "default-context")] pub type DefaultSigner = Signer; -/// Create a default Huawei Cloud OBS signer with standard configuration +/// Create a default Huawei Cloud OBS signer with the supplied runtime context. /// /// This function creates a signer with: -/// - Default context (with Tokio file reader, reqwest HTTP client, OS environment) +/// - The caller-supplied [`Context`] (for example `reqsign::default_context()` when `default-context` is enabled) /// - Default credential provider (reads from env vars) /// - Request signer for the specified bucket /// /// # Example /// /// ```no_run -/// # #[tokio::main] -/// # async fn main() -> reqsign_core::Result<()> { -/// // Create a signer for Huawei Cloud OBS bucket -/// let signer = reqsign::huaweicloud::default_signer("mybucket"); +/// # #[cfg(feature = "default-context")] +/// # async fn example() -> reqsign_core::Result<()> { +/// let ctx = reqsign::default_context(); +/// let signer = reqsign::huaweicloud::default_signer(ctx, "mybucket"); /// /// // Sign a request /// let mut req = http::Request::builder() @@ -53,14 +51,12 @@ pub type DefaultSigner = Signer; /// .unwrap() /// .into_parts() /// .0; -/// +/// /// signer.sign(&mut req, None).await?; /// # Ok(()) /// # } /// ``` -#[cfg(feature = "default-context")] -pub fn default_signer(bucket: &str) -> DefaultSigner { - let ctx = default_context(); +pub fn default_signer(ctx: Context, bucket: &str) -> DefaultSigner { let provider = DefaultCredentialProvider::new(); let signer = RequestSigner::new(bucket); Signer::new(ctx, provider, signer) diff --git a/reqsign/src/lib.rs b/reqsign/src/lib.rs index 94663644..9e5a04d1 100644 --- a/reqsign/src/lib.rs +++ b/reqsign/src/lib.rs @@ -54,3 +54,33 @@ pub mod tencent; #[cfg(feature = "volcengine")] pub mod volcengine; + +#[cfg(all(test, feature = "aws-v4"))] +mod tests { + use crate::{Context, StaticEnv, aws}; + use std::collections::HashMap; + + #[tokio::test] + async fn default_signer_works_without_default_context_feature() { + let ctx = Context::new().with_env(StaticEnv { + home_dir: None, + envs: HashMap::from([ + ("AWS_ACCESS_KEY_ID".to_string(), "AKIDEXAMPLE".to_string()), + ( + "AWS_SECRET_ACCESS_KEY".to_string(), + "example-secret-key".to_string(), + ), + ]), + }); + let signer = aws::default_signer(ctx, "s3", "us-east-1"); + + let mut req = http::Request::get("https://s3.amazonaws.com/my-bucket/my-object") + .body(()) + .unwrap() + .into_parts() + .0; + + signer.sign(&mut req, None).await.unwrap(); + assert!(req.headers.contains_key("authorization")); + } +} diff --git a/reqsign/src/openstack.rs b/reqsign/src/openstack.rs index 2b57003a..10481493 100644 --- a/reqsign/src/openstack.rs +++ b/reqsign/src/openstack.rs @@ -23,17 +23,15 @@ // Re-export all OpenStack Keystone types pub use reqsign_openstack_keystone::*; -#[cfg(feature = "default-context")] -use crate::{Signer, default_context}; +use crate::{Context, Signer}; /// Default OpenStack Signer type with commonly used components -#[cfg(feature = "default-context")] pub type DefaultSigner = Signer; -/// Create a default OpenStack signer with standard configuration +/// Create a default OpenStack signer with the supplied runtime context. /// /// This function creates a signer with: -/// - Default context (with Tokio file reader, reqwest HTTP client, OS environment) +/// - The caller-supplied [`Context`] (for example `reqsign::default_context()` when `default-context` is enabled) /// - Default credential provider (reads the standard `OS_AUTH_URL`, /// `OS_USERNAME`, and `OS_PASSWORD` environment variables) /// - Request signer that inserts `X-Auth-Token` header @@ -41,9 +39,10 @@ pub type DefaultSigner = Signer; /// # Example /// /// ```no_run -/// # #[tokio::main] -/// # async fn main() -> reqsign_core::Result<()> { -/// let signer = reqsign::openstack::default_signer(); +/// # #[cfg(feature = "default-context")] +/// # async fn example() -> reqsign_core::Result<()> { +/// let ctx = reqsign::default_context(); +/// let signer = reqsign::openstack::default_signer(ctx); /// /// let mut req = http::Request::builder() /// .method("GET") @@ -57,9 +56,7 @@ pub type DefaultSigner = Signer; /// # Ok(()) /// # } /// ``` -#[cfg(feature = "default-context")] -pub fn default_signer() -> DefaultSigner { - let ctx = default_context(); +pub fn default_signer(ctx: Context) -> DefaultSigner { let provider = DefaultCredentialProvider::new(); let signer = RequestSigner; Signer::new(ctx, provider, signer) diff --git a/reqsign/src/oracle.rs b/reqsign/src/oracle.rs index 8a6520cf..4f213015 100644 --- a/reqsign/src/oracle.rs +++ b/reqsign/src/oracle.rs @@ -23,27 +23,25 @@ // Re-export all Oracle Cloud signing types pub use reqsign_oracle::*; -#[cfg(feature = "default-context")] -use crate::{Signer, default_context}; +use crate::{Context, Signer}; /// Default Oracle Cloud Signer type with commonly used components -#[cfg(feature = "default-context")] pub type DefaultSigner = Signer; -/// Create a default Oracle Cloud signer with standard configuration +/// Create a default Oracle Cloud signer with the supplied runtime context. /// /// This function creates a signer with: -/// - Default context (with Tokio file reader, reqwest HTTP client, OS environment) +/// - The caller-supplied [`Context`] (for example `reqsign::default_context()` when `default-context` is enabled) /// - Default credential provider (reads from config file) /// - Request signer for Oracle Cloud /// /// # Example /// /// ```no_run -/// # #[tokio::main] -/// # async fn main() -> reqsign_core::Result<()> { -/// // Create a signer for Oracle Cloud -/// let signer = reqsign::oracle::default_signer(); +/// # #[cfg(feature = "default-context")] +/// # async fn example() -> reqsign_core::Result<()> { +/// let ctx = reqsign::default_context(); +/// let signer = reqsign::oracle::default_signer(ctx); /// /// // Sign a request /// let mut req = http::Request::builder() @@ -53,14 +51,12 @@ pub type DefaultSigner = Signer; /// .unwrap() /// .into_parts() /// .0; -/// +/// /// signer.sign(&mut req, None).await?; /// # Ok(()) /// # } /// ``` -#[cfg(feature = "default-context")] -pub fn default_signer() -> DefaultSigner { - let ctx = default_context(); +pub fn default_signer(ctx: Context) -> DefaultSigner { let provider = DefaultCredentialProvider::new(); let signer = RequestSigner::new(); Signer::new(ctx, provider, signer) diff --git a/reqsign/src/tencent.rs b/reqsign/src/tencent.rs index 11e3b5d1..ca36c16a 100644 --- a/reqsign/src/tencent.rs +++ b/reqsign/src/tencent.rs @@ -23,27 +23,25 @@ // Re-export all Tencent Cloud COS signing types pub use reqsign_tencent_cos::*; -#[cfg(feature = "default-context")] -use crate::{Signer, default_context}; +use crate::{Context, Signer}; /// Default Tencent Cloud COS Signer type with commonly used components -#[cfg(feature = "default-context")] pub type DefaultSigner = Signer; -/// Create a default Tencent Cloud COS signer with standard configuration +/// Create a default Tencent Cloud COS signer with the supplied runtime context. /// /// This function creates a signer with: -/// - Default context (with Tokio file reader, reqwest HTTP client, OS environment) +/// - The caller-supplied [`Context`] (for example `reqsign::default_context()` when `default-context` is enabled) /// - Default credential provider (reads from env vars) /// - Request signer for Tencent Cloud COS /// /// # Example /// /// ```no_run -/// # #[tokio::main] -/// # async fn main() -> reqsign_core::Result<()> { -/// // Create a signer for Tencent Cloud COS -/// let signer = reqsign::tencent::default_signer(); +/// # #[cfg(feature = "default-context")] +/// # async fn example() -> reqsign_core::Result<()> { +/// let ctx = reqsign::default_context(); +/// let signer = reqsign::tencent::default_signer(ctx); /// /// // Sign a request /// let mut req = http::Request::builder() @@ -53,14 +51,12 @@ pub type DefaultSigner = Signer; /// .unwrap() /// .into_parts() /// .0; -/// +/// /// signer.sign(&mut req, None).await?; /// # Ok(()) /// # } /// ``` -#[cfg(feature = "default-context")] -pub fn default_signer() -> DefaultSigner { - let ctx = default_context(); +pub fn default_signer(ctx: Context) -> DefaultSigner { let provider = DefaultCredentialProvider::new(); let signer = RequestSigner::new(); Signer::new(ctx, provider, signer) diff --git a/reqsign/src/volcengine.rs b/reqsign/src/volcengine.rs index b9ea771c..23e9b559 100644 --- a/reqsign/src/volcengine.rs +++ b/reqsign/src/volcengine.rs @@ -23,27 +23,25 @@ // Re-export all Volcengine TOS signing types pub use reqsign_volcengine_tos::*; -#[cfg(feature = "default-context")] -use crate::{Signer, default_context}; +use crate::{Context, Signer}; /// Default Volcengine TOS Signer type with commonly used components -#[cfg(feature = "default-context")] pub type DefaultSigner = Signer; -/// Create a default Volcengine TOS signer with standard configuration +/// Create a default Volcengine TOS signer with the supplied runtime context. /// /// This function creates a signer with: -/// - Default context (with Tokio file reader, reqwest HTTP client, OS environment) +/// - The caller-supplied [`Context`] (for example `reqsign::default_context()` when `default-context` is enabled) /// - Default credential provider (reads from env vars) /// - Request signer for the specified region /// /// # Example /// /// ```no_run -/// # #[tokio::main] -/// # async fn main() -> reqsign_core::Result<()> { -/// // Create a signer for Volcengine TOS in cn-beijing region -/// let signer = reqsign::volcengine::default_signer("cn-beijing"); +/// # #[cfg(feature = "default-context")] +/// # async fn example() -> reqsign_core::Result<()> { +/// let ctx = reqsign::default_context(); +/// let signer = reqsign::volcengine::default_signer(ctx, "cn-beijing"); /// /// // Sign a request /// let mut req = http::Request::builder() @@ -53,14 +51,12 @@ pub type DefaultSigner = Signer; /// .unwrap() /// .into_parts() /// .0; -/// +/// /// signer.sign(&mut req, None).await?; /// # Ok(()) /// # } /// ``` -#[cfg(feature = "default-context")] -pub fn default_signer(region: &str) -> DefaultSigner { - let ctx = default_context(); +pub fn default_signer(ctx: Context, region: &str) -> DefaultSigner { let provider = DefaultCredentialProvider::new(); let signer = RequestSigner::new(region); Signer::new(ctx, provider, signer) diff --git a/website/data/providers.json b/website/data/providers.json index f77b300d..05023992 100644 --- a/website/data/providers.json +++ b/website/data/providers.json @@ -52,7 +52,7 @@ ], "default_signer": { "available": true, - "entry": "reqsign::aws::default_signer(service, region)" + "entry": "reqsign::aws::default_signer(ctx, service, region)" }, "credential_sources": [ { @@ -168,7 +168,7 @@ ], "default_signer": { "available": true, - "entry": "reqsign::aws::v4a::default_signer(service, region_set)" + "entry": "reqsign::aws::v4a::default_signer(ctx, service, region_set)" }, "credential_sources": [ { @@ -270,7 +270,7 @@ ], "default_signer": { "available": true, - "entry": "reqsign::azure::default_signer()" + "entry": "reqsign::azure::default_signer(ctx)" }, "credential_sources": [ { @@ -372,7 +372,7 @@ ], "default_signer": { "available": true, - "entry": "reqsign::google::default_signer(service)" + "entry": "reqsign::google::default_signer(ctx, service)" }, "credential_sources": [ { @@ -488,7 +488,7 @@ ], "default_signer": { "available": true, - "entry": "reqsign::aliyun::default_signer(bucket)" + "entry": "reqsign::aliyun::default_signer(ctx, bucket)" }, "credential_sources": [ { @@ -582,7 +582,7 @@ ], "default_signer": { "available": true, - "entry": "reqsign::huaweicloud::default_signer(bucket)" + "entry": "reqsign::huaweicloud::default_signer(ctx, bucket)" }, "credential_sources": [ { @@ -646,7 +646,7 @@ ], "default_signer": { "available": true, - "entry": "reqsign::oracle::default_signer()" + "entry": "reqsign::oracle::default_signer(ctx)" }, "credential_sources": [ { @@ -715,7 +715,7 @@ ], "default_signer": { "available": true, - "entry": "reqsign::tencent::default_signer()" + "entry": "reqsign::tencent::default_signer(ctx)" }, "credential_sources": [ { @@ -784,7 +784,7 @@ ], "default_signer": { "available": true, - "entry": "reqsign::volcengine::default_signer(region)" + "entry": "reqsign::volcengine::default_signer(ctx, region)" }, "credential_sources": [ { @@ -843,7 +843,7 @@ ], "default_signer": { "available": true, - "entry": "reqsign::openstack::default_signer()" + "entry": "reqsign::openstack::default_signer(ctx)" }, "credential_sources": [ { diff --git a/website/docs/architecture.md b/website/docs/architecture.md index a50bd992..466653f7 100644 --- a/website/docs/architecture.md +++ b/website/docs/architecture.md @@ -66,7 +66,7 @@ Builders swap any component while keeping the others: ```rust let signer = signer - .with_context(custom_ctx) + .with_context(custom_ctx) // clears the credential cache .with_credential_provider(static_provider) // clears the credential cache .with_request_signer(other_signer); ``` @@ -209,9 +209,9 @@ The reuse rule on every `sign` or `grant`: reuse of the previous cached credential. A configured provider chain can handle errors internally by trying its next source, as described above. -Replacing a signer's credential provider — or a granter's context or source -provider — clears the cache: a credential loaded under one configuration is -never reused under another. +Replacing a signer's or granter's context or credential provider clears the +cache: a credential loaded under one configuration is never reused under +another. ## Granter and GrantCredential @@ -268,8 +268,10 @@ The same components are reachable at three levels — pick by how much you want to control: **The facade** (`reqsign` crate) — one dependency, feature flags per -provider, `default_signer` entries that wire everything. Best for -applications; still customizable through `with_*` builders. +provider, `default_context()` for the standard runtime, and `default_signer` +entries that wire each provider's credential chain and request signer with +your supplied `Context`. Best for applications; still customizable through +`with_*` builders. **Custom assembly** — the same components, wired explicitly. What `default_signer` does for you, written out: diff --git a/website/docs/getting-started.md b/website/docs/getting-started.md index 8d64c67a..9bc7dbff 100644 --- a/website/docs/getting-started.md +++ b/website/docs/getting-started.md @@ -66,10 +66,11 @@ This is the repository's compiled example — CI builds it on every commit: Three things happen here: -1. `aws::default_signer("s3", "us-east-1")` composes the default runtime - context with AWS's full credential chain — environment variables, shared - profiles, SSO, ECS, IMDS, and more. See - [Loading credentials](/docs/guides/credentials/). +1. `default_context()` builds the default runtime context, and + `aws::default_signer(ctx, "s3", "us-east-1")` composes it with AWS's full + credential chain — environment variables, shared profiles, SSO, ECS, IMDS, + and more. Reuse the same `Context` across multiple signers by cloning it. + See [Loading credentials](/docs/guides/credentials/). 2. The request is built with the plain `http` crate. Reqsign signs `http::request::Parts` directly — there is no wrapper client to adopt. 3. `signer.sign(&mut req, None).await?` mutates the request head in place, @@ -97,16 +98,16 @@ composes that provider's own credential chain — the | Provider | Entry | | --- | --- | -| [AWS SigV4](/docs/providers/aws-sigv4/) | `aws::default_signer(service, region)` | -| [AWS SigV4a](/docs/providers/aws-sigv4a/) | `aws::v4a::default_signer(service, region_set)` | -| [Azure Storage](/docs/providers/azure-storage/) | `azure::default_signer()` | -| [Google Cloud](/docs/providers/google/) | `google::default_signer(service)` | -| [Aliyun OSS](/docs/providers/aliyun-oss/) | `aliyun::default_signer(bucket)` | -| [Huawei Cloud OBS](/docs/providers/huaweicloud-obs/) | `huaweicloud::default_signer(bucket)` | -| [OpenStack Keystone](/docs/providers/openstack-keystone/) | `openstack::default_signer()` | -| [Oracle Cloud](/docs/providers/oracle/) | `oracle::default_signer()` | -| [Tencent COS](/docs/providers/tencent-cos/) | `tencent::default_signer()` | -| [Volcengine TOS](/docs/providers/volcengine-tos/) | `volcengine::default_signer(region)` | +| [AWS SigV4](/docs/providers/aws-sigv4/) | `aws::default_signer(ctx, service, region)` | +| [AWS SigV4a](/docs/providers/aws-sigv4a/) | `aws::v4a::default_signer(ctx, service, region_set)` | +| [Azure Storage](/docs/providers/azure-storage/) | `azure::default_signer(ctx)` | +| [Google Cloud](/docs/providers/google/) | `google::default_signer(ctx, service)` | +| [Aliyun OSS](/docs/providers/aliyun-oss/) | `aliyun::default_signer(ctx, bucket)` | +| [Huawei Cloud OBS](/docs/providers/huaweicloud-obs/) | `huaweicloud::default_signer(ctx, bucket)` | +| [OpenStack Keystone](/docs/providers/openstack-keystone/) | `openstack::default_signer(ctx)` | +| [Oracle Cloud](/docs/providers/oracle/) | `oracle::default_signer(ctx)` | +| [Tencent COS](/docs/providers/tencent-cos/) | `tencent::default_signer(ctx)` | +| [Volcengine TOS](/docs/providers/volcengine-tos/) | `volcengine::default_signer(ctx, region)` | A default signer is an ordinary `Signer`: replace any component and keep the rest — diff --git a/website/docs/guides/credentials.md b/website/docs/guides/credentials.md index 17f24d91..9caf96cb 100644 --- a/website/docs/guides/credentials.md +++ b/website/docs/guides/credentials.md @@ -77,8 +77,9 @@ injects keys — skip chains entirely: ```rust file=reqsign/examples/static_credentials.rs region=static ``` -Replacing a signer's credential provider clears its credential cache, so a -credential from the old chain is never reused with the new configuration. +Replacing a signer's context or credential provider clears its credential +cache, so a credential from the old configuration is never reused with the +new one. ## Implement your own source @@ -161,5 +162,6 @@ a custom `Signer::new`. The credential type you return implements `SigningCredential`; set its expiration so [caching](/docs/architecture/#credential-caching-and-validity) refreshes it -on time. Credentials without an expiration are cached until the provider is -replaced. +on time. Credentials without an expiration are cached by the signer until +its credential provider is replaced. Replacing the signer's `Context` also +clears the signer's credential cache. diff --git a/website/docs/providers/aliyun-oss.mdx b/website/docs/providers/aliyun-oss.mdx index 5288f0f8..36206a55 100644 --- a/website/docs/providers/aliyun-oss.mdx +++ b/website/docs/providers/aliyun-oss.mdx @@ -34,10 +34,11 @@ cargo add reqsign --features aliyun ``` ```rust -use reqsign::aliyun; +use reqsign::{aliyun, default_context}; // Env, config files, ECS RAM roles, OIDC — resolved by the default chain. -let signer = aliyun::default_signer("my-bucket"); +let ctx = default_context(); +let signer = aliyun::default_signer(ctx, "my-bucket"); let mut req = http::Request::builder() .method(http::Method::GET) diff --git a/website/docs/providers/aws-sigv4.mdx b/website/docs/providers/aws-sigv4.mdx index 0dbb5baa..b0f61bd9 100644 --- a/website/docs/providers/aws-sigv4.mdx +++ b/website/docs/providers/aws-sigv4.mdx @@ -34,11 +34,12 @@ cargo add reqsign --features aws ``` ```rust -use reqsign::aws; +use reqsign::{aws, default_context}; // Credentials resolve through the default chain: // env → profiles (including assume-role chains) → SSO → OIDC → process → ECS → IMDS. -let signer = aws::default_signer("s3", "us-east-1"); +let ctx = default_context(); +let signer = aws::default_signer(ctx, "s3", "us-east-1"); let mut req = http::Request::builder() .method(http::Method::GET) diff --git a/website/docs/providers/aws-sigv4a.mdx b/website/docs/providers/aws-sigv4a.mdx index cda9f47a..40eaa296 100644 --- a/website/docs/providers/aws-sigv4a.mdx +++ b/website/docs/providers/aws-sigv4a.mdx @@ -35,11 +35,13 @@ cargo add reqsign --features aws-v4a ```rust use reqsign::aws::v4a::{default_signer, SigningRegionSet}; +use reqsign::default_context; // Same credential chain as SigV4; the signature covers a region set — // built for multi-region endpoints like S3 Multi-Region Access Points. +let ctx = default_context(); let region_set = SigningRegionSet::new("us-east-1,us-west-2")?; -let signer = default_signer("s3", region_set); +let signer = default_signer(ctx, "s3", region_set); let mut req = http::Request::builder() .method(http::Method::GET) diff --git a/website/docs/providers/azure-storage.mdx b/website/docs/providers/azure-storage.mdx index ed1c30ca..8547b606 100644 --- a/website/docs/providers/azure-storage.mdx +++ b/website/docs/providers/azure-storage.mdx @@ -34,11 +34,12 @@ cargo add reqsign --features azure ``` ```rust -use reqsign::azure; +use reqsign::{azure, default_context}; // Shared key, SAS, or Entra ID (client secrets, workload identity, // managed identity, Azure CLI) — resolved by the default chain. -let signer = azure::default_signer(); +let ctx = default_context(); +let signer = azure::default_signer(ctx); let mut req = http::Request::builder() .method(http::Method::GET) diff --git a/website/docs/providers/google.mdx b/website/docs/providers/google.mdx index 8d3d994f..734ae639 100644 --- a/website/docs/providers/google.mdx +++ b/website/docs/providers/google.mdx @@ -34,11 +34,12 @@ cargo add reqsign --features google ``` ```rust -use reqsign::google; +use reqsign::{default_context, google}; // Service account files, workload identity federation, VM metadata — // resolved by the default chain. -let signer = google::default_signer("storage.googleapis.com"); +let ctx = default_context(); +let signer = google::default_signer(ctx, "storage.googleapis.com"); let mut req = http::Request::builder() .method(http::Method::GET) diff --git a/website/docs/providers/huaweicloud-obs.mdx b/website/docs/providers/huaweicloud-obs.mdx index c5fdd8e0..f6eb846a 100644 --- a/website/docs/providers/huaweicloud-obs.mdx +++ b/website/docs/providers/huaweicloud-obs.mdx @@ -34,10 +34,11 @@ cargo add reqsign --features huaweicloud ``` ```rust -use reqsign::huaweicloud; +use reqsign::{default_context, huaweicloud}; // Environment credentials — resolved by the default chain. -let signer = huaweicloud::default_signer("my-bucket"); +let ctx = default_context(); +let signer = huaweicloud::default_signer(ctx, "my-bucket"); let mut req = http::Request::builder() .method(http::Method::GET) diff --git a/website/docs/providers/openstack-keystone.mdx b/website/docs/providers/openstack-keystone.mdx index 5368383a..9f322e65 100644 --- a/website/docs/providers/openstack-keystone.mdx +++ b/website/docs/providers/openstack-keystone.mdx @@ -34,10 +34,11 @@ cargo add reqsign --features openstack ``` ```rust -use reqsign::openstack; +use reqsign::{default_context, openstack}; // Environment variables — resolved by the default chain. -let signer = openstack::default_signer(); +let ctx = default_context(); +let signer = openstack::default_signer(ctx); let mut req = http::Request::builder() .method(http::Method::GET) diff --git a/website/docs/providers/oracle.mdx b/website/docs/providers/oracle.mdx index fb63f27b..d43ea505 100644 --- a/website/docs/providers/oracle.mdx +++ b/website/docs/providers/oracle.mdx @@ -34,10 +34,11 @@ cargo add reqsign --features oracle ``` ```rust -use reqsign::oracle; +use reqsign::{default_context, oracle}; // Env and the OCI config file (~/.oci/config) — resolved by the default chain. -let signer = oracle::default_signer(); +let ctx = default_context(); +let signer = oracle::default_signer(ctx); let mut req = http::Request::builder() .method(http::Method::GET) diff --git a/website/docs/providers/tencent-cos.mdx b/website/docs/providers/tencent-cos.mdx index b9708ae1..498d2eea 100644 --- a/website/docs/providers/tencent-cos.mdx +++ b/website/docs/providers/tencent-cos.mdx @@ -34,10 +34,11 @@ cargo add reqsign --features tencent ``` ```rust -use reqsign::tencent; +use reqsign::{default_context, tencent}; // Env, config, OIDC federation — resolved by the default chain. -let signer = tencent::default_signer(); +let ctx = default_context(); +let signer = tencent::default_signer(ctx); let mut req = http::Request::builder() .method(http::Method::GET) diff --git a/website/docs/providers/volcengine-tos.mdx b/website/docs/providers/volcengine-tos.mdx index 1687a776..7cef4b79 100644 --- a/website/docs/providers/volcengine-tos.mdx +++ b/website/docs/providers/volcengine-tos.mdx @@ -34,10 +34,11 @@ cargo add reqsign --features volcengine ``` ```rust -use reqsign::volcengine; +use reqsign::{default_context, volcengine}; // Environment variables — resolved by the default chain. -let signer = volcengine::default_signer("cn-beijing"); +let ctx = default_context(); +let signer = volcengine::default_signer(ctx, "cn-beijing"); let mut req = http::Request::builder() .method(http::Method::GET) diff --git a/website/docs/what-is-reqsign.md b/website/docs/what-is-reqsign.md index a7098ed1..e0db71ad 100644 --- a/website/docs/what-is-reqsign.md +++ b/website/docs/what-is-reqsign.md @@ -39,10 +39,11 @@ Everything else stays yours: the HTTP client, retries, connection pooling, and the runtime. Reqsign never sends your requests. ```rust -use reqsign::aws; +use reqsign::{aws, default_context}; // Credentials load from env, profiles, SSO, IMDS — the default chain. -let signer = aws::default_signer("s3", "us-east-1"); +let ctx = default_context(); +let signer = aws::default_signer(ctx, "s3", "us-east-1"); // Build the request with plain http types. let mut req = http::Request::builder()