keyspace 1.0.1

Keyspace partitioning and re-balancing for distributed systems
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

use super::{KeyPosition, KeyspaceNode, NodeRef};

/// A range of keys in the keyspace.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum KeyRange {
    Bounded(KeyPosition, KeyPosition),
    Unbounded(KeyPosition),
}

impl KeyRange {
    /// Create a new key range from the given start and end positions.
    pub fn new(start: KeyPosition, end: Option<KeyPosition>) -> Self {
        match end {
            Some(end) => KeyRange::Bounded(start, end),
            None => KeyRange::Unbounded(start),
        }
    }

    /// Check if the given key is in the range.
    ///
    /// Note not the key itself, but the hash of the key provides the position
    /// within keyspace.
    pub fn contains(&self, key_hash: KeyPosition) -> bool {
        match self {
            KeyRange::Bounded(start, end) => key_hash >= *start && key_hash < *end,
            KeyRange::Unbounded(start) => key_hash >= *start,
        }
    }
}

/// A half-open interval of the keyspace with responsible nodes assigned.
///
/// Range bounded inclusively below and exclusively above i.e.
/// `[start..end)`.
#[derive(Debug, PartialEq, Eq)]
pub struct Interval<N: KeyspaceNode> {
    key_range: KeyRange,
    nodes: Vec<NodeRef<N>>,
}

impl<N: KeyspaceNode> Clone for Interval<N> {
    fn clone(&self) -> Self {
        Self {
            key_range: self.key_range,
            nodes: self.nodes.clone(),
        }
    }
}

impl<N: KeyspaceNode> Interval<N> {
    /// Creates a new interval with the given key range and nodes.
    pub(crate) fn new<I: IntoIterator<Item = NodeRef<N>>>(key_range: KeyRange, nodes: I) -> Self {
        let nodes = nodes.into_iter().collect::<Vec<_>>();
        Self { key_range, nodes }
    }

    /// Returns the key range of the interval.
    pub fn key_range(&self) -> &KeyRange {
        &self.key_range
    }

    /// Returns the nodes responsible for the interval.
    pub fn nodes(&self) -> &Vec<NodeRef<N>> {
        &self.nodes
    }
}