Skip to main content

cloud_sdk_reqwest/blocking/
basic_config.rs

1use core::fmt;
2
3use crate::shared::{BasicCredential, BuildError, HttpsEndpoint, RequestTimeouts, UserAgent};
4
5use super::BlockingBasicClient;
6#[cfg(feature = "blocking-rustls-fips")]
7use super::config::FipsTlsPolicy;
8use super::config::{ClientSettings, configured_client};
9
10/// Builder requiring a scoped Basic credential and complete transport limits.
11pub struct BlockingBasicClientBuilder {
12    endpoint: HttpsEndpoint,
13    credential: BasicCredential,
14    user_agent: UserAgent,
15    timeouts: RequestTimeouts,
16    #[cfg(feature = "blocking-rustls-fips")]
17    fips_tls_policy: Option<FipsTlsPolicy>,
18}
19
20impl BlockingBasicClientBuilder {
21    /// Creates a complete blocking Basic-client configuration.
22    #[must_use]
23    pub const fn new(
24        endpoint: HttpsEndpoint,
25        credential: BasicCredential,
26        user_agent: UserAgent,
27        timeouts: RequestTimeouts,
28    ) -> Self {
29        Self {
30            endpoint,
31            credential,
32            user_agent,
33            timeouts,
34            #[cfg(feature = "blocking-rustls-fips")]
35            fips_tls_policy: None,
36        }
37    }
38
39    /// Supplies mandatory deployment-managed roots and CRLs for FIPS TLS.
40    #[cfg(feature = "blocking-rustls-fips")]
41    #[must_use]
42    pub fn with_fips_tls_policy(mut self, policy: FipsTlsPolicy) -> Self {
43        self.fips_tls_policy = Some(policy);
44        self
45    }
46
47    /// Builds a hardened HTTPS-only Basic-auth client.
48    pub fn build(self) -> Result<BlockingBasicClient, BuildError> {
49        self.build_inner(true)
50    }
51
52    fn build_inner(self, https_only: bool) -> Result<BlockingBasicClient, BuildError> {
53        if !self.credential.scope().matches_endpoint(&self.endpoint) {
54            return Err(BuildError::CredentialEndpointMismatch);
55        }
56        let settings = ClientSettings {
57            user_agent: &self.user_agent,
58            timeouts: self.timeouts,
59            #[cfg(feature = "blocking-rustls-fips")]
60            fips_tls_policy: self.fips_tls_policy.as_ref(),
61        };
62        let client = configured_client(settings, https_only)?;
63        Ok(BlockingBasicClient::new(
64            client,
65            self.endpoint,
66            self.credential,
67            !https_only,
68        ))
69    }
70
71    #[cfg(test)]
72    pub(super) fn build_for_loopback(self) -> Result<BlockingBasicClient, BuildError> {
73        self.build_inner(false)
74    }
75}
76
77impl fmt::Debug for BlockingBasicClientBuilder {
78    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
79        let mut debug = formatter.debug_struct("BlockingBasicClientBuilder");
80        debug
81            .field("endpoint", &"[redacted]")
82            .field("credential", &"[redacted]")
83            .field("user_agent", &self.user_agent)
84            .field("timeouts", &self.timeouts);
85        #[cfg(feature = "blocking-rustls-fips")]
86        debug.field("fips_tls_policy", &self.fips_tls_policy);
87        debug.finish()
88    }
89}