logone 0.2.9

A command-line tool that parses Nix's --log-format json-internal output as standalone and crate library
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
134
135
136
137
138
139
140

use crate::logone;
use anyhow::{anyhow, Result};
use logone::{LogStatus, NixMessage};
use regex::Regex;
use serde_json::{Map, Value};

pub fn handle_log_start(obj: &Map<String, Value>, logone: &mut logone::LogOne) -> Result<()> {
    let id = obj
        .get("id")
        .and_then(|v| v.as_u64())
        .ok_or_else(|| anyhow!("Missing id in log start"))?;

    let text = obj
        .get("text")
        .and_then(|v| v.as_str())
        .unwrap_or("")
        .to_string();

    // Create new log buffer for this id
    logone.nix_log_buffers.insert(id, Vec::new());
    logone.nix_log_buffers_state.insert(id, LogStatus::Started);

    // Map id to derivation name
    //println!("{}", text.clone());
    logone.drv_to_id.insert(text.clone(), id);

    Ok(())
}

pub fn handle_log_line(obj: &Map<String, Value>, logone: &mut logone::LogOne) -> Result<()> {
    let id = obj
        .get("id")
        .and_then(|v| v.as_u64())
        .ok_or_else(|| anyhow!("Missing id in log line"))?;

    let fields = obj.get("fields").and_then(|v| v.as_array());

    let content = if let Some(fields) = fields {
        if !fields.is_empty() {
            fields[0].as_str().unwrap_or("").to_string()
        } else {
            String::new()
        }
    } else {
        String::new()
    };

    let message = NixMessage {
        action: "result".to_string(),
        message_type: Some(101), // resBuildLogLine
        content,
        level: None,
        file: None,
    };

    // Add to buffer
    if let Some(buffer) = logone.nix_log_buffers.get_mut(&id) {
        buffer.push(message);
    }

    Ok(())
}

pub fn handle_log_phase(obj: &Map<String, Value>, logone: &mut logone::LogOne) -> Result<()> {
    let id = obj
        .get("id")
        .and_then(|v| v.as_u64())
        .ok_or_else(|| anyhow!("Missing id in log phase"))?;

    let fields = obj.get("fields").and_then(|v| v.as_array());

    let content = if let Some(fields) = fields {
        if !fields.is_empty() {
            format!("Phase: {}", fields[0].as_str().unwrap_or(""))
        } else {
            "Phase: unknown".to_string()
        }
    } else {
        "Phase: unknown".to_string()
    };

    let message = NixMessage {
        action: "result".to_string(),
        message_type: Some(104), // resSetPhase
        content,
        level: None,
        file: None,
    };

    // Add to buffer
    if let Some(buffer) = logone.nix_log_buffers.get_mut(&id) {
        buffer.push(message);
    }

    Ok(())
}

pub fn handle_log_stop(obj: &Map<String, Value>, logone: &mut logone::LogOne) -> Result<()> {
    let id = obj
        .get("id")
        .and_then(|v| v.as_u64())
        .ok_or_else(|| anyhow!("Missing id in log phase"))?;
    logone.nix_log_buffers_state.insert(id, LogStatus::Stopped);
    Ok(())
}

pub fn handle_msg(obj: &Map<String, Value>, logone: &mut logone::LogOne) -> Result<()> {
    let level = obj.get("level").and_then(|v| v.as_u64()).unwrap_or(0);
    let msg = obj.get("msg").and_then(|v| v.as_str()).unwrap_or("");
    let file = obj.get("file").and_then(|v| v.as_str());

    let re = Regex::new(r#"/nix/store/([a-zA-Z0-9_.+-]+).drv"#).unwrap();
    let captures = re.captures(msg);

    match captures {
        Some(c) => {
            if let Some(c) = c.get(1) {
                // lv24iib6cgsr1ipkz4gpf2agf08bxj6n-cargo-0_88_0-d76731b471aa2da9
                let drv: String = format!("building '/nix/store/{}.drv'", c.as_str());
                logone.print_log_buffer_by_drv(drv);
            }
        }
        None => {}
    }

    // Show messages with level 1-3 (WARN, NOTICE, INFO)
    if level >= 1 && level <= 3 {
        logone.print_message(level, msg, file);
    }

    Ok(())
}

pub fn has_log_buffer(id: u64, logone: &mut logone::LogOne) -> bool {
    logone.nix_log_buffers.contains_key(&id)
}

pub fn query_logs_by_id(id: u64, logone: &mut logone::LogOne) -> Option<Vec<NixMessage>> {
    logone.nix_log_buffers.get(&id).cloned()
}