binsync 0.0.4

A library for syncing binary files between two locations.
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use std::{
    path::Path,
    process,
    sync::{
        atomic::{AtomicBool, Ordering},
        Arc,
    },
    thread,
    time::{Duration, Instant},
};

use binsync::{generate_manifest, CachingChunkProvider, Syncer};
use clap::{Parser, Subcommand};
use indicatif::{ProgressBar, ProgressStyle};

#[derive(Parser)]
#[clap(author, version, about, long_about = None)]
#[clap(propagate_version = true)]
struct Cli {
    #[clap(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    Sync { from: String, to: String },
    Generate { from: String },
}

/// A command-line interface for the crate. Allows you to run various commands
/// without having to compile your own rust program and inspect the outputs.
fn main() {
    let cli = Cli::parse();

    match &cli.command {
        Commands::Sync { from, to } => {
            let now = Instant::now();

            println!("[1/2] Generating manifest from {}", from);

            let stop_spinner = Arc::new(AtomicBool::new(false));
            let handle = thread::spawn({
                let stop = stop_spinner.clone();
                move || {
                    let spinner = ProgressBar::new(10000);
                    spinner.set_style(
                        ProgressStyle::default_spinner()
                            .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈ ")
                            .template(
                                "{prefix:.bold.dim} [{elapsed_precise}] {spinner} {wide_msg}",
                            ),
                    );
                    spinner.set_prefix("[1/2]");

                    while !stop.load(Ordering::SeqCst) {
                        spinner.inc(1);
                        thread::sleep(Duration::from_millis(100));
                    }

                    spinner.finish_with_message("Manifest generated.");
                }
            });

            let manifest = match generate_manifest(&from) {
                Ok(manifest) => manifest,
                Err(err) => {
                    eprintln!("Failed to generate manifest: {}", err);
                    process::exit(1);
                }
            };

            stop_spinner.store(true, Ordering::SeqCst);
            handle.join().unwrap();

            let from_path = Path::new(&from);
            let provider = CachingChunkProvider::new(from_path);

            let to_path = Path::new(&to);

            println!("[2/2] Syncing files to {}", to);

            let bar = ProgressBar::new(100);
            bar.set_style(
                ProgressStyle::default_bar()
                    .template(
                        "{prefix:.bold.dim} [{elapsed_precise}] [{wide_bar:.cyan/blue}] ({eta})",
                    )
                    .progress_chars("#>-"),
            );
            bar.set_prefix("[2/2]");

            let mut syncer = Syncer::new(to_path, provider, manifest);
            syncer.on_progress(|amt| bar.set_position(amt.into()));
            if let Err(err) = syncer.sync() {
                eprintln!("Error running sync: {}", err);
                process::exit(1);
            }

            bar.finish();

            println!("Sync completed in {}s", now.elapsed().as_secs());
        }
        Commands::Generate { from } => {
            let now = Instant::now();

            println!("[1/1] Generating manifest from {}", from);

            let stop_spinner = Arc::new(AtomicBool::new(false));
            let handle = thread::spawn({
                let stop = stop_spinner.clone();
                move || {
                    let spinner = ProgressBar::new(10000);
                    spinner.set_style(
                        ProgressStyle::default_spinner()
                            .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈ ")
                            .template(
                                "{prefix:.bold.dim} [{elapsed_precise}] {spinner} {wide_msg}",
                            ),
                    );
                    spinner.set_prefix("[1/2]");

                    while !stop.load(Ordering::SeqCst) {
                        spinner.inc(1);
                        thread::sleep(Duration::from_millis(100));
                    }

                    spinner.finish_with_message("Manifest generated.");
                }
            });

            match generate_manifest(&from) {
                Ok(manifest) => println!("Generated manifest: {:?}", manifest),
                Err(msg) => {
                    eprintln!("Error running sync: {}", msg);
                    process::exit(1);
                }
            }

            stop_spinner.store(true, Ordering::SeqCst);
            handle.join().unwrap();

            println!("Manifest generated in {}s", now.elapsed().as_secs());
        }
    }
}