nio_axum 0.1.1

nio authentication and authorization crte for axum
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

use std::fmt::{Display, Formatter};

// use std::num::ParseIntError;
use tonic::transport::Error;
use tonic::Status;

#[derive(thiserror::Error, Debug)]
pub enum ParseErrorKind {
    //#[error("maxlen is {0}")]
    //LengthLimitExceeded(i32),
    // #[error("invalid syntax: {0}")]
    // InvalidSyntax(String),
    #[error("invalid syntax")]
    InvalidSyntaxWithInner(#[from] Box<dyn std::error::Error + Send + Sync>),
    // #[error("invalid integer")]
    // ParseInt(ParseIntError),
}

#[derive(thiserror::Error, Debug)]
#[error("'{value}' has invalid syntax for {item}")]
pub struct ParseError {
    item: String,
    value: String,
    source: ParseErrorKind,
    //hint: Option<&'static str>
}

#[derive(Debug)]
pub struct ConnectError(pub(super) Error);

impl Display for ConnectError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "connect to check service")
    }
}

impl std::error::Error for ConnectError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        Some(&self.0)
    }
}

#[derive(Debug)]
pub struct AddError(pub(super) Status);

impl Display for AddError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "add tuples grpc call")
    }
}

impl std::error::Error for AddError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        Some(&self.0)
    }
}

impl From<Status> for AddError {
    fn from(value: Status) -> Self {
        AddError(value)
    }
}

#[derive(Debug)]
pub struct ReadError(pub(super) Status);

impl Display for crate::error::ReadError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "read tuples grpc call")
    }
}

impl std::error::Error for crate::error::ReadError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        Some(&self.0)
    }
}

impl From<Status> for crate::error::ReadError {
    fn from(value: Status) -> Self {
        crate::error::ReadError(value)
    }
}