klone 1.0.2

A backup application based in the same FS that will only back the file that you changed
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

use crate::config::exclusions::is_excluded;
use crate::error::{Error, ErrorKind};
use crate::output::cli;
use core::panic;
use std::fs::DirEntry;
use std::path::PathBuf;
use std::sync::mpsc::{self, Receiver, Sender};

pub fn initial_copy(origin_dir: PathBuf, mut target_dir: PathBuf) -> Result<(), Error> {
    target_dir.push(origin_dir.iter().next_back().unwrap());
    let (tx, rx): (Sender<String>, Receiver<String>) = mpsc::channel();
    let _wrap = super::wrapper::Wrapper;
    cli(rx)?;
    start_initial_copy(origin_dir, target_dir, tx).unwrap();
    Ok(())
}
fn start_initial_copy(
    origin_dir: PathBuf,
    target_dir: PathBuf,
    tx: Sender<String>,
) -> Result<(), Error> {
    for child in std::fs::read_dir(origin_dir).map_err(|_| Error {
        kind: ErrorKind::FSError,
    })? {
        copy_operations(
            child.map_err(|_| Error {
                kind: ErrorKind::IOError,
            })?,
            target_dir.clone(),
            tx.clone(),
        )?;
    }
    Ok(())
}
fn copy_operations(
    origin_dir: DirEntry,
    target_dir: PathBuf,
    tx: Sender<String>,
) -> Result<(), Error> {
    let path_target_dir = target_dir.clone();
    let target_dir = path_target_dir.join(origin_dir.file_name());
    if is_excluded(origin_dir.path().display().to_string().as_str())? {
        return Ok(());
    }
    if origin_dir.path().is_symlink() {
        return Ok(());
    }
    tx.send(origin_dir.path().display().to_string())
        .map_err(|_| Error {
            kind: ErrorKind::IOError,
        })?;
    if origin_dir.path().is_dir() {
        dbg!(origin_dir.path().display());
        match std::fs::create_dir_all(&target_dir) {
            Ok(()) => (),
            Err(err) => match err.kind() {
                std::io::ErrorKind::PermissionDenied => {
                    return Err(Error {
                        kind: ErrorKind::PermissionDenied,
                    })
                }
                _ => (),
            },
        }
        return start_initial_copy(origin_dir.path(), target_dir, tx);
    }
    match fs_extra::file::copy(
        origin_dir.path(),
        target_dir,
        &fs_extra::file::CopyOptions {
            overwrite: true,
            ..Default::default()
        },
    ) {
        Ok(_) => (),
        Err(error) => match error.kind {
            fs_extra::error::ErrorKind::NotFound => (),
            _ => panic!("{:?}", error),
        },
    }
    Ok(())
}