barc 2.2.2

Body Archive (BARC) file reader and writer, for HTTP dialogs
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
119
120
121
122
123
124
125
126
127
128

//! This was copied from src/barc.rs unit tests with minimal changes and only
//! serves as a rough compression performance sanity check.
#![warn(rust_2018_idioms)]

#![feature(test)]
extern crate test; // Still required, see rust-lang/rust#55133

use std::fs;
use std::path::{Path, PathBuf};

use test::Bencher;

use body_image::{BodySink, Tunables};
use barc::*;

#[bench]
fn write_read_large_plain(b: &mut Bencher) {
    b.iter(|| {
        let fname = barc_test_file("large.barc").unwrap();
        let strategy = NoCompressStrategy::default();
        write_read_large(&fname, &strategy).unwrap();
    })
}

#[bench]
fn write_read_large_gzip(b: &mut Bencher) {
    b.iter(|| {
        let fname = barc_test_file("large_gzip.barc").unwrap();
        let strategy = GzipCompressStrategy::default();
        write_read_large(&fname, &strategy).unwrap();
    })
}

#[bench]
fn write_read_large_gzip_0(b: &mut Bencher) {
    b.iter(|| {
        let fname = barc_test_file("large_gzip_0.barc").unwrap();
        let strategy = GzipCompressStrategy::default().set_compression_level(0);
        write_read_large(&fname, &strategy).unwrap();
    })
}

#[cfg(feature = "brotli")]
#[bench]
fn write_read_large_brotli(b: &mut Bencher) {
    b.iter(|| {
        let fname = barc_test_file("large_brotli.barc").unwrap();
        let strategy = BrotliCompressStrategy::default();
        write_read_large(&fname, &strategy).unwrap();
    })
}

#[cfg(feature = "brotli")]
#[bench]
fn write_read_large_brotli_0(b: &mut Bencher) {
    b.iter(|| {
        let fname = barc_test_file("large_brotli_0.barc").unwrap();
        let strategy = BrotliCompressStrategy::default()
            .set_compression_level(0);
        write_read_large(&fname, &strategy).unwrap();
    })
}

fn write_read_large(fname: &PathBuf, strategy: &dyn CompressStrategy)
    -> Result<(), Flaw>
{
    let bfile = BarcFile::new(fname);

    let mut writer = bfile.writer()?;

    let lorem_ipsum =
       "Lorem ipsum dolor sit amet, consectetur adipiscing elit, \
        sed do eiusmod tempor incididunt ut labore et dolore magna \
        aliqua. Ut enim ad minim veniam, quis nostrud exercitation \
        ullamco laboris nisi ut aliquip ex ea commodo \
        consequat. Duis aute irure dolor in reprehenderit in \
        voluptate velit esse cillum dolore eu fugiat nulla \
        pariatur. Excepteur sint occaecat cupidatat non proident, \
        sunt in culpa qui officia deserunt mollit anim id est \
        laborum. ";

    let req_reps =   500;
    let res_reps = 1_000;

    let mut req_body = BodySink::with_ram_buffers(req_reps);
    for _ in 0..req_reps {
        req_body.push(lorem_ipsum)?;
    }
    let req_body = req_body.prepare()?;

    let mut res_body = BodySink::with_ram_buffers(res_reps);
    for _ in 0..res_reps {
        res_body.push(lorem_ipsum)?;
    }
    let res_body = res_body.prepare()?;

    let mut res_headers = http::HeaderMap::default();
    res_headers.insert(http::header::CONTENT_TYPE, "text/plain".parse()?);
    let req_headers = res_headers.clone();
    let mut meta = http::HeaderMap::default();
    meta.insert(hname_meta_res_decoded(), "identity".parse()?);

    writer.write(
        &Record { req_body, req_headers, res_body, res_headers, meta,
                  ..Record::default()},
        strategy)?;

    let tune = Tunables::new();
    let mut reader = bfile.reader()?;
    let record = reader.read(&tune)?.unwrap();

    assert_eq!(record.rec_type, RecordType::Dialog);

    Ok(())
}

fn barc_test_file(name: &str) -> Result<PathBuf, Flaw> {
    let target = env!("CARGO_MANIFEST_DIR");
    let path = format!("{}/../target/testmp", target);
    let tpath = Path::new(&path);
    fs::create_dir_all(tpath)?;

    let fname = tpath.join(name);
    if fname.exists() {
        fs::remove_file(&fname)?;
    }
    Ok(fname)
}