aboutsummaryrefslogtreecommitdiffstats
path: root/src/bin/geniza-sleep.rs
blob: 168f8030a3d1a47d7f1930669404186c0db8ef56 (plain)
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

#[macro_use]
extern crate clap;

extern crate geniza;

// TODO: more careful import
use geniza::*;
use std::path::Path;

use clap::{App, SubCommand};

fn run() -> Result<()> {
 
    let matches = App::new("geniza-sleep")
        .version(env!("CARGO_PKG_VERSION"))
        .subcommand(SubCommand::with_name("info")
            .about("Reads a SLEEP file and shows some basic metadata")
            .arg_from_usage("<FILE> 'SLEEP file to read'"))
        .subcommand(SubCommand::with_name("create")
            .about("Creates an empty SLEEP file (with header)")
            .arg_from_usage("<FILE> 'SLEEP file to write (can't exist)'")
            .arg_from_usage("<magic> 'Magic word to use (eg, 0x5025700)'")
            .arg_from_usage("<entry_size> 'Size of each entry (bytes)'")
            .arg_from_usage("<algo_name> 'Name of algorithm (empty string for none)'"))
        .get_matches();


    match matches.subcommand() {
        ("info", Some(subm)) => {
            let path = Path::new(subm.value_of("FILE").unwrap());
            let sf = SleepFile::open(path, false)?;
            //debug!(println!("{:?}", sf));
            println!("Magic: 0x{:X}", sf.get_magic());
            println!("Algorithm: '{}'", sf.get_algorithm().or(Some("".to_string())).unwrap());
            println!("Entry Size (bytes): {}", sf.get_entry_size());
            println!("Entry count: {}", sf.length()?);
        },
        ("create", Some(subm)) => {
            let path = Path::new(subm.value_of("FILE").unwrap());
            let algo_name = subm.value_of("algo_name").unwrap();
            let algo_name = if algo_name.len() == 0 {
                None
            } else {
                Some(algo_name.to_string())
            };
            SleepFile::create(
                path,
                value_t_or_exit!(subm, "magic", u32),
                value_t_or_exit!(subm, "entry_size", u16),
                algo_name)?;
            println!("Done!");
        },
        _ => {
            println!("Missing or unimplemented command!");
            println!("{}", matches.usage());
            ::std::process::exit(-1);
        },
    }
    Ok(())
}

// TODO: is there a shorter error_chain 'main()' to use here?
fn main() {
    if let Err(ref e) = run() {
        println!("error: {}", e);

        for e in e.iter().skip(1) {
            println!("caused by: {}", e);
        }

        // The backtrace is not always generated. Try to run this example
        // with `RUST_BACKTRACE=1`.
        if let Some(backtrace) = e.backtrace() {
            println!("backtrace: {:?}", backtrace);
        }

        ::std::process::exit(1);
    }
}