lockbook_server_lib/
error_handler.rs

1use crate::ServerError::InternalError;
2use crate::account_service::DeleteAccountHelperError;
3use crate::billing::billing_service::{AppStoreNotificationError, LockBillingWorkflowError};
4use crate::billing::google_play_client::SimpleGCPError;
5use crate::metrics::MetricsError;
6use crate::{
7    ClientError, GetUsageHelperError, ServerError, SimplifiedStripeError, StripeWebhookError,
8};
9use base64::DecodeError;
10use db_rs::DbError;
11use jsonwebtoken::errors::ErrorKind;
12use lb_rs::model::api::*;
13use lb_rs::model::errors::{DiffError, LbErr, LbErrKind};
14use std::fmt::Debug;
15use std::io::Error;
16use std::sync::PoisonError;
17
18impl<T: Debug> From<Error> for ServerError<T> {
19    fn from(err: Error) -> Self {
20        internal!("IO Error: {:?}", err)
21    }
22}
23
24impl<T: Debug> From<Box<bincode::ErrorKind>> for ServerError<T> {
25    fn from(err: Box<bincode::ErrorKind>) -> Self {
26        internal!("Bincode error: {:?}", err)
27    }
28}
29
30impl<T: Debug> From<stripe::ParseIdError> for ServerError<T> {
31    fn from(err: stripe::ParseIdError) -> Self {
32        internal!("Stripe parse error: {:?}", err)
33    }
34}
35
36impl<T: Debug> From<serde_json::Error> for ServerError<T> {
37    fn from(err: serde_json::Error) -> Self {
38        internal!("Serde json Error: {:?}", err)
39    }
40}
41
42impl From<LbErr> for ServerError<CancelSubscriptionError> {
43    fn from(err: LbErr) -> Self {
44        internal!("{:?}", err)
45    }
46}
47impl From<LbErr> for ServerError<AdminGetAccountInfoError> {
48    fn from(err: LbErr) -> Self {
49        internal!("{:?}", err)
50    }
51}
52impl From<LbErr> for ServerError<GetUsageError> {
53    fn from(err: LbErr) -> Self {
54        internal!("{:?}", err)
55    }
56}
57
58impl From<ServerError<GetUsageHelperError>> for ServerError<GetUsageError> {
59    fn from(e: ServerError<GetUsageHelperError>) -> Self {
60        match e {
61            ServerError::ClientError(GetUsageHelperError::UserNotFound) => {
62                ClientError(GetUsageError::UserNotFound)
63            }
64            _ => internal!("{:?}", e),
65        }
66    }
67}
68
69impl From<ServerError<GetUsageHelperError>> for ServerError<CancelSubscriptionError> {
70    fn from(e: ServerError<GetUsageHelperError>) -> Self {
71        match e {
72            ServerError::ClientError(GetUsageHelperError::UserNotFound) => {
73                ClientError(CancelSubscriptionError::UserNotFound)
74            }
75            _ => internal!("{:?}", e),
76        }
77    }
78}
79
80impl From<SimpleGCPError> for ServerError<UpgradeAccountGooglePlayError> {
81    fn from(e: SimpleGCPError) -> Self {
82        match e {
83            SimpleGCPError::PurchaseTokenNotFound => {
84                ClientError(UpgradeAccountGooglePlayError::InvalidPurchaseToken)
85            }
86            SimpleGCPError::Unexpected(msg) => internal!("{}", msg),
87        }
88    }
89}
90
91impl From<SimpleGCPError> for ServerError<CancelSubscriptionError> {
92    fn from(e: SimpleGCPError) -> Self {
93        internal!("{:#?}", e)
94    }
95}
96
97impl From<SimplifiedStripeError> for ServerError<UpgradeAccountStripeError> {
98    fn from(e: SimplifiedStripeError) -> Self {
99        match e {
100            SimplifiedStripeError::CardDecline => {
101                ClientError(UpgradeAccountStripeError::CardDecline)
102            }
103            SimplifiedStripeError::InsufficientFunds => {
104                ClientError(UpgradeAccountStripeError::InsufficientFunds)
105            }
106            SimplifiedStripeError::TryAgain => ClientError(UpgradeAccountStripeError::TryAgain),
107            SimplifiedStripeError::CardNotSupported => {
108                ClientError(UpgradeAccountStripeError::CardNotSupported)
109            }
110            SimplifiedStripeError::ExpiredCard => {
111                ClientError(UpgradeAccountStripeError::ExpiredCard)
112            }
113            SimplifiedStripeError::InvalidCardNumber => {
114                ClientError(UpgradeAccountStripeError::InvalidCardNumber)
115            }
116            SimplifiedStripeError::InvalidCardExpYear => {
117                ClientError(UpgradeAccountStripeError::InvalidCardExpYear)
118            }
119            SimplifiedStripeError::InvalidCardExpMonth => {
120                ClientError(UpgradeAccountStripeError::InvalidCardExpMonth)
121            }
122            SimplifiedStripeError::InvalidCardCvc => {
123                ClientError(UpgradeAccountStripeError::InvalidCardCvc)
124            }
125            SimplifiedStripeError::Other(msg) => internal!("{}", msg),
126        }
127    }
128}
129
130impl From<stripe::WebhookError> for ServerError<StripeWebhookError> {
131    fn from(e: stripe::WebhookError) -> Self {
132        match e {
133            stripe::WebhookError::BadKey => {
134                internal!(
135                    "Cannot verify stripe webhook request because server is using a bad signing key"
136                )
137            }
138            stripe::WebhookError::BadHeader(bad_header_err) => {
139                ClientError(StripeWebhookError::InvalidHeader(format!("{bad_header_err:?}")))
140            }
141            stripe::WebhookError::BadSignature => {
142                ClientError(StripeWebhookError::InvalidHeader("Bad signature".to_string()))
143            }
144            stripe::WebhookError::BadTimestamp(bad_timestamp_err) => {
145                ClientError(StripeWebhookError::InvalidHeader(format!(
146                    "Timestamp for webhook is too old: {bad_timestamp_err}"
147                )))
148            }
149            stripe::WebhookError::BadParse(bad_parse_err) => ClientError(
150                StripeWebhookError::ParseError(format!("Parsing error: {bad_parse_err:?}")),
151            ),
152        }
153    }
154}
155
156impl From<jsonwebtoken::errors::Error> for ServerError<UpgradeAccountAppStoreError> {
157    fn from(err: jsonwebtoken::errors::Error) -> Self {
158        internal!("JWT error: {:?}", err)
159    }
160}
161
162impl From<reqwest::Error> for ServerError<UpgradeAccountAppStoreError> {
163    fn from(err: reqwest::Error) -> Self {
164        internal!("reqwest error: {:?}", err)
165    }
166}
167
168impl From<reqwest::Error> for ServerError<UpsertDebugInfoError> {
169    fn from(err: reqwest::Error) -> Self {
170        internal!("reqwest error: {:?}", err)
171    }
172}
173
174impl From<base64::DecodeError> for ServerError<AppStoreNotificationError> {
175    fn from(_: DecodeError) -> Self {
176        ClientError(AppStoreNotificationError::InvalidJWS)
177    }
178}
179
180impl From<jsonwebtoken::errors::Error> for ServerError<AppStoreNotificationError> {
181    fn from(err: jsonwebtoken::errors::Error) -> Self {
182        match err.kind() {
183            ErrorKind::InvalidToken
184            | ErrorKind::InvalidSignature
185            | ErrorKind::MissingRequiredClaim(_)
186            | ErrorKind::ExpiredSignature
187            | ErrorKind::InvalidIssuer
188            | ErrorKind::InvalidAudience
189            | ErrorKind::InvalidSubject
190            | ErrorKind::ImmatureSignature
191            | ErrorKind::InvalidAlgorithm
192            | ErrorKind::MissingAlgorithm
193            | ErrorKind::Base64(_)
194            | ErrorKind::Json(_)
195            | ErrorKind::Utf8(_) => ClientError(AppStoreNotificationError::InvalidJWS),
196            ErrorKind::InvalidEcdsaKey
197            | ErrorKind::InvalidRsaKey(_)
198            | ErrorKind::RsaFailedSigning
199            | ErrorKind::InvalidAlgorithmName
200            | ErrorKind::InvalidKeyFormat
201            | ErrorKind::Crypto(_)
202            | &_ => internal!("JWT error: {:?}", err),
203        }
204    }
205}
206
207impl From<ServerError<LockBillingWorkflowError>> for ServerError<UpgradeAccountGooglePlayError> {
208    fn from(err: ServerError<LockBillingWorkflowError>) -> Self {
209        match err {
210            ClientError(LockBillingWorkflowError::ExistingRequestPending) => {
211                ClientError(UpgradeAccountGooglePlayError::ExistingRequestPending)
212            }
213            ClientError(LockBillingWorkflowError::UserNotFound) => {
214                ClientError(UpgradeAccountGooglePlayError::UserNotFound)
215            }
216            InternalError(msg) => InternalError(msg),
217        }
218    }
219}
220
221impl From<ServerError<LockBillingWorkflowError>> for ServerError<UpgradeAccountAppStoreError> {
222    fn from(err: ServerError<LockBillingWorkflowError>) -> Self {
223        match err {
224            ClientError(LockBillingWorkflowError::ExistingRequestPending) => {
225                ClientError(UpgradeAccountAppStoreError::ExistingRequestPending)
226            }
227            ClientError(LockBillingWorkflowError::UserNotFound) => {
228                ClientError(UpgradeAccountAppStoreError::UserNotFound)
229            }
230            InternalError(msg) => InternalError(msg),
231        }
232    }
233}
234
235impl From<ServerError<LockBillingWorkflowError>> for ServerError<UpgradeAccountStripeError> {
236    fn from(err: ServerError<LockBillingWorkflowError>) -> Self {
237        match err {
238            ClientError(LockBillingWorkflowError::ExistingRequestPending) => {
239                ClientError(UpgradeAccountStripeError::ExistingRequestPending)
240            }
241            ClientError(LockBillingWorkflowError::UserNotFound) => {
242                ClientError(UpgradeAccountStripeError::UserNotFound)
243            }
244            InternalError(msg) => InternalError(msg),
245        }
246    }
247}
248
249impl From<ServerError<LockBillingWorkflowError>> for ServerError<CancelSubscriptionError> {
250    fn from(err: ServerError<LockBillingWorkflowError>) -> Self {
251        match err {
252            ClientError(LockBillingWorkflowError::ExistingRequestPending) => {
253                ClientError(CancelSubscriptionError::ExistingRequestPending)
254            }
255            ClientError(LockBillingWorkflowError::UserNotFound) => {
256                ClientError(CancelSubscriptionError::UserNotFound)
257            }
258            InternalError(msg) => InternalError(msg),
259        }
260    }
261}
262
263impl From<ServerError<LockBillingWorkflowError>> for ServerError<AdminSetUserTierError> {
264    fn from(err: ServerError<LockBillingWorkflowError>) -> Self {
265        match err {
266            ClientError(LockBillingWorkflowError::ExistingRequestPending) => {
267                ClientError(AdminSetUserTierError::ExistingRequestPending)
268            }
269            ClientError(LockBillingWorkflowError::UserNotFound) => {
270                ClientError(AdminSetUserTierError::UserNotFound)
271            }
272            InternalError(msg) => InternalError(msg),
273        }
274    }
275}
276
277impl From<LbErr> for ServerError<DeleteAccountHelperError> {
278    fn from(err: LbErr) -> Self {
279        internal!("{:?}", err)
280    }
281}
282
283impl From<ServerError<DeleteAccountHelperError>> for ServerError<DeleteAccountError> {
284    fn from(err: ServerError<DeleteAccountHelperError>) -> Self {
285        match err {
286            ClientError(DeleteAccountHelperError::UserNotFound) => {
287                ClientError(DeleteAccountError::UserNotFound)
288            }
289            InternalError(msg) => InternalError(msg),
290        }
291    }
292}
293
294impl From<ServerError<DeleteAccountHelperError>> for ServerError<AdminDisappearAccountError> {
295    fn from(err: ServerError<DeleteAccountHelperError>) -> Self {
296        match err {
297            ClientError(DeleteAccountHelperError::UserNotFound) => {
298                ClientError(AdminDisappearAccountError::UserNotFound)
299            }
300            InternalError(msg) => InternalError(msg),
301        }
302    }
303}
304
305impl From<LbErr> for ServerError<AdminValidateAccountError> {
306    fn from(err: LbErr) -> Self {
307        internal!("{:?}", err)
308    }
309}
310
311impl From<LbErr> for ServerError<AdminValidateServerError> {
312    fn from(err: LbErr) -> Self {
313        internal!("{:?}", err)
314    }
315}
316
317impl From<LbErr> for ServerError<AdminFileInfoError> {
318    fn from(err: LbErr) -> Self {
319        internal!("{:?}", err)
320    }
321}
322
323impl From<LbErr> for ServerError<AdminDisappearFileError> {
324    fn from(err: LbErr) -> Self {
325        internal!("{:?}", err)
326    }
327}
328
329impl From<LbErr> for ServerError<UpsertError> {
330    fn from(err: LbErr) -> Self {
331        use lb_rs::model::api::UpsertError::*;
332        match err.kind {
333            LbErrKind::Diff(diff) => match diff {
334                DiffError::OldVersionIncorrect => ClientError(OldVersionIncorrect),
335                DiffError::OldFileNotFound => ClientError(OldFileNotFound),
336                DiffError::OldVersionRequired => ClientError(OldVersionRequired),
337                DiffError::DiffMalformed => ClientError(DiffMalformed),
338                DiffError::HmacModificationInvalid => ClientError(HmacModificationInvalid),
339                DiffError::SizeModificationInvalid => ClientError(SizeModificationInvalid),
340            },
341            LbErrKind::InsufficientPermission => ClientError(NotPermissioned),
342            LbErrKind::Validation(fail) => ClientError(Validation(fail)),
343            LbErrKind::RootModificationInvalid => ClientError(RootModificationInvalid),
344            LbErrKind::Unexpected(msg) => InternalError(msg),
345            _ => internal!("{:?}", err),
346        }
347    }
348}
349
350impl From<LbErr> for ServerError<ChangeDocError> {
351    fn from(err: LbErr) -> Self {
352        internal!("{:?}", err)
353    }
354}
355
356impl From<LbErr> for ServerError<MetricsError> {
357    fn from(err: LbErr) -> Self {
358        internal!("{:?}", err)
359    }
360}
361
362impl From<LbErr> for ServerError<GetDocumentError> {
363    fn from(err: LbErr) -> Self {
364        internal!("{:?}", err)
365    }
366}
367
368impl From<LbErr> for ServerError<GetFileIdsError> {
369    fn from(err: LbErr) -> Self {
370        internal!("{:?}", err)
371    }
372}
373
374impl From<LbErr> for ServerError<GetUpdatesError> {
375    fn from(err: LbErr) -> Self {
376        internal!("{:?}", err)
377    }
378}
379
380impl<T: Debug> From<DbError> for ServerError<T> {
381    fn from(value: DbError) -> Self {
382        internal!("db-rs error {:?}", value)
383    }
384}
385
386impl<T: Debug, G> From<PoisonError<G>> for ServerError<T> {
387    fn from(value: PoisonError<G>) -> Self {
388        internal!("mutex poisoned {:?}", value)
389    }
390}
lockbook_server_lib/error_handler.rs

lockbook_server_lib/
error_handler.rs
