rqlite_client 0.0.1-alpha.7

rqlite database client with optional extra convenience
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

//! Everything related to __rqlite__ database server `response` handling

use crate::Error;
pub use query::Query;

pub mod mapping;
pub mod query;

/// Result type with [`Response`] or [`Error`]
pub type Result = std::result::Result<Response, Error>;

/// [`Response`] `enum` for handling different __rqlited__ database server responses
#[derive(Debug, PartialEq)]
pub enum Response {
    /// Response of [monitor::Endpoint::Nodes](crate::monitor::response::Nodes) (feature `monitor`)
    #[cfg(feature = "monitor")]
    Node(crate::monitor::response::Nodes),
    /// Response of [monitor::Endpoint::Readyz](crate::monitor::response::Readyz) (feature `monitor`)
    #[cfg(feature = "monitor")]
    Readyz(crate::monitor::response::Readyz),
    /// Response of [query::Endpoint::Execute](crate::query::Endpoint::Execute),
    /// [query::Endpoint::Query](crate::query::Endpoint::Query),
    /// [query::Endpoint::Request](crate::query::Endpoint::Request)
    Query(Query),
    /// Response of [monitor::Endpoint::Status](crate::monitor::response::Status) (feature `monitor`)
    #[cfg(feature = "monitor")]
    Status(crate::monitor::response::Status),
}

#[cfg(feature = "ureq")]
impl TryFrom<ureq::Response> for Response {
    type Error = Error;

    fn try_from(response: ureq::Response) -> std::result::Result<Self, Self::Error> {
        let status = response.status();

        if !(200..300).contains(&status) {
            return Err(Error::HttpError(status, response.status_text().to_string()));
        }

        let mut value = None;
        let mut content = None;

        // checks
        if let Some(content_type) = response.header("Content-Type") {
            let content_length = response
                .header("Content-Length")
                .and_then(|s| s.parse::<usize>().ok());

            if content_type.starts_with("application/json") {
                value = Some(response.into_json::<crate::Value>().map_err(Error::from)?);
            } else if let Some(content_length) = content_length {
                if content_length <= 200 && content_type.starts_with("text/plain") {
                    content = response.into_string().ok();
                } else {
                    return Err("content-length too big".into());
                }
            } else {
                return Err("unsupported response".into());
            }
        } else {
            return Err("unsupported response".into());
        }

        // response type parsing - feature monitor
        #[cfg(feature = "monitor")]
        if let Some(value) = value {
            if value.get("results").is_some() {
                serde_json::from_value::<Query>(value)
                    .map(Response::Query)
                    .map_err(Error::from)
            } else if value.get("build").is_some() {
                serde_json::from_value::<crate::monitor::response::Status>(value)
                    .map(Response::Status)
                    .map_err(Error::from)
            } else if value.is_object() {
                serde_json::from_value::<crate::monitor::response::Nodes>(value)
                    .map(Response::Node)
                    .map_err(Error::from)
            } else {
                Err(Error::ResponseError(value))
            }
        } else if let Some(content) = content {
            use std::str::FromStr;
            Ok(Response::Readyz(
                crate::monitor::response::Readyz::from_str(&content)?,
            ))
        } else {
            Err("unsupported response".into())
        }

        // response type parsing - NOT feature monitor
        #[cfg(not(feature = "monitor"))]
        if let Some(value) = value {
            if value.get("results").is_some() {
                serde_json::from_value::<Query>(value)
                    .map(Response::Query)
                    .map_err(Error::from)
            } else {
                Err(Error::ResponseError(value))
            }
        } else {
            let _ = content;
            Err("unsupported response".into())
        }
    }
}

#[allow(unreachable_patterns)]
impl From<Response> for Query {
    fn from(response: Response) -> Self {
        match response {
            Response::Query(r) => r,
            _ => panic!("not matching"),
        }
    }
}

#[cfg(feature = "monitor")]
impl From<Response> for crate::monitor::response::Nodes {
    fn from(response: Response) -> Self {
        match response {
            Response::Node(r) => r,
            _ => panic!("not matching"),
        }
    }
}

#[cfg(feature = "monitor")]
impl From<Response> for crate::monitor::response::Readyz {
    fn from(response: Response) -> Self {
        match response {
            Response::Readyz(r) => r,
            _ => panic!("not matching"),
        }
    }
}

#[cfg(feature = "monitor")]
impl From<Response> for crate::monitor::response::Status {
    fn from(response: Response) -> Self {
        match response {
            Response::Status(r) => r,
            _ => panic!("not matching"),
        }
    }
}