sndr 0.3.0

Easily and securely share files from the command line. A fully featured Send client (formerly ffsend, rebranded by tarnover).
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

use chrono::Duration;
use clap::ArgMatches;
use ffsend_api::config::SEND_DEFAULT_EXPIRE_TIME;
use prettytable::{format::FormatBuilder, Cell, Row, Table};

use crate::client::to_duration;
use crate::cmd::matcher::{debug::DebugMatcher, main::MainMatcher, Matcher};
use crate::error::ActionError;
#[cfg(feature = "clipboard-bin")]
use crate::util::ClipboardType;
use crate::util::{api_version_list, features_list, format_bool, format_duration};

/// A file debug action.
pub struct Debug<'a> {
    cmd_matches: &'a ArgMatches<'a>,
}

impl<'a> Debug<'a> {
    /// Construct a new debug action.
    pub fn new(cmd_matches: &'a ArgMatches<'a>) -> Self {
        Self { cmd_matches }
    }

    /// Invoke the debug action.
    // TODO: create a trait for this method
    pub fn invoke(&self) -> Result<(), ActionError> {
        // Create the command matchers
        let matcher_main = MainMatcher::with(self.cmd_matches).unwrap();
        let matcher_debug = DebugMatcher::with(self.cmd_matches).unwrap();

        // Create a table for all debug information
        let mut table = Table::new();
        table.set_format(FormatBuilder::new().padding(0, 2).build());

        // The crate version
        table.add_row(Row::new(vec![
            Cell::new("Version:"),
            Cell::new(crate_version!()),
        ]));

        // The default host
        table.add_row(Row::new(vec![
            Cell::new("Host:"),
            Cell::new(matcher_debug.host().as_str()),
        ]));

        // The history file
        #[cfg(feature = "history")]
        table.add_row(Row::new(vec![
            Cell::new("History file:"),
            Cell::new(matcher_main.history().to_str().unwrap_or("?")),
        ]));

        // The timeouts
        table.add_row(Row::new(vec![
            Cell::new("Timeout:"),
            Cell::new(
                &to_duration(matcher_main.timeout())
                    .map(|t| {
                        format_duration(
                            Duration::from_std(t).expect("failed to convert timeout duration"),
                        )
                    })
                    .unwrap_or("disabled".into()),
            ),
        ]));
        table.add_row(Row::new(vec![
            Cell::new("Transfer timeout:"),
            Cell::new(
                &to_duration(matcher_main.transfer_timeout())
                    .map(|t| {
                        format_duration(
                            Duration::from_std(t)
                                .expect("failed to convert transfer timeout duration"),
                        )
                    })
                    .unwrap_or("disabled".into()),
            ),
        ]));

        // The default host
        table.add_row(Row::new(vec![
            Cell::new("Default expiry:"),
            Cell::new(&format_duration(Duration::seconds(
                SEND_DEFAULT_EXPIRE_TIME as i64,
            ))),
        ]));

        // Render a list of compiled features
        table.add_row(Row::new(vec![
            Cell::new("Features:"),
            Cell::new(&features_list().join(", ")),
        ]));

        // Render a list of compiled features
        table.add_row(Row::new(vec![
            Cell::new("API support:"),
            Cell::new(&api_version_list().join(", ")),
        ]));

        // Show used crypto backend
        table.add_row(Row::new(vec![
            Cell::new("Crypto backend:"),
            #[cfg(feature = "crypto-ring")]
            Cell::new("ring"),
            #[cfg(feature = "crypto-openssl")]
            Cell::new("OpenSSL"),
        ]));

        // Clipboard information
        #[cfg(feature = "clipboard-bin")]
        table.add_row(Row::new(vec![
            Cell::new("Clipboard:"),
            Cell::new(&format!("{}", ClipboardType::select())),
        ]));

        // Show whether quiet is used
        table.add_row(Row::new(vec![
            Cell::new("Quiet:"),
            Cell::new(format_bool(matcher_main.quiet())),
        ]));

        // Show whether verbose is used
        table.add_row(Row::new(vec![
            Cell::new("Verbose:"),
            Cell::new(format_bool(matcher_main.verbose())),
        ]));

        // Print the debug table
        table.printstd();

        Ok(())
    }
}