qbsdiff 1.4.4

Fast and memory saving bsdiff 4.x compatible delta compressor and patcher.
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

#![forbid(unsafe_code)]
use std::io::prelude::*;
use std::{fs, io, process};

use clap::{ArgAction, Parser};
use qbsdiff::{Bsdiff, ParallelScheme};

#[derive(Parser, Debug)]
#[clap(
name = "qbsdiff",
version = "1.4.4",
about = "fast and memory saving bsdiff 4.x compatible delta compressor",
long_about = None,
)]
struct BsdiffArgs {
    /// source file
    #[clap(value_name = "SOURCE")]
    source_path: String,

    /// target file
    #[clap(value_name = "TARGET")]
    target_path: String,

    /// patch file
    #[clap(value_name = "PATCH")]
    patch_path: String,

    /// disable parallel searching
    #[clap(short = 'P', default_value_t = true, action = ArgAction::SetFalse)]
    parallel: bool,

    /// parallel chunk size
    #[clap(short = 'c', value_name = "CHUNK")]
    chunk_size: Option<usize>,

    /// buffer size
    #[clap(short = 'b', value_name = "BUFFER")]
    buffer_size: Option<usize>,

    /// bzip2 compression level (1-9)
    #[clap(short = 'z', value_name = "LEVEL")]
    compress_level: Option<u32>,

    /// skip small matches
    #[clap(short = 's', value_name = "SMALL")]
    small_match: Option<usize>,
}

fn main() {
    let args = BsdiffArgs::parse();
    if let Err(e) = execute(args) {
        eprintln!("error: {}", e);
        process::exit(1);
    }
}

fn execute(args: BsdiffArgs) -> io::Result<()> {
    // validate command line arguments
    if !matches!(args.compress_level, Some(0..=9) | None) {
        return Err(io::Error::new(
            io::ErrorKind::Other,
            "compression level must be in range 0-9",
        ));
    }

    // setup input/output
    if args.source_path == "-" && args.target_path == "-" {
        return Err(io::Error::new(
            io::ErrorKind::Other,
            "source and target are both from stdin",
        ));
    }
    let source = input_bytes(&args.source_path)?;
    let target = input_bytes(&args.target_path)?;
    let patch = output_writer(&args.patch_path)?;

    // setup delta compressor
    let mut bsdiff = Bsdiff::new(source.as_slice(), target.as_slice());
    if args.parallel {
        bsdiff = bsdiff.parallel_scheme(ParallelScheme::Auto);
    } else if let Some(mut chunk_size) = args.chunk_size {
        chunk_size = Ord::max(chunk_size, 256 * 1024);
        bsdiff = bsdiff.parallel_scheme(ParallelScheme::ChunkSize(chunk_size));
    } else {
        bsdiff = bsdiff.parallel_scheme(ParallelScheme::Never);
    }
    if let Some(compress_level) = args.compress_level {
        bsdiff = bsdiff.compression_level(compress_level);
    }
    if let Some(buffer_size) = args.buffer_size {
        bsdiff = bsdiff.buffer_size(buffer_size);
    }
    if let Some(small_match) = args.small_match {
        bsdiff = bsdiff.small_match(small_match);
    }

    // execute delta compressor
    bsdiff.compare(patch)?;
    Ok(())
}

fn input_bytes(path: &str) -> io::Result<Vec<u8>> {
    let mut data;
    if path == "-" {
        data = Vec::new();
        io::stdin().read_to_end(&mut data)?;
    } else {
        data = fs::read(path)?;
    }
    Ok(data)
}

fn output_writer(path: &str) -> io::Result<Box<dyn Write>> {
    if path == "-" {
        Ok(Box::new(io::stdout()))
    } else {
        Ok(Box::new(fs::File::create(path)?))
    }
}