gurtlib 0.1.0

Official GURT:// protocol implementation
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

use std::fmt;

pub const GURT_VERSION: &str = "1.0.0";
pub const DEFAULT_PORT: u16 = 4878;

pub const PROTOCOL_PREFIX: &str = "GURT/";

pub const HEADER_SEPARATOR: &str = "\r\n";
pub const BODY_SEPARATOR: &str = "\r\n\r\n";

pub const DEFAULT_HANDSHAKE_TIMEOUT: u64 = 5;
pub const DEFAULT_REQUEST_TIMEOUT: u64 = 30;
pub const DEFAULT_CONNECTION_TIMEOUT: u64 = 10;

pub const MAX_MESSAGE_SIZE: usize = 10 * 1024 * 1024;

pub const MAX_POOL_SIZE: usize = 10;
pub const POOL_IDLE_TIMEOUT: u64 = 300;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum GurtStatusCode {
    // Success
    Ok = 200,
    Created = 201,
    Accepted = 202,
    NoContent = 204,
    
    // Handshake
    SwitchingProtocols = 101,
    
    // Client errors
    BadRequest = 400,
    Unauthorized = 401,
    Forbidden = 403,
    NotFound = 404,
    MethodNotAllowed = 405,
    Timeout = 408,
    TooLarge = 413,
    UnsupportedMediaType = 415,
    TooManyRequests = 429,
    
    // Server errors
    InternalServerError = 500,
    NotImplemented = 501,
    BadGateway = 502,
    ServiceUnavailable = 503,
    GatewayTimeout = 504,
}

impl GurtStatusCode {
    pub fn from_u16(code: u16) -> Option<Self> {
        match code {
            200 => Some(Self::Ok),
            201 => Some(Self::Created),
            202 => Some(Self::Accepted),
            204 => Some(Self::NoContent),
            101 => Some(Self::SwitchingProtocols),
            400 => Some(Self::BadRequest),
            401 => Some(Self::Unauthorized),
            403 => Some(Self::Forbidden),
            404 => Some(Self::NotFound),
            405 => Some(Self::MethodNotAllowed),
            408 => Some(Self::Timeout),
            413 => Some(Self::TooLarge),
            415 => Some(Self::UnsupportedMediaType),
            429 => Some(Self::TooManyRequests),
            500 => Some(Self::InternalServerError),
            501 => Some(Self::NotImplemented),
            502 => Some(Self::BadGateway),
            503 => Some(Self::ServiceUnavailable),
            504 => Some(Self::GatewayTimeout),
            _ => None,
        }
    }
    
    pub fn message(&self) -> &'static str {
        match self {
            Self::Ok => "OK",
            Self::Created => "CREATED",
            Self::Accepted => "ACCEPTED",
            Self::NoContent => "NO_CONTENT",
            Self::SwitchingProtocols => "SWITCHING_PROTOCOLS",
            Self::BadRequest => "BAD_REQUEST",
            Self::Unauthorized => "UNAUTHORIZED",
            Self::Forbidden => "FORBIDDEN",
            Self::NotFound => "NOT_FOUND",
            Self::MethodNotAllowed => "METHOD_NOT_ALLOWED",
            Self::Timeout => "TIMEOUT",
            Self::TooLarge => "TOO_LARGE",
            Self::UnsupportedMediaType => "UNSUPPORTED_MEDIA_TYPE",
            Self::TooManyRequests => "TOO_MANY_REQUESTS",
            Self::InternalServerError => "INTERNAL_SERVER_ERROR",
            Self::NotImplemented => "NOT_IMPLEMENTED",
            Self::BadGateway => "BAD_GATEWAY",
            Self::ServiceUnavailable => "SERVICE_UNAVAILABLE",
            Self::GatewayTimeout => "GATEWAY_TIMEOUT",
        }
    }
    
    pub fn is_success(&self) -> bool {
        matches!(self, Self::Ok | Self::Created | Self::Accepted | Self::NoContent)
    }
    
    pub fn is_client_error(&self) -> bool {
        (*self as u16) >= 400 && (*self as u16) < 500
    }
    
    pub fn is_server_error(&self) -> bool {
        (*self as u16) >= 500
    }
}

impl From<GurtStatusCode> for u16 {
    fn from(code: GurtStatusCode) -> Self {
        code as u16
    }
}

impl fmt::Display for GurtStatusCode {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", *self as u16)
    }
}