xapi-rs 0.2.0

A conformant LRS implementation of xAPI 2.0.0
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

// SPDX-License-Identifier: GPL-3.0-or-later

use rocket::{
    Request, Response,
    http::Status,
    response::{self, Responder},
};
use serde_json::json;
use std::{borrow::Cow, io};
use thiserror::Error;
use tracing::{error, info};
use xapi_data::DataError;

/// Enumeration of different error types raised by this crate.
#[derive(Debug, Error)]
pub enum MyError {
    /// xAPI format violation error.
    #[error("Failed matching '{input:?}' to {name:?} format pattern")]
    Format {
        #[doc(hidden)]
        input: Cow<'static, str>,
        #[doc(hidden)]
        name: Cow<'static, str>,
    },

    /// Data serialization/deserialization, parsing and validation errors.
    #[error("General data error: {0}")]
    Data(
        #[doc(hidden)]
        #[from]
        DataError,
    ),

    /// Base64 decoding error.
    #[error("Base64 decode error: {0}")]
    Base64(
        #[doc(hidden)]
        #[from]
        base64::DecodeError,
    ),

    /// UTF-8 string conversion error.
    #[error("UTF8 conversion error: {0}")]
    UTF8(
        #[doc(hidden)]
        #[from]
        std::str::Utf8Error,
    ),

    /// Rocket Multipart error.
    #[error("Multipart/mixed parse error: {0}")]
    MULTIPART(
        #[doc(hidden)]
        #[from]
        rocket_multipart::Error,
    ),

    /// DB pool/connection error.
    #[error("DB error: {0}")]
    DB(
        #[doc(hidden)]
        #[from]
        sqlx::Error,
    ),

    /// DB migration error.
    #[error("DB migration error: {0}")]
    DBMigrate(
        #[doc(hidden)]
        #[from]
        sqlx::migrate::MigrateError,
    ),

    /// Unexpected runtime error.
    #[error("{0}")]
    Runtime(#[doc(hidden)] Cow<'static, str>),

    /// I/O error.
    #[error("I/O error: {0}")]
    IO(
        #[doc(hidden)]
        #[from]
        io::Error,
    ),

    /// OpenSSL error.
    #[error("OpenSSL error: {0}")]
    OSSL(
        #[doc(hidden)]
        #[from]
        openssl::error::ErrorStack,
    ),

    /// JOSE error.
    #[error("JOSE error: {0}")]
    JOSE(
        #[doc(hidden)]
        #[from]
        josekit::JoseError,
    ),

    /// Rocket-fiendly handler error.
    #[error("Rocket handler error ({status}): {info}")]
    HTTP {
        /// HTTP Status code.
        status: Status,
        /// Text message giving more context to the reason this error was raised.
        info: Cow<'static, str>,
    },
}

impl MyError {
    /// Return a new instance that is an HTTP variant w/ the designated Status
    /// code and the original error string.
    pub fn with_status(self, s: Status) -> Self {
        match self {
            MyError::HTTP { status, info } => {
                info!("Replace status {} w/ {}", status, s);
                MyError::HTTP { status: s, info }
            }
            _ => MyError::HTTP {
                status: s,
                info: self.to_string().into(),
            },
        }
    }
}

#[rocket::async_trait]
impl<'r> Responder<'r, 'static> for MyError {
    fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
        let status = match self {
            MyError::HTTP { status, .. } => status,
            _ => Status::InternalServerError,
        };
        error!("Failed: {}", &self);
        Response::build_from(
            json!({
                "status": status.code,
                "info": format!("{}", self),
            })
            .respond_to(req)?,
        )
        .status(status)
        .ok()
    }
}