oauth10a 3.0.0

A rust implementation of the oauth 1.0a protocol fully-async with logging, metrics and tracing facilities
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! HTTP client

use core::fmt;

use reqwest::{Request, Response};

use crate::{
    credentials::{AuthorizationError, Credentials},
    execute::ExecuteRequest,
};

// CLIENT ERROR ////////////////////////////////////////////////////////////////

#[derive(Debug, thiserror::Error)]
pub enum ClientError<E = reqwest::Error> {
    #[error("failed to authorize request, {0}")]
    Authorize(#[from] AuthorizationError),
    #[error("failed to execute request, {0}")]
    Execute(E),
}

// CLIENT //////////////////////////////////////////////////////////////////////

/// HTTP client with optional [`Credentials`].
///
/// When credentials are provided, the client, will ensure requests are authorized
/// before they are executed.
#[derive(Debug, Default, Clone)]
#[must_use]
pub struct Client<T = reqwest::Client> {
    inner: T,
    credentials: Option<Credentials>,
}

impl<T> From<T> for Client<T> {
    fn from(value: T) -> Self {
        Self {
            inner: value,
            credentials: None,
        }
    }
}

impl From<&Credentials> for Client {
    fn from(value: &Credentials) -> Self {
        Self::from(value.clone())
    }
}

impl<T: Into<Box<str>>> From<Credentials<T>> for Client {
    fn from(value: Credentials<T>) -> Self {
        Self {
            inner: reqwest::Client::new(),
            credentials: Some(value.into()),
        }
    }
}

impl Client {
    pub fn new() -> Self {
        Self::default()
    }
}

impl<T: fmt::Debug> Client<T> {
    /// Sets the `credentials` to be used by the client to authorize HTTP request,
    /// discarding the current value, if any.
    #[cfg_attr(feature = "tracing", tracing::instrument)]
    pub fn set_credentials(&mut self, credentials: Option<Credentials>) {
        self.credentials = credentials;
    }

    #[cfg_attr(feature = "tracing", tracing::instrument)]
    fn set_credentials_from<U: Into<Box<str>> + fmt::Debug>(
        &mut self,
        credentials: Option<Credentials<U>>,
    ) {
        self.credentials = credentials.map(Credentials::into);
    }

    /// Fills the `credentials` to be used by the client to authorize HTTP request,
    /// discarding the current value, if any.
    pub fn with_credentials<U: Into<Box<str>> + fmt::Debug>(
        mut self,
        credentials: impl Into<Option<Credentials<U>>>,
    ) -> Self {
        self.set_credentials_from(credentials.into());
        self
    }

    /// Returns the credentials that will be used by this client to authorized
    /// subsequent HTTP requests.
    #[cfg_attr(feature = "tracing", tracing::instrument)]
    pub fn credentials(&self) -> Option<Credentials<&str>> {
        self.credentials.as_ref().map(Credentials::as_ref)
    }

    /// Returns a shared reference to the inner HTTP client.
    #[cfg_attr(feature = "tracing", tracing::instrument)]
    pub fn inner(&self) -> &T {
        &self.inner
    }

    /// Appends an `Authorization` header to the `request`, if this client has credentials and unless it is already set.
    ///
    /// Returns `true` if the `Authorization` header was inserted.
    ///
    /// # Errors
    ///
    /// Upon failure to produce the header value.
    ///
    /// If the client doesn't have credentials, this method is infallible.
    #[cfg_attr(feature = "tracing", tracing::instrument)]
    pub fn authorize(&self, request: &mut Request) -> Result<bool, AuthorizationError> {
        match self.credentials() {
            None => Ok(false),
            Some(credentials) => credentials.authorize(request),
        }
    }
}

impl<T: ExecuteRequest> ExecuteRequest for Client<T> {
    type Error = ClientError<T::Error>;

    fn execute_request(
        &self,
        mut request: Request,
    ) -> impl Future<Output = Result<Response, Self::Error>> + Send + 'static {
        let result = self
            .authorize(&mut request)
            .map(|_| self.inner.execute_request(request));

        async move { result?.await.map_err(ClientError::Execute) }
    }
}

#[cfg(feature = "zeroize")]
impl<T> Drop for Client<T> {
    fn drop(&mut self) {
        use zeroize::Zeroize;

        if let Some(mut credentials) = self.credentials.take() {
            credentials.zeroize();
        }
    }
}