unwalk 0.2.0-beta1

Walk directory recursively to un-gzip files
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

//! # unwalk
//!
//! Perform action on matching files/dirs during recursive walking of given
//! directory. The default action is to perform un-gzip, useful for unarchiving
//! all `.gz` files when copying files over from AWS S3 / HDFS services, which
//! also happens to be the original use case of this CLI application.

#![cfg_attr(feature = "cargo-clippy", deny(clippy))]
#![deny(missing_debug_implementations, missing_docs, warnings)]

// TODO: this is required is action type is implemented
// #[macro_use]
extern crate clap;
extern crate failure;
#[macro_use]
extern crate serde_derive;
extern crate structopt;
#[macro_use]
extern crate structopt_derive;
extern crate toml;
extern crate unwalk_base;
extern crate unwalk_gz;
extern crate walkdir;

mod arg;
#[macro_use]
mod verbose;

use arg::Config;
use failure::Fail;
use std::ffi::OsStr;
use std::fs::remove_file;
use std::process;
use structopt::StructOpt;
use unwalk_base::Action;
use unwalk_base::error::{ErrorKind, Result};
use unwalk_gz::GzAction;
use walkdir::WalkDir;

fn run(config: &Config) -> Result<()> {
    if !config.path.exists() {
        Err(ErrorKind::DirectoryNotFound)?;
    }

    let entries = WalkDir::new(&config.path)
        .into_iter()
        .inspect(|e| {
            if let Err(ref e) = *e {
                ve1!(config.verbose, "{}", e);
            }
        })
        .filter_map(|e| e.ok())
        .filter(|e| !e.file_type().is_dir());

    for entry in entries {
        let loop_fn = || -> Result<()> {
            let entry_path = entry.path();

            if entry_path.extension() == Some(OsStr::new("gz")) {
                v2!(config.verbose, "Processing {:?}", entry_path);
                GzAction::execute(entry_path)?;
                v3!(config.verbose, "Processed {:?}", entry_path);

                if config.delete {
                    remove_file(entry_path)?;
                    v1!(config.verbose, "Removed {:?}", entry_path);
                }
            } else {
                v2!(
                    config.verbose,
                    "Ignored {:?}, extension is not '.gz'",
                    entry_path
                );
            }

            Ok(())
        };

        let loop_res = loop_fn();

        if let Err(e) = loop_res {
            eprintln!("{}", e);
        }
    }

    Ok(())
}

fn main() {
    let config = Config::from_args();

    match run(&config) {
        Ok(_) => v1!(config.verbose, "Unwalk complete!"),
        Err(e) => {
            eprintln!("{}", e);

            if let Some(cause) = e.cause() {
                eprintln!("Caused by: {}", cause);
            }

            if let Some(backtrace) = e.backtrace() {
                eprintln!("Backtrace: {}", backtrace);
            }

            process::exit(1);
        }
    }
}