quoracle 2.0.0

Construct, analyze, and optimize read-write quorum systems: load, capacity, latency, network cost, and fault tolerance
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

//! Error types for the Quoracle library

use thiserror::Error;

/// Result type alias for Quoracle operations
pub type Result<T> = std::result::Result<T, Error>;

/// Errors that can occur when working with quorum systems
#[derive(Error, Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum Error {
    /// Some write quorum does not intersect some read quorum.
    #[error("not all read quorums intersect all write quorums")]
    NonOverlappingQuorums,

    /// The constraints are infeasible, or there are no f-resilient
    /// quorums for the requested `f`.
    #[error("no strategy found satisfying the constraints")]
    NoStrategyFound,

    /// Search found no quorum system satisfying the requirements.
    #[error("no quorum system found satisfying the requirements")]
    NoQuorumSystemFound,

    /// Invalid read/write distribution.
    #[error("invalid distribution: {0}")]
    InvalidDistribution(String),

    /// The LP solver failed for a reason other than infeasibility.
    #[error("LP solver error: {0}")]
    LpError(String),

    /// Invalid arguments to a quorum system or strategy operation.
    #[error("invalid quorum system: {0}")]
    InvalidQuorumSystem(String),

    /// Invalid expression or geometry arguments.
    #[error("invalid expression: {0}")]
    InvalidExpression(String),
}

impl From<good_lp::ResolutionError> for Error {
    fn from(e: good_lp::ResolutionError) -> Self {
        match e {
            good_lp::ResolutionError::Infeasible => Self::NoStrategyFound,
            other => Self::LpError(other.to_string()),
        }
    }
}

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

    #[test]
    fn resolution_error_mapping() {
        assert_eq!(
            Error::from(good_lp::ResolutionError::Infeasible),
            Error::NoStrategyFound
        );
        assert!(matches!(
            Error::from(good_lp::ResolutionError::Unbounded),
            Error::LpError(_)
        ));
        assert!(Error::NonOverlappingQuorums.to_string().contains("intersect"));
    }
}