hawktracer_converter_lib/

label_mapping.rs

use hawktracer_parser::{CoreEventKlassId, Event, Value};
use std::io::BufRead;

// TODO: SUPPORT MAPPING EVENT

#[derive(Default)]
pub struct LabelMap {
    mapping: std::collections::HashMap<u64, String>,
}

impl LabelMap {
    pub fn new() -> LabelMap {
        LabelMap {
            mapping: std::collections::HashMap::<u64, String>::new(),
        }
    }

    pub fn load_from_file(&mut self, path: &str) -> std::io::Result<()> {
        let f = std::fs::File::open(path)?;
        let file = std::io::BufReader::new(&f);
        for (i, line) in file.lines().enumerate() {
            let line = line?;
            let data: Vec<&str> = line.split(' ').collect();
            if data.len() != 3 {
                eprintln!(
                    "invalid mapping in line {}. Expected 3 arguments, was {}",
                    i,
                    data.len()
                );
                continue;
            }

            let id = match data[2].parse::<u64>() {
                Err(e) => {
                    eprintln!(
                        "Can not parse identifier '{}' in line {}. Error message: {}",
                        data[2], i, e
                    );
                    continue;
                }
                Ok(id) => id,
            };

            let label = data[1].to_string();
            self.mapping.insert(id, label); // TODO support data[0] (category)?
        }

        Ok(())
    }

    pub fn get_label(&mut self, id: u64) -> &String {
        self.mapping.entry(id).or_insert_with(|| {
            eprintln!("Label for ID {} does not exist in the mapping", id);
            id.to_string()
        })
    }

    pub fn add_mapping(&mut self, id: u64, label: &str) {
        self.mapping.insert(id, label.to_owned());
    }
}

pub struct LabelGetter {
    label_map: LabelMap,
    label_fields: std::vec::Vec<String>,
    mapping_event_id: Option<u32>,
}

impl LabelGetter {
    pub fn new(label_map: LabelMap, label_fields: std::vec::Vec<String>) -> LabelGetter {
        LabelGetter {
            label_map,
            label_fields,
            mapping_event_id: None,
        }
    }

    // TODO TEST ME PLEASE!
    fn update_mapping_event_info(&mut self, event: &Event) -> bool {
        if self.mapping_event_id.is_none()
            && event.get_klass_id() == CoreEventKlassId::KlassInfo as u32
        {
            let klass_name = event.get_value_string("event_klass_name");
            if klass_name.is_ok() && klass_name.unwrap() == "HT_StringMappingEvent" {
                // TODO We should have KlassInfo event wrapper with get_klass_name method in parser
                self.mapping_event_id = event.get_value_u32("info_klass_id").ok();
            }
        } else if self.mapping_event_id.is_some()
            && event.get_klass_id() == self.mapping_event_id.unwrap()
        {
            if let Ok(label) = event.get_value_string("label") {
                if let Ok(id) = event.get_value_u64("identifier") {
                    self.label_map.add_mapping(id, label);
                    return true;
                }
            }
        }
        false
    }

    pub fn get_label<'a>(&'a mut self, event: &'a Event) -> Option<(&'a String, &'a String)> {
        if self.update_mapping_event_info(event) {
            return None
        }

        for label_field in &self.label_fields {
            if let Some(value) = event.get_raw_value(label_field) {
                match value {
                    Value::U64(value) => {
                        return Some((label_field, self.label_map.get_label(*value)));
                    }
                    Value::Str(value) => return Some((label_field, value)),
                    _ => (),
                }
            }
        }
        None
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn load_from_file_valid_file_should_load_mapping() {
        let mut path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
        path.push("resources/test/label_map_valid.txt");
        let mut map = LabelMap::new();

        map.load_from_file(&path.to_str().unwrap()).unwrap();

        assert_eq!(map.get_label(1), "label1");
        assert_eq!(map.get_label(2), "label2");
        assert_eq!(map.get_label(3), "label3");
    }

    #[test]
    fn load_from_file_corrupted_file_should_ignore_invalid_values() {
        let mut path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
        path.push("resources/test/label_map_invalid.txt");
        let mut map = LabelMap::new();

        map.load_from_file(&path.to_str().unwrap()).unwrap();

        assert_eq!(map.get_label(8), "valid_label");
    }

    #[test]
    fn load_from_file_should_fail_if_file_does_not_exist() {
        let mut map = LabelMap::new();

        assert!(map.load_from_file("not_existing_file").is_err());
    }

    #[test]
    fn map_should_return_number_if_mapping_does_not_exist() {
        let mut map = LabelMap::new();

        assert_eq!(map.get_label(4), "4");
    }

    #[test]
    fn map_should_return_label_if_mapping_exist() {
        let mut map = LabelMap::new();
        let label = "test";
        map.mapping.insert(4, label.to_owned());

        assert_eq!(map.get_label(4), label);
    }

    fn make_event(field_name: &str, value: Value) -> Event {
        let mut values = std::collections::HashMap::<String, Value>::new();
        values.insert(field_name.to_owned(), value);
        Event::new(1, values)
    }

    #[test]
    fn getter_should_return_value_if_value_exists() {
        let mut getter = LabelGetter::new(LabelMap::new(), vec!["name".to_owned()]);
        let event = make_event("name", Value::Str("test1".to_owned()));

        let (field, value) = getter.get_label(&event).unwrap();

        assert_eq!(field, "name");
        assert_eq!(value, "test1");
    }

    #[test]
    fn getter_should_not_return_value_if_field_does_not_exist() {
        let mut getter = LabelGetter::new(LabelMap::new(), vec!["unknown".to_owned()]);
        let event = make_event("name", Value::Str("test1".to_owned()));

        let mapping = getter.get_label(&event);

        assert!(mapping.is_none());
    }

    #[test]
    fn getter_should_not_return_value_if_value_is_invalid() {
        let mut getter = LabelGetter::new(LabelMap::new(), vec!["name".to_owned()]);
        let event = make_event(
            "name",
            Value::Struct(Event::new(
                1,
                std::collections::HashMap::<String, Value>::new(),
            )),
        );

        let mapping = getter.get_label(&event);

        assert!(mapping.is_none());
    }
}