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

ecpool
======

[![Crates.io: ecpool](https://img.shields.io/crates/v/ecpool.svg)](https://crates.io/crates/ecpool)
[![Documentation](https://docs.rs/ecpool/badge.svg)](https://docs.rs/ecpool)
[![Build Status](https://travis-ci.org/frugalos/ecpool.svg?branch=master)](https://travis-ci.org/frugalos/ecpool)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

This crate provides thread pool ([`ErasureCoderPool`]) for managing executions of erasure coding.

[Documentation](https://docs.rs/ecpool)

`ecpool` also provides [`ErasureCode`] trait defines erasure coding interface
and of which implemtations can be executed via [`ErasureCoderPool`].

There are some built-in implementations of the trait:
- [`LibErasureCoder`]:
  - This implementation uses [`liberasurecode`] crate that is a wrapper for [openstack/liberasurecode] library.
  - It is highly optimized and stable but only available in Unix environments.
- [`ReplicaCoder`]:
  - This implementation simply replicates the input data.
  - It is provided for example and testing purposes only and not intended to use in production.


Build Prerequisites
-------------------

It is required to install [openstack/liberasurecode] and its dependencies by executing
the following commands before building this crate:

```console
$ git clone https://github.com/frugalos/liberasurecode
$ cd liberasurecode && sudo ./install_deps.sh
```

Examples
--------

Basic usage:
```rust
use ecpool::replica::ReplicaCoder;
use ecpool::{ErrorKind, ErasureCoderPool};
use std::num::NonZeroUsize;
use std::result::Result;
use trackable::error::{Failure, Failed};

// Creates a pool
let data_fragments = NonZeroUsize::new(4).ok_or_else(|| Failure::from(Failed))?;
let parity_fragments = NonZeroUsize::new(2).ok_or_else(|| Failure::from(Failed))?;
let coder = ErasureCoderPool::new(ReplicaCoder::new(data_fragments, parity_fragments));

// Encodes
let data = vec![0, 1, 2, 3];
let encoded = fibers_global::execute(coder.encode(data.clone()))?;

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

[`ErasureCoderPool`]: https://docs.rs/ecpool/0.1/struct.ErasureCoderPool.html
[`ErasureCode`]: https://docs.rs/ecpool/0.1/trait.ErasureCode.html
[`liberasurecode`]: https://github.com/frugalos/liberasurecode
[openstack/liberasurecode]: https://github.com/openstack/liberasurecode
[`LibErasureCoder`]: https://docs.rs/ecpool/0.1/liberasurecode/struct.LibErasureCoder.html
[`ReplicaCoder`]: https://docs.rs/ecpool/0.1/replica/struct.ReplicaCoder.html