rstmdb-server 0.2.0

TCP server for rstmdb - connection handling, command dispatch, sessions
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

//! Server error types.

use rstmdb_protocol::ErrorCode;
use thiserror::Error;

/// Server errors.
#[derive(Debug, Error)]
pub enum ServerError {
    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),

    #[error("protocol error: {0}")]
    Protocol(#[from] rstmdb_protocol::ProtocolError),

    #[error("core error: {0}")]
    Core(#[from] rstmdb_core::CoreError),

    #[error("storage error: {0}")]
    Storage(#[from] rstmdb_storage::StorageError),

    #[error("WAL error: {0}")]
    Wal(#[from] rstmdb_wal::WalError),

    #[error("JSON error: {0}")]
    Json(#[from] serde_json::Error),

    #[error("session not authenticated")]
    NotAuthenticated,

    #[error("authentication failed: {0}")]
    AuthFailed(String),

    #[error("invalid request: {0}")]
    InvalidRequest(String),

    #[error("machine version limit exceeded: {0}")]
    MachineVersionLimitExceeded(String),

    #[error("server shutting down")]
    ShuttingDown,

    #[error("TLS configuration error: {0}")]
    TlsConfig(String),

    #[error("TLS handshake failed: {0}")]
    TlsHandshake(String),
}

impl ServerError {
    /// Converts to protocol error code.
    pub fn error_code(&self) -> ErrorCode {
        match self {
            ServerError::Io(_) => ErrorCode::InternalError,
            ServerError::Protocol(_) => ErrorCode::BadRequest,
            ServerError::Core(e) => match e.error_code() {
                "MACHINE_NOT_FOUND" => ErrorCode::MachineNotFound,
                "MACHINE_VERSION_EXISTS" => ErrorCode::MachineVersionExists,
                "INSTANCE_NOT_FOUND" => ErrorCode::InstanceNotFound,
                "INSTANCE_EXISTS" => ErrorCode::InstanceExists,
                "INVALID_TRANSITION" => ErrorCode::InvalidTransition,
                "GUARD_FAILED" => ErrorCode::GuardFailed,
                "CONFLICT" => ErrorCode::Conflict,
                "WAL_IO_ERROR" => ErrorCode::WalIoError,
                _ => ErrorCode::InternalError,
            },
            ServerError::Storage(_) => ErrorCode::InternalError,
            ServerError::Wal(_) => ErrorCode::WalIoError,
            ServerError::Json(_) => ErrorCode::BadRequest,
            ServerError::NotAuthenticated => ErrorCode::Unauthorized,
            ServerError::AuthFailed(_) => ErrorCode::AuthFailed,
            ServerError::InvalidRequest(_) => ErrorCode::BadRequest,
            ServerError::MachineVersionLimitExceeded(_) => ErrorCode::MachineVersionLimitExceeded,
            ServerError::ShuttingDown => ErrorCode::InternalError,
            ServerError::TlsConfig(_) => ErrorCode::InternalError,
            ServerError::TlsHandshake(_) => ErrorCode::InternalError,
        }
    }

    /// Returns whether this error is retryable.
    pub fn is_retryable(&self) -> bool {
        matches!(
            self.error_code(),
            ErrorCode::WalIoError | ErrorCode::RateLimited | ErrorCode::InternalError
        )
    }
}