ddsi_log_parser 0.1.2

Utility to parse ddsi2 logs.
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

use crate::ddsi_log_regex::DdsiLogType;
use crate::ddsi_participant::DdsiParticipant;
use serde::ser::{Serialize, SerializeStruct, Serializer};
use std::collections::HashMap;
use std::error::Error;

#[derive(Debug)]
pub struct DdsiTopology {
    participants: HashMap<String, DdsiParticipant>,
    own_ip: String,
}

impl DdsiTopology {
    pub fn new() -> DdsiTopology {
        DdsiTopology {
            participants: HashMap::new(),
            own_ip: String::from("unkwnown"),
        }
    }

    pub fn update(&mut self, dds_log_type: DdsiLogType) -> Result<(), Box<dyn Error>> {
        let system_id = dds_log_type.get_system_id();

        if let DdsiLogType::OwnIp(capture) = dds_log_type {
            self.own_ip = String::from(&capture["hostname"]);
            Ok(())
        } else {
            let participant = self
                .participants
                .entry(system_id)
                .or_insert(DdsiParticipant::new(
                    &dds_log_type.get_system_id(),
                    &self.own_ip,
                ));

            participant.update(dds_log_type)
        }
    }

    pub fn len(&self) -> usize {
        self.participants.len()
    }

    pub fn get_participants_ids(&self) -> Vec<String> {
        self.participants.keys().cloned().collect()
    }

    pub fn summarize(&self) -> String {
        let mut summary = format!(
            "\t- Found {} participants: {:?}.\n",
            self.len(),
            self.get_participants_ids()
        );

        for participant_id in self.get_participants_ids() {
            let participant = self.participants.get(&participant_id).unwrap();

            summary.push_str(&format!(
                "\t- Participant {}@{}:\n",
                participant_id,
                participant.get_hostname()
            ));

            let readers_id = participant.get_readers_id();

            summary.push_str(&format!("\t\t- Readers {}:\n", readers_id.len()));

            for id in readers_id {
                let qos = participant.get_reader_qos(&id).unwrap();
                summary.push_str(&format!("\t\t\t- {}: {:?}\n", id, qos));
            }

            let writers_id = participant.get_writers_id();

            summary.push_str(&format!("\t\t- Writers {}:\n", writers_id.len()));

            for id in writers_id {
                let qos = participant.get_writer_qos(&id).unwrap();
                summary.push_str(&format!("\t\t\t- {}: {:?}\n", id, qos));
            }
        }
        summary
    }
}

impl Serialize for DdsiTopology {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        // 3 is the number of fields in the struct.
        let mut state = serializer.serialize_struct("DdsiTopology", 2)?;
        state.serialize_field("participants", &self.participants)?;
        state.serialize_field("own_ip", &self.own_ip)?;
        state.end()
    }
}