cloud_sdk_reqwest/blocking/
basic_client.rs

1use core::fmt;
2use std::sync::Arc;
3
4use cloud_sdk::authentication::{AuthenticatedRequest, BlockingAuthenticatedTransport};
5use cloud_sdk::transport::{
6    BoundTransport, EndpointIdentity, EndpointIdentityError, ResponseStorageSanitizer,
7    ResponseWriter, TransportFailure,
8};
9use cloud_sdk_sanitization::sanitize_bytes;
10
11use crate::shared::{
12    AuthenticatedTransportFailure, BasicCredential, HttpsEndpoint, TransportError,
13    map_authentication_error, validate_basic_authentication,
14};
15
16use super::RawBlockingClient;
17
18/// Hardened provider-neutral reqwest blocking Basic-auth transport.
19#[derive(Clone)]
20pub struct BlockingBasicClient {
21    client: RawBlockingClient,
22    endpoint: HttpsEndpoint,
23    credential: Arc<BasicCredential>,
24    allow_insecure_loopback: bool,
25}
26
27impl BlockingBasicClient {
28    pub(super) fn new(
29        client: RawBlockingClient,
30        endpoint: HttpsEndpoint,
31        credential: BasicCredential,
32        allow_insecure_loopback: bool,
33    ) -> Self {
34        Self {
35            client,
36            endpoint,
37            credential: Arc::new(credential),
38            allow_insecure_loopback,
39        }
40    }
41
42    fn send_inner(
43        &self,
44        authenticated: AuthenticatedRequest<'_, '_>,
45        response: &mut ResponseWriter<'_>,
46    ) -> Result<(), AuthenticatedTransportFailure> {
47        let endpoint = self.endpoint.identity().map_err(|_| {
48            TransportFailure::not_sent(TransportError::AuthenticationEndpointMismatch)
49        })?;
50        validate_basic_authentication(
51            endpoint,
52            self.credential.scope(),
53            authenticated.policy(),
54            self.allow_insecure_loopback,
55        )
56        .map_err(|error| TransportFailure::not_sent(map_authentication_error(error)))?;
57        let authorization = self
58            .credential
59            .header_value()
60            .map_err(|_| TransportFailure::not_sent(TransportError::HeaderRejected))?;
61        self.client
62            .execute_authenticated(
63                authenticated.transport_request(),
64                authenticated.response_policy(),
65                authorization,
66                response,
67            )
68            .map_err(|failure| failure.map(TransportError::RawHttp))
69    }
70}
71
72impl BlockingAuthenticatedTransport for BlockingBasicClient {
73    type Error = AuthenticatedTransportFailure;
74
75    fn send_authenticated(
76        &self,
77        request: AuthenticatedRequest<'_, '_>,
78        response: &mut ResponseWriter<'_>,
79    ) -> Result<(), Self::Error> {
80        self.send_inner(request, response)
81    }
82}
83
84impl ResponseStorageSanitizer for BlockingBasicClient {
85    fn sanitize_response_storage(&self, response_storage: &mut [u8]) {
86        sanitize_bytes(response_storage);
87    }
88}
89
90impl BoundTransport for BlockingBasicClient {
91    fn endpoint_identity(&self) -> Result<EndpointIdentity<'_>, EndpointIdentityError> {
92        self.endpoint.identity()
93    }
94}
95
96impl fmt::Debug for BlockingBasicClient {
97    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
98        formatter
99            .debug_struct("BlockingBasicClient")
100            .field("endpoint", &"[redacted]")
101            .field("credential", &"[redacted]")
102            .finish_non_exhaustive()
103    }
104}
cloud_sdk_reqwest/blocking/basic_client.rs

cloud_sdk_reqwest/blocking/
basic_client.rs
