ocypod 0.8.0

Ocypod is a Redis-backed service for orchestrating background jobs.
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

//! Defines basic error and result types used throughout the application.

use std::{error::Error, fmt};

use actix_web::{http::StatusCode, HttpResponse, ResponseError};
use deadpool_redis::PoolError;
use redis::RedisError;

/// Result type used throughout the application.
pub type OcyResult<T> = Result<T, OcyError>;

/// Error type used throughout the application.
#[derive(Debug)]
pub enum OcyError {
    /// Error occurred during interaction with Redis.
    Redis(RedisError),

    /// Error occurred while trying to get a pooled DB connection to Redis.
    RedisConnection(PoolError),

    /// Operation attempted on queue that does not exist.
    NoSuchQueue(String),

    /// Operation attempted on job that does not exist.
    NoSuchJob(u64),

    /// Could not complete request with given parameters.
    BadRequest(String),

    /// Request was not valid due to current state of some resource(s).
    Conflict(String),

    /// Internal application error, e.g. actor mailbox full.
    Internal(String),

    /// Parsing of some data structure failed. Typically used when parsing JSON.
    ParseError(String),
}

impl OcyError {
    /// Construct a new OcyError::Conflict with given message.
    pub fn conflict<S: Into<String>>(msg: S) -> Self {
        OcyError::Conflict(msg.into())
    }

    /// Construct a new OcyError::BadRequest with given message.
    pub fn bad_request<S: Into<String>>(msg: S) -> Self {
        OcyError::BadRequest(msg.into())
    }
}

impl PartialEq for OcyError {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::Redis(l0), Self::Redis(r0)) => l0 == r0,
            (Self::RedisConnection(l0), Self::RedisConnection(r0)) => l0.to_string() == r0.to_string(),
            (Self::NoSuchQueue(l0), Self::NoSuchQueue(r0)) => l0 == r0,
            (Self::NoSuchJob(l0), Self::NoSuchJob(r0)) => l0 == r0,
            (Self::BadRequest(l0), Self::BadRequest(r0)) => l0 == r0,
            (Self::Conflict(l0), Self::Conflict(r0)) => l0 == r0,
            (Self::Internal(l0), Self::Internal(r0)) => l0 == r0,
            (Self::ParseError(l0), Self::ParseError(r0)) => l0 == r0,
            _ => false,
        }
    }
}

impl From<RedisError> for OcyError {
    fn from(err: RedisError) -> Self {
        OcyError::Redis(err)
    }
}

impl From<serde_json::Error> for OcyError {
    fn from(err: serde_json::Error) -> Self {
        OcyError::ParseError(err.to_string())
    }
}

impl From<deadpool_redis::PoolError> for OcyError {
    fn from(err: deadpool_redis::PoolError) -> Self {
        OcyError::RedisConnection(err)
    }
}

impl fmt::Display for OcyError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            OcyError::Redis(err) => err.fmt(f),
            OcyError::RedisConnection(msg) => write!(f, "Failed to connect to Redis: {}", msg),
            OcyError::NoSuchQueue(queue) => write!(f, "Queue '{}' does not exist", queue),
            OcyError::NoSuchJob(job_id) => write!(f, "Job with ID {} does not exist", job_id),
            OcyError::ParseError(msg) => write!(f, "Parse error: {}", msg),
            OcyError::BadRequest(msg) | OcyError::Conflict(msg) | OcyError::Internal(msg) => {
                write!(f, "{}", msg)
            }
        }
    }
}

impl Error for OcyError {
    fn cause(&self) -> Option<&dyn Error> {
        match self {
            OcyError::Redis(err) => err.source(),
            _ => None,
        }
    }
}

impl ResponseError for OcyError {
    fn error_response(&self) -> HttpResponse {
        actix_web::HttpResponseBuilder::new(self.status_code())
            .insert_header((actix_web::http::header::CONTENT_TYPE, "text/html; charset=utf-8"))
            .body(self.to_string())
    }

    fn status_code(&self) -> StatusCode {
        match self {
            // TODO: check that this is the right response for ParseError
            OcyError::Redis(_) | OcyError::Internal(_) | OcyError::ParseError(_) => StatusCode::INTERNAL_SERVER_ERROR,
            OcyError::RedisConnection(_) => StatusCode::SERVICE_UNAVAILABLE,
            OcyError::NoSuchQueue(_) | OcyError::NoSuchJob(_) => StatusCode::NOT_FOUND,
            OcyError::BadRequest(_) => StatusCode::BAD_REQUEST,
            OcyError::Conflict(_) => StatusCode::CONFLICT,
        }
    }
}