ciruela 0.6.12

A peer-to-peer synchronization software for servers in datacenters.
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 std::fmt;
use std::io::BufRead;


use dir_signature::v1::{Entry};
use dir_signature::HashType;
use dir_signature::v1::{Parser, ParseError as IndexError};

use index::{ImageId};


pub struct IndexData {
    pub id: ImageId,
    pub hash_type: HashType,
    pub block_size: u64,
    pub entries: Vec<Entry>,
    pub bytes_total: u64,
    pub blocks_total: u64,
}

impl fmt::Debug for IndexData {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("Index")
        .field("id", &self.id)
        .field("bytes", &self.bytes_total)
        .field("blocks", &self.blocks_total)
        .finish()
    }
}

fn bytes(e: &Entry) -> u64 {
    match *e {
        Entry::File { size, ..} => size,
        _ => 0,
    }
}

fn blocks(e: &Entry, block_size: u64) -> u64 {
    match *e {
        Entry::File { size, ..} => (size + block_size-1) / block_size,
        _ => 0,
    }
}

impl IndexData {
    pub fn parse<F: BufRead>(id: &ImageId, f: F)
        -> Result<IndexData, IndexError>
    {
        // TODO(tailhook) verify index
        let mut parser = Parser::new(f)?;
        let header = parser.get_header();
        let items = parser.iter().collect::<Result<Vec<_>, _>>()?;
        Ok(IndexData {
            id: id.clone(),
            hash_type: header.get_hash_type(),
            block_size: header.get_block_size(),
            bytes_total: items.iter()
                .map(bytes)
                .sum(),
            blocks_total: items.iter()
                .map(|x| blocks(x, header.get_block_size()))
                .sum(),
            entries: items,
        })
    }
}