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

use clap::ArgMatches;
use serde::Serialize;
use snafu::ResultExt;
use std::collections::HashMap;
use uuid::Uuid;

use super::session;
use super::{DecoderError, Error, SerializationError};

#[derive(Serialize)]
pub struct JsonSessionOutput
{
    session: session::Session,
    request_data: HashMap<Uuid, JsonRequestData>,
}

#[derive(Serialize)]
pub struct JsonRequestData
{
    request: JsonMessageData,
    response: JsonMessageData,
}

#[derive(Serialize)]
pub struct JsonMessageData
{
    decoded: HashMap<&'static str, String>,
}

pub fn view(matches: &ArgMatches) -> Result<(), Error>
{
    let filename = matches.value_of("file").unwrap();
    let session = session::serialization::read_file(&filename).context(SerializationError {})?;

    let decoders = crate::decoders::get_decoders(matches).context(DecoderError {})?;

    let mut output = JsonSessionOutput {
        session,
        request_data: Default::default(),
    };
    for r in output.session.requests.iter() {
        output.request_data.insert(
            r.request_data.uuid,
            JsonRequestData {
                request: get_message_data(&r.request_data, &r.request_msg, &decoders),
                response: get_message_data(&r.request_data, &r.response_msg, &decoders),
            },
        );
    }

    println!("{}", serde_json::to_string_pretty(&output).unwrap());
    Ok(())
}

fn get_message_data(
    req: &session::RequestData,
    msg: &session::MessageData,
    decoders: &crate::decoders::Decoders,
) -> JsonMessageData
{
    JsonMessageData {
        decoded: decoders
            .get_decoders(req, msg)
            .map(|dec| {
                (
                    dec.name(),
                    dec.decode(msg)
                        .into_iter()
                        .map(text_to_string)
                        .collect::<String>(),
                )
            })
            .collect(),
    }
}

fn text_to_string(s: tui::text::Spans) -> String
{
    s.0.iter().map(|s| s.content.as_ref()).collect::<String>()
}