sett 0.4.0

Rust port of sett (data compression, encryption and transfer tool).
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

//! Error types occurring during authentication

pub use openidconnect;
pub use reqwest;

type OpenIdRequestCoreError = openidconnect::RequestTokenError<
    reqwest::Error,
    openidconnect::StandardErrorResponse<openidconnect::core::CoreErrorResponseType>,
>;
type OpenIdRequestDeviceError = openidconnect::RequestTokenError<
    reqwest::Error,
    openidconnect::StandardErrorResponse<openidconnect::DeviceCodeErrorResponseType>,
>;
type OpenIdUserInfoError = openidconnect::UserInfoError<reqwest::Error>;
type OpenIdConfigurationError = openidconnect::ConfigurationError;

/// Error generated during openid provider metadata discovery
pub type OpenIdDiscoveryError = openidconnect::DiscoveryError<reqwest::Error>;

/// Error occurring when trying to parse an url
#[derive(Debug)]
pub struct UrlParseError(pub String);

impl std::fmt::Display for UrlParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(f)
    }
}
impl core::error::Error for UrlParseError {}

/// Error occurring during client configuration
#[derive(Debug)]
pub enum ConfigError {
    /// OpenID provider metadata discovery error
    OpenIdDiscovery(OpenIdDiscoveryError),
    /// HTTP client error
    HttpClient(reqwest::Error),
}

impl core::error::Error for ConfigError {}

impl From<OpenIdDiscoveryError> for ConfigError {
    fn from(value: OpenIdDiscoveryError) -> Self {
        Self::OpenIdDiscovery(value)
    }
}

impl From<reqwest::Error> for ConfigError {
    fn from(value: reqwest::Error) -> Self {
        Self::HttpClient(value)
    }
}

impl std::fmt::Display for ConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::OpenIdDiscovery(e) => e.fmt(f),
            Self::HttpClient(e) => {
                write!(f, "Unable to crate an HTTP client: {e:?}")
            }
        }
    }
}

/// Error occuring during authentication
#[derive(Debug)]
pub enum AuthError<E> {
    /// Error caused by an auth handler
    Handler(E),
    /// Auth fails during configuration of device code exchange
    OpenIdConfig(OpenIdConfigurationError),
    /// Auth fails during device code exchange (request)
    OpenIdRequestCore(OpenIdRequestCoreError),
    /// Auth fails during device access token exchange (request)
    OpenIdRequestDevice(OpenIdRequestDeviceError),
}

impl<E> std::fmt::Display for AuthError<E>
where
    E: std::fmt::Display,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Handler(e) => e.fmt(f),
            Self::OpenIdConfig(e) => e.fmt(f),
            Self::OpenIdRequestCore(e) => e.fmt(f),
            Self::OpenIdRequestDevice(e) => e.fmt(f),
        }
    }
}
impl<E> core::error::Error for AuthError<E> where E: std::fmt::Debug + std::fmt::Display {}
impl<E> From<OpenIdConfigurationError> for AuthError<E> {
    fn from(value: OpenIdConfigurationError) -> Self {
        Self::OpenIdConfig(value)
    }
}
impl<E> From<OpenIdRequestCoreError> for AuthError<E> {
    fn from(value: OpenIdRequestCoreError) -> Self {
        Self::OpenIdRequestCore(value)
    }
}
impl<E> From<OpenIdRequestDeviceError> for AuthError<E> {
    fn from(value: OpenIdRequestDeviceError) -> Self {
        Self::OpenIdRequestDevice(value)
    }
}

#[derive(Debug)]
/// Error occurring when retrieving user info
pub enum UserInfoError {
    /// Retrieval of user info fails during preparation of the request
    Config(OpenIdConfigurationError),
    /// Error while sending the request
    UserInfo(OpenIdUserInfoError),
}
impl std::fmt::Display for UserInfoError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::UserInfo(e) => {
                write!(f, "Failed requesting user info: {e:?}")
            }
            Self::Config(e) => {
                write!(f, "No user info endpoint: {e:?}")
            }
        }
    }
}
impl core::error::Error for UserInfoError {}
impl From<OpenIdConfigurationError> for UserInfoError {
    fn from(value: OpenIdConfigurationError) -> Self {
        Self::Config(value)
    }
}
impl From<OpenIdUserInfoError> for UserInfoError {
    fn from(value: OpenIdUserInfoError) -> Self {
        Self::UserInfo(value)
    }
}

#[derive(Debug)]
/// Error occuring when refreshing a token
pub enum RefreshTokenError {
    /// Token refresh fails during preparation of the request
    Config(OpenIdConfigurationError),
    /// OpenId request error
    RequestCore(OpenIdRequestCoreError),
}

impl std::fmt::Display for RefreshTokenError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Config(e) => {
                write!(f, "No token refresh endpoint: {e:?}")
            }
            Self::RequestCore(e) => e.fmt(f),
        }
    }
}
impl core::error::Error for RefreshTokenError {}
impl From<OpenIdConfigurationError> for RefreshTokenError {
    fn from(value: OpenIdConfigurationError) -> Self {
        Self::Config(value)
    }
}
impl From<OpenIdRequestCoreError> for RefreshTokenError {
    fn from(value: OpenIdRequestCoreError) -> Self {
        Self::RequestCore(value)
    }
}