Skip to main content

cloud_sdk/authentication/
transport.rs

1use core::fmt;
2use core::future::Future;
3
4use crate::transport::{RawResponsePolicy, ResponseWriter, TransportRequest};
5
6use super::AuthenticationScopePolicy;
7
8/// Request plus mandatory provider or operation-owned authentication policy.
9#[derive(Clone, Copy)]
10pub struct AuthenticatedRequest<'request, 'policy> {
11    request: TransportRequest<'request>,
12    policy: AuthenticationScopePolicy<'policy>,
13    response_policy: RawResponsePolicy<'policy>,
14}
15
16impl<'request, 'policy> AuthenticatedRequest<'request, 'policy> {
17    /// Binds a transport request to its complete authentication policy.
18    #[must_use]
19    pub const fn new(
20        request: TransportRequest<'request>,
21        policy: AuthenticationScopePolicy<'policy>,
22        response_policy: RawResponsePolicy<'policy>,
23    ) -> Self {
24        Self {
25            request,
26            policy,
27            response_policy,
28        }
29    }
30
31    /// Returns the credential-free transport request.
32    #[must_use]
33    pub const fn transport_request(self) -> TransportRequest<'request> {
34        self.request
35    }
36
37    /// Returns the complete authentication policy.
38    #[must_use]
39    pub const fn policy(self) -> AuthenticationScopePolicy<'policy> {
40        self.policy
41    }
42
43    /// Returns the complete status-class raw response policy.
44    #[must_use]
45    pub const fn response_policy(self) -> RawResponsePolicy<'policy> {
46        self.response_policy
47    }
48}
49
50impl fmt::Debug for AuthenticatedRequest<'_, '_> {
51    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
52        formatter
53            .debug_struct("AuthenticatedRequest")
54            .field("request", &self.request)
55            .field("policy", &self.policy)
56            .field("response_policy", &self.response_policy)
57            .finish()
58    }
59}
60
61/// Blocking transport that cannot execute without an authentication policy.
62pub trait BlockingAuthenticatedTransport {
63    /// Transport-specific failure.
64    type Error;
65
66    /// Validates scope and sends one authenticated request.
67    fn send_authenticated(
68        &self,
69        request: AuthenticatedRequest<'_, '_>,
70        response: &mut ResponseWriter<'_>,
71    ) -> Result<(), Self::Error>;
72}
73
74/// Executor-neutral async transport requiring an authentication policy.
75pub trait AsyncAuthenticatedTransport {
76    /// Transport-specific failure.
77    type Error;
78
79    /// Validates scope and sends one authenticated request.
80    fn send_authenticated<'transport, 'request, 'policy, 'writer>(
81        &'transport self,
82        request: AuthenticatedRequest<'request, 'policy>,
83        response: &'writer mut ResponseWriter<'_>,
84    ) -> impl Future<Output = Result<(), Self::Error>> + Send + 'writer
85    where
86        'transport: 'writer,
87        'request: 'writer,
88        'policy: 'writer;
89}