proxide 0.2.3

Proxide is a debugging proxy for capturing HTTP/2 and gRPC traffic. 
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

use crate::ui::state::UiContext;
use crate::ui::toast;
use chrono::prelude::*;
use clap::{App, Arg, ArgMatches, SubCommand};
use core::cell::RefCell;
use tui::backend::Backend;

use super::Executable;
use crate::session;
use crate::ui::state::HandleResult;

thread_local! {
    pub static CMD_API: RefCell<App<'static>> = RefCell::new(create_app());
}

pub fn create_app() -> App<'static>
{
    App::new("CMD")
        .setting(clap::AppSettings::NoBinaryName)
        .subcommand(SubCommand::with_name("quit").alias("q"))
        .subcommand(SubCommand::with_name("clear"))
        .subcommand(
            SubCommand::with_name("export")
                .alias("w")
                .arg(
                    Arg::with_name("file")
                        .index(1)
                        .value_name("file")
                        .required(false),
                )
                .arg(
                    Arg::with_name("format")
                        .short('f')
                        .long("format")
                        .takes_value(true)
                        .possible_values(["msgpack", "json"]),
                ),
        )
}

pub struct ColonCommand;
impl<B: Backend> Executable<B> for ColonCommand
{
    fn execute(&self, cmd: &str, ctx: &mut UiContext) -> Option<HandleResult<B>>
    {
        let words = match shell_words::split(cmd) {
            Ok(w) => w,
            Err(e) => {
                toast::show_error(format!("Failed to parse command:\n{}", e));
                return None;
            }
        };

        CMD_API.with(|api| {
            let mut cmd_borrow = api.borrow_mut();
            let matches = match cmd_borrow.get_matches_from_safe_borrow(words) {
                Ok(matches) => matches,
                Err(e) => {
                    toast::show_error(format!("Failed to parse command:\n{}", e));
                    return None;
                }
            };
            execute_matches(matches, ctx)
        })
    }
}

pub fn execute_matches<B: Backend>(s: ArgMatches, ctx: &mut UiContext) -> Option<HandleResult<B>>
{
    match s.subcommand() {
        Some(("quit", _)) => Some(HandleResult::Quit),
        Some(("clear", _)) => clear_session(ctx),
        Some(("export", m)) => export_session(ctx, m),
        Some((cmd, _)) => {
            toast::show_error(format!("Unknown command: {}", cmd));
            None
        }
        None => {
            toast::show_error("No command specified");
            None
        }
    }
}

pub fn clear_session<B: Backend>(ctx: &mut UiContext) -> Option<HandleResult<B>>
{
    ctx.data.requests = Default::default();
    ctx.data.connections = Default::default();
    Some(HandleResult::Update)
}

pub fn export_session<B: Backend>(ctx: &UiContext, matches: &ArgMatches)
    -> Option<HandleResult<B>>
{
    let filename = matches
        .value_of("file")
        .map(|f| f.to_string())
        .unwrap_or_else(|| format!("session-{}.bin", Local::now().format("%Y-%m-%d_%H%M%S")));

    let format = match matches.value_of("format") {
        Some("json") => session::serialization::OutputFormat::Json,
        _ => session::serialization::OutputFormat::MessagePack,
    };

    match ctx.data.write_to_file(&filename, format) {
        Ok(_) => toast::show_message(format!("Exported session to '{}'", filename)),
        Err(e) => toast::show_error(e.to_string()),
    }

    None
}