cloud_sdk_reqwest/asynchronous/
basic_client.rs

1use core::fmt;
2use std::sync::Arc;
3
4use cloud_sdk::authentication::{AsyncAuthenticatedTransport, AuthenticatedRequest};
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::RawAsyncClient;
17
18/// Hardened provider-neutral reqwest asynchronous Basic-auth transport.
19#[derive(Clone)]
20pub struct AsyncBasicClient {
21    client: RawAsyncClient,
22    endpoint: HttpsEndpoint,
23    credential: Arc<BasicCredential>,
24    allow_insecure_loopback: bool,
25}
26
27impl AsyncBasicClient {
28    pub(super) fn new(
29        client: RawAsyncClient,
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    async 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            .await
69            .map_err(|failure| failure.map(TransportError::RawHttp))
70    }
71}
72
73impl AsyncAuthenticatedTransport for AsyncBasicClient {
74    type Error = AuthenticatedTransportFailure;
75
76    async fn send_authenticated<'transport, 'request, 'policy, 'writer>(
77        &'transport self,
78        request: AuthenticatedRequest<'request, 'policy>,
79        response: &'writer mut ResponseWriter<'_>,
80    ) -> Result<(), Self::Error>
81    where
82        'transport: 'writer,
83        'request: 'writer,
84        'policy: 'writer,
85    {
86        self.send_inner(request, response).await
87    }
88}
89
90impl ResponseStorageSanitizer for AsyncBasicClient {
91    fn sanitize_response_storage(&self, response_storage: &mut [u8]) {
92        sanitize_bytes(response_storage);
93    }
94}
95
96impl BoundTransport for AsyncBasicClient {
97    fn endpoint_identity(&self) -> Result<EndpointIdentity<'_>, EndpointIdentityError> {
98        self.endpoint.identity()
99    }
100}
101
102impl fmt::Debug for AsyncBasicClient {
103    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
104        formatter
105            .debug_struct("AsyncBasicClient")
106            .field("endpoint", &"[redacted]")
107            .field("credential", &"[redacted]")
108            .finish_non_exhaustive()
109    }
110}
cloud_sdk_reqwest/asynchronous/basic_client.rs

cloud_sdk_reqwest/asynchronous/
basic_client.rs
