ecpool 1.0.2

Thread pool for managing executions of erasure coding
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

//! An [`ErasureCode`] implementation that simply replicates the input data.
//!
//! [`ErasureCode`]: ../trait.ErasureCode.html
use std::num::NonZeroUsize;

use {BuildCoder, ErasureCode, ErrorKind, Fragment, FragmentBuf, Result};

/// An [`ErasureCode`] implementation that simply replicates the input data.
///
/// Note that this is provided for example and testing purposes only and not intended to use in production.
///
/// [`ErasureCode`]: ../trait.ErasureCode.html
///
/// # Examples
///
/// ```
/// use ecpool::{ErasureCode, ErrorKind};
/// use ecpool::replica::ReplicaCoder;
/// use std::num::NonZeroUsize;
///
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// let data_fragments = NonZeroUsize::new(4).ok_or("invalid input")?;
/// let parity_fragments = NonZeroUsize::new(2).ok_or("invalid input")?;
/// let mut coder = ReplicaCoder::new(data_fragments, parity_fragments);
///
/// // Encodes
/// let data = vec![0, 1, 2, 3];
/// let encoded = coder.encode(&data)?;
/// let encoded = encoded.iter().map(|f| f.as_ref()).collect::<Vec<_>>();
///
/// // Decodes
/// assert_eq!(Some(&data), coder.decode(&encoded[0..]).as_ref().ok());
/// assert_eq!(Some(&data), coder.decode(&encoded[1..]).as_ref().ok());
/// assert_eq!(Some(&data), coder.decode(&encoded[2..]).as_ref().ok());
/// assert_eq!(Err(ErrorKind::InvalidInput), coder.decode(&encoded[3..]).map_err(|e| *e.kind()));
/// # Ok(())
/// # }
/// ```
#[derive(Debug, Clone)]
pub struct ReplicaCoder {
    data_fragments: NonZeroUsize,
    parity_fragments: NonZeroUsize,
}
impl ReplicaCoder {
    /// Makes a new `ReplicaCoder` instance.
    pub fn new(data_fragments: NonZeroUsize, parity_fragments: NonZeroUsize) -> Self {
        ReplicaCoder {
            data_fragments,
            parity_fragments,
        }
    }
}
impl ErasureCode for ReplicaCoder {
    fn data_fragments(&self) -> NonZeroUsize {
        self.data_fragments
    }

    fn parity_fragments(&self) -> NonZeroUsize {
        self.parity_fragments
    }

    fn encode(&mut self, data: &[u8]) -> Result<Vec<FragmentBuf>> {
        let mut fragments = Vec::with_capacity(self.fragments().get());
        fragments.push(Vec::from(data));
        for _ in 1..self.data_fragments.get() {
            fragments.push(Vec::new());
        }
        for _ in 0..self.parity_fragments.get() {
            fragments.push(Vec::from(data));
        }
        Ok(fragments)
    }

    fn decode(&mut self, fragments: &[&Fragment]) -> Result<Vec<u8>> {
        track_assert!(
            fragments.len() >= self.data_fragments.get(),
            ErrorKind::InvalidInput,
            "fragments={}, data_fragments={}",
            fragments.len(),
            self.data_fragments
        );
        let data = track_assert_some!(
            fragments.iter().find(|f| !f.is_empty()),
            ErrorKind::CorruptedFragments,
            "No replica fragment is found"
        );
        Ok(data.to_vec())
    }
}
impl BuildCoder for ReplicaCoder {
    type Coder = Self;

    fn build_coder(&self) -> Result<Self::Coder> {
        Ok(self.clone())
    }

    fn coder_id(&self) -> String {
        format!("replica:{}:{}", self.data_fragments, self.parity_fragments)
    }
}

#[cfg(test)]
mod tests {
    use std::num::NonZeroUsize;

    use super::*;
    use {ErasureCode, ErrorKind};

    #[test]
    fn it_works() {
        let data_fragments = NonZeroUsize::new(4).unwrap();
        let parity_fragments = NonZeroUsize::new(2).unwrap();

        let mut coder = ReplicaCoder::new(data_fragments, parity_fragments);
        let data = vec![0, 1, 2, 3];
        let encoded = coder.encode(&data).unwrap();
        let encoded = encoded.iter().map(|f| f.as_ref()).collect::<Vec<_>>();

        assert_eq!(Some(&data), coder.decode(&encoded[0..]).as_ref().ok());
        assert_eq!(Some(&data), coder.decode(&encoded[1..]).as_ref().ok());
        assert_eq!(Some(&data), coder.decode(&encoded[2..]).as_ref().ok());
        assert_eq!(
            Err(ErrorKind::InvalidInput),
            coder.decode(&encoded[3..]).map_err(|e| *e.kind())
        );
    }
}