cloud-sdk 0.95.0

no_std-first provider-neutral cloud SDK foundations.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use super::{ClientExecutionError, ClientKernel, ClientResponse, ClientWorkspaceLease};
use crate::authentication::{
    AsyncAuthenticatedTransport, BlockingAuthenticatedTransport, LocalAsyncAuthenticatedTransport,
};
use crate::operation::{PreparationStorageGuard, PreparedRequest};
use crate::transport::BoundTransport;

impl<T> ClientKernel<T>
where
    T: BlockingAuthenticatedTransport + BoundTransport,
{
    /// Executes through cleanup-owning provider preparation and decoding hooks.
    pub fn execute_blocking_with<'operation, O, R, P, D, F, G, const N: usize>(
        &self,
        operation: &'operation O,
        mut lease: ClientWorkspaceLease<'_, '_, N>,
        prepare: F,
        decode: G,
    ) -> Result<R, ClientExecutionError<P, T::Error, D>>
    where
        F: for<'guard> FnOnce(
            &'operation O,
            &'guard mut PreparationStorageGuard<'_>,
        ) -> Result<PreparedRequest<'guard>, P>,
        G: FnOnce(&'operation O, ClientResponse<'_, '_>) -> Result<R, D>,
    {
        let mut parts = lease.parts_mut();
        parts.clear();
        let mut storage = PreparationStorageGuard::new(parts.target, parts.request_body);
        let prepared =
            prepare(operation, &mut storage).map_err(ClientExecutionError::Preparation)?;
        let response = prepared
            .send_blocking(&self.transport, parts.response_body, parts.response_headers)
            .map_err(ClientExecutionError::Execution)?;
        decode(operation, ClientResponse::new(prepared, response))
            .map_err(ClientExecutionError::Decode)
    }
}

impl<T> ClientKernel<T>
where
    T: AsyncAuthenticatedTransport + BoundTransport + Sync,
{
    /// Send-async equivalent of [`Self::execute_blocking_with`].
    #[allow(clippy::manual_async_fn)]
    pub fn execute_async_with<'operation, O, R, P, D, F, G, const N: usize>(
        &self,
        operation: &'operation O,
        mut lease: ClientWorkspaceLease<'_, '_, N>,
        prepare: F,
        decode: G,
    ) -> impl core::future::Future<Output = Result<R, ClientExecutionError<P, T::Error, D>>> + Send
    where
        O: Sync,
        P: Send,
        R: Send,
        D: Send,
        F: for<'guard> FnOnce(
                &'operation O,
                &'guard mut PreparationStorageGuard<'_>,
            ) -> Result<PreparedRequest<'guard>, P>
            + Send,
        G: FnOnce(&'operation O, ClientResponse<'_, '_>) -> Result<R, D> + Send,
        T::Error: Send,
    {
        async move {
            let mut parts = lease.parts_mut();
            parts.clear();
            let mut storage = PreparationStorageGuard::new(parts.target, parts.request_body);
            let prepared =
                prepare(operation, &mut storage).map_err(ClientExecutionError::Preparation)?;
            let response = prepared
                .send_async(&self.transport, parts.response_body, parts.response_headers)
                .await
                .map_err(ClientExecutionError::Execution)?;
            decode(operation, ClientResponse::new(prepared, response))
                .map_err(ClientExecutionError::Decode)
        }
    }
}

impl<T> ClientKernel<T>
where
    T: LocalAsyncAuthenticatedTransport + BoundTransport,
{
    /// Local-async equivalent of [`Self::execute_blocking_with`].
    pub async fn execute_local_async_with<'operation, O, R, P, D, F, G, const N: usize>(
        &self,
        operation: &'operation O,
        mut lease: ClientWorkspaceLease<'_, '_, N>,
        prepare: F,
        decode: G,
    ) -> Result<R, ClientExecutionError<P, T::Error, D>>
    where
        F: for<'guard> FnOnce(
            &'operation O,
            &'guard mut PreparationStorageGuard<'_>,
        ) -> Result<PreparedRequest<'guard>, P>,
        G: FnOnce(&'operation O, ClientResponse<'_, '_>) -> Result<R, D>,
    {
        let mut parts = lease.parts_mut();
        parts.clear();
        let mut storage = PreparationStorageGuard::new(parts.target, parts.request_body);
        let prepared =
            prepare(operation, &mut storage).map_err(ClientExecutionError::Preparation)?;
        let response = prepared
            .send_local_async(&self.transport, parts.response_body, parts.response_headers)
            .await
            .map_err(ClientExecutionError::Execution)?;
        decode(operation, ClientResponse::new(prepared, response))
            .map_err(ClientExecutionError::Decode)
    }
}