coyote 0.1.1

Embeddable ACME server with programmable challenges and storage
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

use deadpool_postgres::PoolError;
use thiserror::Error;

/// ConnectionError is for database connection issues
#[derive(Debug, Error)]
pub enum ConnectionError {
    #[error("Unspecified connection error: {0}")]
    Generic(String),
    #[error("Database error: {0}")]
    DB(tokio_postgres::Error),
    #[error("Connection pool error: {0}")]
    Pool(PoolError),
    #[error("Migration run error: {0}")]
    Migrations(MigrationError),
}

impl From<tokio_postgres::Error> for ConnectionError {
    fn from(tp: tokio_postgres::Error) -> Self {
        Self::DB(tp)
    }
}

impl From<MigrationError> for ConnectionError {
    fn from(me: MigrationError) -> Self {
        Self::Migrations(me)
    }
}

impl From<PoolError> for ConnectionError {
    fn from(pe: PoolError) -> Self {
        Self::Pool(pe)
    }
}

/// SaveError is for any error involving a persistence operation.
#[derive(Debug, Error)]
pub enum SaveError {
    #[error("error while saving: {0}")]
    Generic(String),
    #[error("database error while saving: {0}")]
    DBError(tokio_postgres::Error),
    #[error("error while encoding json: {0}")]
    JSONCodecError(String),
    #[error("error while refreshing results after write: {0}")]
    ReloadError(LoadError),
    #[error("db connection error: {0}")]
    ConnectionError(ConnectionError),
}

impl From<ConnectionError> for SaveError {
    fn from(e: ConnectionError) -> Self {
        Self::ConnectionError(e)
    }
}

impl From<LoadError> for SaveError {
    fn from(e: LoadError) -> Self {
        return Self::JSONCodecError(e.to_string());
    }
}

impl From<serde_json::Error> for SaveError {
    fn from(e: serde_json::Error) -> Self {
        return Self::JSONCodecError(e.to_string());
    }
}

impl From<tokio_postgres::Error> for SaveError {
    fn from(tp: tokio_postgres::Error) -> Self {
        Self::DBError(tp)
    }
}

/// LoadError is for any error involving a fetch operation.
#[derive(Debug, Error)]
pub enum LoadError {
    #[error("error while loading: {0}")]
    Generic(String),
    #[error("database error while loading: {0}")]
    DBError(tokio_postgres::Error),
    #[error("error while decoding json: {0}")]
    JSONCodecError(String),
    #[error("error while connecting to database: {0}")]
    ConnectionError(ConnectionError),
    #[error("invalid token in enum translation")]
    InvalidEnum,
    #[error("key not found")]
    NotFound,
}

impl From<ConnectionError> for LoadError {
    fn from(ce: ConnectionError) -> Self {
        Self::ConnectionError(ce)
    }
}

impl From<serde_json::Error> for LoadError {
    fn from(e: serde_json::Error) -> Self {
        return Self::JSONCodecError(e.to_string());
    }
}

impl From<tokio_postgres::Error> for LoadError {
    fn from(e: tokio_postgres::Error) -> Self {
        Self::DBError(e)
    }
}

/// MigrationError is for errors involving updating the database schema.
#[derive(Debug, Error)]
pub enum MigrationError {
    #[error("Unspecified migration error: {0}")]
    Generic(String),
    #[error("Database error: {0}")]
    DBError(tokio_postgres::Error),
    #[error("migration error: {0}")]
    Error(refinery::Error),
}

impl From<tokio_postgres::Error> for MigrationError {
    fn from(e: tokio_postgres::Error) -> Self {
        Self::DBError(e)
    }
}

impl From<refinery::Error> for MigrationError {
    fn from(e: refinery::Error) -> Self {
        Self::Error(e)
    }
}

impl From<ConnectionError> for MigrationError {
    fn from(e: ConnectionError) -> Self {
        Self::Generic(e.to_string())
    }
}