lockbook_server_lib/
error_handler.rs

1use crate::account_service::DeleteAccountHelperError;
2use crate::billing::billing_service::{AppStoreNotificationError, LockBillingWorkflowError};
3use crate::billing::google_play_client::SimpleGCPError;
4use crate::metrics::MetricsError;
5use crate::ServerError::InternalError;
6use crate::{
7    ClientError, GetUsageHelperError, ServerError, SimplifiedStripeError, StripeWebhookError,
8};
9use base64::DecodeError;
10use db_rs::DbError;
11use jsonwebtoken::errors::ErrorKind;
12use lockbook_shared::api::*;
13use lockbook_shared::{SharedError, SharedErrorKind};
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<SharedError> for ServerError<CancelSubscriptionError> {
43    fn from(err: SharedError) -> Self {
44        internal!("{:?}", err)
45    }
46}
47impl From<SharedError> for ServerError<AdminGetAccountInfoError> {
48    fn from(err: SharedError) -> Self {
49        internal!("{:?}", err)
50    }
51}
52impl From<SharedError> for ServerError<GetUsageError> {
53    fn from(err: SharedError) -> 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!("Cannot verify stripe webhook request because server is using a bad signing key")
135            }
136            stripe::WebhookError::BadHeader(bad_header_err) => {
137                ClientError(StripeWebhookError::InvalidHeader(format!("{:?}", bad_header_err)))
138            }
139            stripe::WebhookError::BadSignature => {
140                ClientError(StripeWebhookError::InvalidHeader("Bad signature".to_string()))
141            }
142            stripe::WebhookError::BadTimestamp(bad_timestamp_err) => {
143                ClientError(StripeWebhookError::InvalidHeader(format!(
144                    "Timestamp for webhook is too old: {}",
145                    bad_timestamp_err
146                )))
147            }
148            stripe::WebhookError::BadParse(bad_parse_err) => ClientError(
149                StripeWebhookError::ParseError(format!("Parsing error: {:?}", bad_parse_err)),
150            ),
151        }
152    }
153}
154
155impl From<jsonwebtoken::errors::Error> for ServerError<UpgradeAccountAppStoreError> {
156    fn from(err: jsonwebtoken::errors::Error) -> Self {
157        internal!("JWT error: {:?}", err)
158    }
159}
160
161impl From<reqwest::Error> for ServerError<UpgradeAccountAppStoreError> {
162    fn from(err: reqwest::Error) -> Self {
163        internal!("reqwest error: {:?}", err)
164    }
165}
166
167impl From<base64::DecodeError> for ServerError<AppStoreNotificationError> {
168    fn from(_: DecodeError) -> Self {
169        ClientError(AppStoreNotificationError::InvalidJWS)
170    }
171}
172
173impl From<jsonwebtoken::errors::Error> for ServerError<AppStoreNotificationError> {
174    fn from(err: jsonwebtoken::errors::Error) -> Self {
175        match err.kind() {
176            ErrorKind::InvalidToken
177            | ErrorKind::InvalidSignature
178            | ErrorKind::MissingRequiredClaim(_)
179            | ErrorKind::ExpiredSignature
180            | ErrorKind::InvalidIssuer
181            | ErrorKind::InvalidAudience
182            | ErrorKind::InvalidSubject
183            | ErrorKind::ImmatureSignature
184            | ErrorKind::InvalidAlgorithm
185            | ErrorKind::MissingAlgorithm
186            | ErrorKind::Base64(_)
187            | ErrorKind::Json(_)
188            | ErrorKind::Utf8(_) => ClientError(AppStoreNotificationError::InvalidJWS),
189            ErrorKind::InvalidEcdsaKey
190            | ErrorKind::InvalidRsaKey(_)
191            | ErrorKind::RsaFailedSigning
192            | ErrorKind::InvalidAlgorithmName
193            | ErrorKind::InvalidKeyFormat
194            | ErrorKind::Crypto(_)
195            | &_ => internal!("JWT error: {:?}", err),
196        }
197    }
198}
199
200impl From<ServerError<LockBillingWorkflowError>> for ServerError<UpgradeAccountGooglePlayError> {
201    fn from(err: ServerError<LockBillingWorkflowError>) -> Self {
202        match err {
203            ClientError(LockBillingWorkflowError::ExistingRequestPending) => {
204                ClientError(UpgradeAccountGooglePlayError::ExistingRequestPending)
205            }
206            ClientError(LockBillingWorkflowError::UserNotFound) => {
207                ClientError(UpgradeAccountGooglePlayError::UserNotFound)
208            }
209            InternalError(msg) => InternalError(msg),
210        }
211    }
212}
213
214impl From<ServerError<LockBillingWorkflowError>> for ServerError<UpgradeAccountAppStoreError> {
215    fn from(err: ServerError<LockBillingWorkflowError>) -> Self {
216        match err {
217            ClientError(LockBillingWorkflowError::ExistingRequestPending) => {
218                ClientError(UpgradeAccountAppStoreError::ExistingRequestPending)
219            }
220            ClientError(LockBillingWorkflowError::UserNotFound) => {
221                ClientError(UpgradeAccountAppStoreError::UserNotFound)
222            }
223            InternalError(msg) => InternalError(msg),
224        }
225    }
226}
227
228impl From<ServerError<LockBillingWorkflowError>> for ServerError<UpgradeAccountStripeError> {
229    fn from(err: ServerError<LockBillingWorkflowError>) -> Self {
230        match err {
231            ClientError(LockBillingWorkflowError::ExistingRequestPending) => {
232                ClientError(UpgradeAccountStripeError::ExistingRequestPending)
233            }
234            ClientError(LockBillingWorkflowError::UserNotFound) => {
235                ClientError(UpgradeAccountStripeError::UserNotFound)
236            }
237            InternalError(msg) => InternalError(msg),
238        }
239    }
240}
241
242impl From<ServerError<LockBillingWorkflowError>> for ServerError<CancelSubscriptionError> {
243    fn from(err: ServerError<LockBillingWorkflowError>) -> Self {
244        match err {
245            ClientError(LockBillingWorkflowError::ExistingRequestPending) => {
246                ClientError(CancelSubscriptionError::ExistingRequestPending)
247            }
248            ClientError(LockBillingWorkflowError::UserNotFound) => {
249                ClientError(CancelSubscriptionError::UserNotFound)
250            }
251            InternalError(msg) => InternalError(msg),
252        }
253    }
254}
255
256impl From<ServerError<LockBillingWorkflowError>> for ServerError<AdminSetUserTierError> {
257    fn from(err: ServerError<LockBillingWorkflowError>) -> Self {
258        match err {
259            ClientError(LockBillingWorkflowError::ExistingRequestPending) => {
260                ClientError(AdminSetUserTierError::ExistingRequestPending)
261            }
262            ClientError(LockBillingWorkflowError::UserNotFound) => {
263                ClientError(AdminSetUserTierError::UserNotFound)
264            }
265            InternalError(msg) => InternalError(msg),
266        }
267    }
268}
269
270impl From<SharedError> for ServerError<DeleteAccountHelperError> {
271    fn from(err: SharedError) -> Self {
272        internal!("{:?}", err)
273    }
274}
275
276impl From<ServerError<DeleteAccountHelperError>> for ServerError<DeleteAccountError> {
277    fn from(err: ServerError<DeleteAccountHelperError>) -> Self {
278        match err {
279            ClientError(DeleteAccountHelperError::UserNotFound) => {
280                ClientError(DeleteAccountError::UserNotFound)
281            }
282            InternalError(msg) => InternalError(msg),
283        }
284    }
285}
286
287impl From<ServerError<DeleteAccountHelperError>> for ServerError<AdminDisappearAccountError> {
288    fn from(err: ServerError<DeleteAccountHelperError>) -> Self {
289        match err {
290            ClientError(DeleteAccountHelperError::UserNotFound) => {
291                ClientError(AdminDisappearAccountError::UserNotFound)
292            }
293            InternalError(msg) => InternalError(msg),
294        }
295    }
296}
297
298impl From<SharedError> for ServerError<AdminValidateAccountError> {
299    fn from(err: SharedError) -> Self {
300        internal!("{:?}", err)
301    }
302}
303
304impl From<SharedError> for ServerError<AdminValidateServerError> {
305    fn from(err: SharedError) -> Self {
306        internal!("{:?}", err)
307    }
308}
309
310impl From<SharedError> for ServerError<AdminFileInfoError> {
311    fn from(err: SharedError) -> Self {
312        internal!("{:?}", err)
313    }
314}
315
316impl From<SharedError> for ServerError<AdminDisappearFileError> {
317    fn from(err: SharedError) -> Self {
318        internal!("{:?}", err)
319    }
320}
321
322impl From<SharedError> for ServerError<UpsertError> {
323    fn from(err: SharedError) -> Self {
324        // panic!("{err}");
325        use lockbook_shared::api::UpsertError::*;
326        match err.kind {
327            SharedErrorKind::OldVersionIncorrect => ClientError(OldVersionIncorrect),
328            SharedErrorKind::OldFileNotFound => ClientError(OldFileNotFound),
329            SharedErrorKind::OldVersionRequired => ClientError(OldVersionRequired),
330            SharedErrorKind::InsufficientPermission => ClientError(NotPermissioned),
331            SharedErrorKind::DiffMalformed => ClientError(DiffMalformed),
332            SharedErrorKind::HmacModificationInvalid => ClientError(HmacModificationInvalid),
333            SharedErrorKind::DeletedFileUpdated(_) => ClientError(DeletedFileUpdated),
334            SharedErrorKind::RootModificationInvalid => ClientError(RootModificationInvalid),
335            SharedErrorKind::ValidationFailure(fail) => ClientError(Validation(fail)),
336            SharedErrorKind::Unexpected(msg) => InternalError(String::from(msg)),
337            _ => internal!("{:?}", err),
338        }
339    }
340}
341
342impl From<SharedError> for ServerError<ChangeDocError> {
343    fn from(err: SharedError) -> Self {
344        internal!("{:?}", err)
345    }
346}
347
348impl From<SharedError> for ServerError<MetricsError> {
349    fn from(err: SharedError) -> Self {
350        internal!("{:?}", err)
351    }
352}
353
354impl From<SharedError> for ServerError<GetDocumentError> {
355    fn from(err: SharedError) -> Self {
356        internal!("{:?}", err)
357    }
358}
359
360impl From<SharedError> for ServerError<GetFileIdsError> {
361    fn from(err: SharedError) -> Self {
362        internal!("{:?}", err)
363    }
364}
365
366impl From<SharedError> for ServerError<GetUpdatesError> {
367    fn from(err: SharedError) -> Self {
368        internal!("{:?}", err)
369    }
370}
371
372impl<T: Debug> From<DbError> for ServerError<T> {
373    fn from(value: DbError) -> Self {
374        internal!("db-rs error {:?}", value)
375    }
376}
377
378impl<T: Debug, G> From<PoisonError<G>> for ServerError<T> {
379    fn from(value: PoisonError<G>) -> Self {
380        internal!("mutex poisoned {:?}", value)
381    }
382}
lockbook_server_lib/error_handler.rs

lockbook_server_lib/
error_handler.rs
