drill-press 0.1.2

A cross platform library for listing and manipulating holes in sparse files.
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
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

use super::*;

use std::io::{Seek, SeekFrom, Write};
use tempfile::NamedTempFile;

use quickcheck::{Arbitrary, Gen};

const MAX_SPLITS: usize = 50;

// minum hole size varies by file system
#[cfg(unix)]
const BLOCK_SIZE: u64 = 4 * 1024;
#[cfg(windows)]
const BLOCK_SIZE: u64 = 64 * 1024;

#[derive(Clone, Debug)]
pub struct SparseDescription {
    start_type: SegmentType,
    split_points: Vec<u8>,
}

impl SparseDescription {
    pub fn from_parts(start_type: SegmentType, mut split_points: Vec<u8>) -> Self {
        split_points.retain(|x| *x != 0);
        split_points.truncate(MAX_SPLITS);
        split_points.sort_unstable();
        split_points.dedup();

        SparseDescription {
            start_type,
            split_points,
        }
    }

    pub fn segments(&self) -> Vec<Segment> {
        let mut segment_type = self.start_type;

        let mut prev = 0;

        let mut segments = Vec::with_capacity(self.split_points.len() + 1);

        for point in &self.split_points {
            let point = *point as u64 * BLOCK_SIZE;

            segments.push(Segment {
                segment_type,
                range: prev..point,
            });
            prev = point;
            segment_type = segment_type.opposite();
        }

        segments
    }

    pub fn one_segment(start_type: SegmentType, end: u64) -> Self {
        SparseDescription::from_parts(start_type, vec![(end / BLOCK_SIZE) as u8])
    }

    pub fn to_file(&self) -> NamedTempFile {
        let mut temp = NamedTempFile::new().expect("Unable to create tempfile");

        // Special handling to enable sparsity on windows
        #[cfg(windows)]
        {
            use std::process::Command;
            Command::new("fsutil")
                .arg("sparse")
                .arg("setflag")
                .arg(temp.path())
                .output()
                .expect("Unable to set the sparse flag on the tempfile");
        }

        let file = temp.as_file_mut();
        // Iterate through the SparseDescription
        for segment in self.segments().data() {
            file.seek(SeekFrom::Start(segment.start))
                .expect("Unable to seek in file");
            let length = segment.end - segment.start;
            let buffer = vec![1_u8; length as usize];
            file.write_all(&buffer[..])
                .expect("Unable to write bytes to file");
        }

        let last = self.split_points.last().copied().unwrap_or_default();
        temp.as_file_mut()
            .set_len(last as u64 * BLOCK_SIZE)
            .expect("Unable to set length of file");
        temp
    }
}

impl Arbitrary for SparseDescription {
    fn arbitrary(g: &mut Gen) -> Self {
        // Generate some random points in the file to be boundarires between segments
        SparseDescription::from_parts(SegmentType::arbitrary(g), Vec::arbitrary(g))
    }

    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
        let start_type = self.start_type;
        Box::new(
            self.split_points
                .shrink()
                .map(move |split_points| SparseDescription::from_parts(start_type, split_points)),
        )
    }
}

impl Arbitrary for SegmentType {
    fn arbitrary(g: &mut Gen) -> Self {
        if bool::arbitrary(g) {
            SegmentType::Hole
        } else {
            SegmentType::Data
        }
    }
}