gprobe 0.1.2

A verbose CLI to probe go-ethereum data structures.
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
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

use clap::CommandFactory;
use flate2::read::GzDecoder;
use isatty::stdout_isatty;
use spinners::{Spinner, Spinners};
use std::{fs::File, thread};
use tar::Archive;

use crate::{
    cli::{GProbe, Subcommands},
    telemetry,
};

impl GProbe {
    /// Runs the core logic for the [gprobe::cli::GProbe] CLI Application
    pub fn run(&mut self) {
        let mut app = GProbe::into_app();

        // Set up tracing
        let subscriber = match self.verbose {
            true => {
                println!("Initializing verbose subscriber...");
                telemetry::get_subscriber("debug".into())
            }
            false => telemetry::get_subscriber("info".into()),
        };
        telemetry::init_subscriber(subscriber);

        // Match on subcommand
        match &self.subcommand {
            Some(Subcommands::Tree { level, path }) => {
                let p = match self.source {
                    Some(_) => self.source.clone(),
                    None => path.clone(),
                };
                self.tree(*level, p);
            }
            Some(Subcommands::Create { path }) => {
                let p = match self.source {
                    Some(_) => self.source.clone(),
                    None => path.clone(),
                };
                self.create(p);
            }
            Some(Subcommands::Decompress { path }) => {
                let p = match self.source {
                    Some(_) => self.source.clone(),
                    None => path.clone(),
                };
                match p {
                    Some(p) => self.decompress(&p),
                    None => {
                        println!("No path provided for tarball");
                    }
                }
            }
            None => {
                if app.print_help().is_err() {
                    tracing::warn!("Failed to print help menu for gprobe command");
                }
            }
        }
    }

    /// Decompress a tarball
    pub fn decompress(&self, p: &str) {
        match File::open(p) {
            Ok(tar_gz) => {
                let tar = GzDecoder::new(tar_gz);
                let mut archive = Archive::new(tar);
                if let Err(e) = archive.unpack(".") {
                    tracing::error!("Failed to decompress tarball: {}", e);
                }
            }
            Err(e) => {
                tracing::error!("Failed to open tarball: {}", e);
            }
        }
    }

    /// Prints out a tree of the data source
    pub fn tree(&mut self, level: u64, path: Option<String>) {
        GProbe::spin("Probing...", |sp| {
            tracing::debug!("Tracing a datastore tree with a depth of {}", level);
            thread::sleep(std::time::Duration::from_secs(2));

            let path = match path {
                Some(path) => path,
                None => {
                    tracing::warn!("No path provided for datastore tree");
                    return;
                }
            };
            crate::handlers::walk(path, level, sp);

            tracing::debug!("Done tracing datastore tree");
        });
    }

    /// Creates a new database at the provided path
    pub fn create(&mut self, path: Option<String>) {
        GProbe::spin("Creating...", |sp| {
            thread::sleep(std::time::Duration::from_secs(2));

            let path = match path {
                Some(path) => path,
                None => {
                    tracing::warn!("No path provided for datastore tree");
                    return;
                }
            };
            crate::handlers::create(path, sp);

            tracing::debug!("Done tracing datastore tree");
        });
    }

    /// Wraps the callback in a spinner if stdout is a TTY
    fn spin(prompt: impl std::fmt::Display, callback: impl FnOnce(&mut Option<Spinner>)) {
        // If stdout is a TTY, create a spinner
        let mut sp: Option<Spinner> = None;
        if stdout_isatty() {
            sp = Some(Spinner::new(Spinners::Dots, format!("{}", prompt)));
        }

        callback(&mut sp);

        // Stop spinner animation if it exists
        if let Some(mut sp) = sp {
            sp.stop();
            println!(" ");
        }
    }
}