monocle 1.2.0

A commandline application to search, parse, and process BGP information in public sources.
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 clap::Args;
use monocle::lens::time::{TimeBgpTime, TimeLens, TimeParseArgs};
use monocle::utils::OutputFormat;
use tabled::settings::Style;
use tabled::Table;

/// Arguments for the Time command
#[derive(Args)]
pub struct TimeArgs {
    /// Time stamp or time string to convert
    #[clap()]
    pub time: Vec<String>,

    /// Simple output, only print the converted time (RFC3339 format)
    #[clap(short, long)]
    pub simple: bool,
}

pub fn run(args: TimeArgs, output_format: OutputFormat) {
    let TimeArgs { time, simple } = args;

    let lens = TimeLens::new();
    let parse_args = TimeParseArgs::new(time);

    // Simple mode overrides output format
    if simple {
        match lens.parse_to_rfc3339(&parse_args.times) {
            Ok(results) => {
                for r in results {
                    println!("{}", r);
                }
            }
            Err(e) => eprintln!("ERROR: {}", e),
        }
        return;
    }

    // Parse times
    let results = match lens.parse(&parse_args) {
        Ok(r) => r,
        Err(e) => {
            eprintln!("ERROR: {}", e);
            return;
        }
    };

    // Format and print based on output format
    format_output(&results, output_format);
}

fn format_output(results: &[TimeBgpTime], output_format: OutputFormat) {
    match output_format {
        OutputFormat::Table => {
            println!("{}", Table::new(results).with(Style::rounded()));
        }
        OutputFormat::Markdown => {
            println!("{}", Table::new(results).with(Style::markdown()));
        }
        OutputFormat::Json => match serde_json::to_string(results) {
            Ok(json) => println!("{}", json),
            Err(e) => eprintln!("ERROR: Failed to serialize to JSON: {}", e),
        },
        OutputFormat::JsonPretty => match serde_json::to_string_pretty(results) {
            Ok(json) => println!("{}", json),
            Err(e) => eprintln!("ERROR: Failed to serialize to JSON: {}", e),
        },
        OutputFormat::JsonLine => {
            for r in results {
                match serde_json::to_string(r) {
                    Ok(json) => println!("{}", json),
                    Err(e) => eprintln!("ERROR: Failed to serialize to JSON: {}", e),
                }
            }
        }
        OutputFormat::Psv => {
            println!("unix|rfc3339|human");
            for r in results {
                println!("{}|{}|{}", r.unix, r.rfc3339, r.human);
            }
        }
    }
}