Trait QuorumSet 

pub trait QuorumSet {
    type Id;
    type Iter: Iterator<Item = Self::Id>;

    // Required methods
    fn is_quorum<'a, I>(&self, ids: I) -> bool
       where Self::Id: 'a,
             I: Iterator<Item = &'a Self::Id> + Clone;
    fn ids(&self) -> Self::Iter;
}

Common interface for every quorum rule supported by this crate.

A quorum is a collection of nodes that a read or write operation in a distributed system has to contact. See: http://web.mit.edu/6.033/2005/wwwdocs/quorum_note.html

Every implementation must follow three rules:

• Upward-closed: adding IDs to an accepted quorum keeps it accepted. VecProgress and verify_intersection rely on this rule.
• Closed over ids(): an ID that ids() does not yield never changes the result of is_quorum(). verify_intersection enumerates only the IDs that ids() yields, so it relies on this rule.
• Duplicate-safe: an ID that appears more than once in the is_quorum() input counts once, so callers may pass an iterator with repeats.

The crate provides implementations for flat majority sets, joint quorum sets, hierarchical QuorumTree rules, and BothQuorums, which requires both a read and a write quorum. ReadOrBoth holds either a read rule alone or a BothQuorums.

Required Associated Types

type Id

Node ID type in this quorum set.

type Iter: Iterator<Item = Self::Id>

Iterator over every voter ID tracked by this quorum set.

Implementations that combine multiple sub-rules return each ID once.

Required Methods

fn is_quorum<'a, I>(&self, ids: I) -> bool

where Self::Id: 'a, I: Iterator<Item = &'a Self::Id> + Clone,

Return true if the candidate IDs satisfy this quorum rule.

Repeated IDs count once, and IDs that ids() does not yield are ignored.

fn ids(&self) -> Self::Iter

Return all voter IDs in this quorum set.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<ID> QuorumSet for BTreeSet<ID>

where ID: Ord + Clone,

Majority quorum implementation for a flat voter set.

A candidate set is accepted when it contains more than half of the IDs in this BTreeSet. An empty BTreeSet accepts no candidate set, unlike an empty joint config (Vec<BTreeSet>), which accepts every candidate set.

type Id = ID

type Iter = IntoIter<ID>

fn is_quorum<'a, I>(&self, ids: I) -> bool

where ID: 'a, I: Iterator<Item = &'a ID> + Clone,

fn ids(&self) -> Self::Iter

impl<ID> QuorumSet for Vec<BTreeSet<ID>>

where ID: Ord + Clone,

Joint quorum implementation for multiple flat voter sets.

A candidate set is accepted only when it is a majority quorum in every member config. QuorumSet::ids returns the deduplicated union of all config IDs. An empty Vec accepts every candidate set: with no member config, the requirement is vacuously satisfied.

type Id = ID

type Iter = IntoIter<ID>

fn is_quorum<'a, I>(&self, ids: I) -> bool

where ID: 'a, I: Iterator<Item = &'a ID> + Clone,

fn ids(&self) -> Self::Iter

impl<T> QuorumSet for Arc<T>

where T: QuorumSet,

type Id = <T as QuorumSet>::Id

type Iter = <T as QuorumSet>::Iter

fn is_quorum<'a, I>(&self, ids: I) -> bool

where Self::Id: 'a, I: Iterator<Item = &'a Self::Id> + Clone,

fn ids(&self) -> Self::Iter

Implementors

impl<ID> QuorumSet for QuorumTree<ID>

where ID: Ord + Clone,

Hierarchical quorum implementation for QuorumTree.

Evaluation follows the tree structure. ids() returns all leaf IDs once, even when the same node appears in more than one subtree.

type Id = ID

type Iter = IntoIter<ID>

impl<R, W> QuorumSet for BothQuorums<R, W>

where R: QuorumSet, W: QuorumSet<Id = R::Id>, R::Id: Ord,

type Id = <R as QuorumSet>::Id

type Iter = IntoIter<<R as QuorumSet>::Id>

impl<R, W> QuorumSet for ReadOrBoth<R, W>

where R: QuorumSet, W: QuorumSet<Id = R::Id>, R::Id: Ord,

type Id = <R as QuorumSet>::Id

type Iter = IntoIter<<R as QuorumSet>::Id>