dynalock 0.1.0

A lease based distributed locking algorithm with support for DynamoDB
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

//   Copyright 2018 Chorus One, Inc.
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

//! Dynalock error type and kinds.

use core::fmt;
use std::error::Error;
use std::string::{String, ToString};

/// An enum of errors to represent the possible kinds of `DynaError`.
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub enum DynaErrorKind {
    /// Unhandled error from another crate or the standard library.
    UnhandledError,
    /// Provider error from another crate.
    ProviderError,
    /// Lock has been acquired by another processor.
    LockAlreadyAcquired,
}

impl DynaErrorKind {
    /// Return a string description of the error.
    pub fn as_str(&self) -> &str {
        match *self {
            DynaErrorKind::UnhandledError => "unhandled internal error",
            DynaErrorKind::ProviderError => "provider error",
            DynaErrorKind::LockAlreadyAcquired => "lock has been acquired by another processor",
        }
    }
}

impl fmt::Display for DynaErrorKind {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

/// The DynaError type is the only error type that can be returned from this
/// crate's API.
#[derive(Debug, PartialEq)]
pub struct DynaError {
    kind: DynaErrorKind,
    description: Option<String>,
}

impl DynaError {
    /// Create a new error object with an optional error message.
    pub fn new(kind: DynaErrorKind, description: Option<&str>) -> Self {
        DynaError {
            kind: kind,
            description: description.map(|desc| desc.to_string()),
        }
    }

    /// Get DynaErrorKind for this error.
    pub fn kind(&self) -> DynaErrorKind {
        self.kind
    }
}

impl fmt::Display for DynaError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self.description {
            Some(ref desc) => write!(f, "{}: {}", self.description(), desc),
            None => write!(f, "{}", self.description()),
        }
    }
}

impl Error for DynaError {
    fn description(&self) -> &str {
        self.kind.as_str()
    }
}

impl From<DynaErrorKind> for DynaError {
    fn from(kind: DynaErrorKind) -> DynaError {
        DynaError {
            kind: kind,
            description: None,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_dynaerrorkind_as_str_success() {
        assert_eq!(
            DynaErrorKind::UnhandledError.as_str(),
            "unhandled internal error"
        );
        assert_eq!(DynaErrorKind::ProviderError.as_str(), "provider error");
        assert_eq!(
            DynaErrorKind::LockAlreadyAcquired.as_str(),
            "lock has been acquired by another processor"
        );
    }

    #[test]
    fn test_dynaerror_new_success() {
        let err = DynaError::new(DynaErrorKind::ProviderError, None);

        assert_eq!(err.kind(), DynaErrorKind::ProviderError);
        assert_eq!(err.description, None);
        assert_eq!(err.description(), "provider error");
    }

    #[test]
    fn test_from_dynaerrorkind_to_dynaerror_success() {
        let err = DynaError::new(DynaErrorKind::UnhandledError, None);

        assert_eq!(err, DynaError::from(DynaErrorKind::UnhandledError));
    }
}