Skip to main content

cloud_sdk_reqwest/asynchronous/
raw.rs

1use core::fmt;
2
3use cloud_sdk::transport::{
4    AsyncRawHttpExecutor, BoundTransport, EndpointIdentity, EndpointIdentityError,
5    RawResponsePolicy, ResponseStorageSanitizer, ResponseWriter, TransportRequest,
6};
7use cloud_sdk_sanitization::sanitize_bytes;
8use http::header::HeaderValue;
9
10use crate::shared::{HttpsEndpoint, RawHyperClient, RawTransportFailure};
11
12/// Raw async HTTP executor with no implicit authentication or provider policy.
13#[derive(Clone)]
14pub struct RawAsyncClient {
15    inner: RawHyperClient,
16    endpoint: HttpsEndpoint,
17}
18
19impl RawAsyncClient {
20    pub(super) const fn new(inner: RawHyperClient, endpoint: HttpsEndpoint) -> Self {
21        Self { inner, endpoint }
22    }
23
24    pub(crate) async fn execute_authenticated(
25        &self,
26        request: TransportRequest<'_>,
27        policy: RawResponsePolicy<'_>,
28        authorization: HeaderValue,
29        response_writer: &mut ResponseWriter<'_>,
30    ) -> Result<(), RawTransportFailure> {
31        self.inner
32            .execute_authenticated(request, policy, authorization, response_writer)
33            .await
34    }
35}
36
37impl AsyncRawHttpExecutor for RawAsyncClient {
38    type Error = RawTransportFailure;
39
40    async fn execute<'executor, 'request, 'policy, 'writer>(
41        &'executor self,
42        request: TransportRequest<'request>,
43        policy: RawResponsePolicy<'policy>,
44        response: &'writer mut ResponseWriter<'_>,
45    ) -> Result<(), Self::Error>
46    where
47        'executor: 'writer,
48        'request: 'writer,
49        'policy: 'writer,
50    {
51        self.inner.execute(request, policy, response).await
52    }
53}
54
55impl ResponseStorageSanitizer for RawAsyncClient {
56    fn sanitize_response_storage(&self, response_storage: &mut [u8]) {
57        sanitize_bytes(response_storage);
58    }
59}
60
61impl BoundTransport for RawAsyncClient {
62    fn endpoint_identity(&self) -> Result<EndpointIdentity<'_>, EndpointIdentityError> {
63        self.endpoint.identity()
64    }
65}
66
67impl fmt::Debug for RawAsyncClient {
68    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
69        formatter
70            .debug_struct("RawAsyncClient")
71            .field("endpoint", &"[redacted]")
72            .finish_non_exhaustive()
73    }
74}