shohei 0.5.0

Infrastructure diagnostics library: DNS, DNSSEC, TLS certificate inspection, email security, DNS propagation, and MCP-integrated AI agent support
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
141
142
143
144
145
146

use std::collections::HashSet;

use owo_colors::{OwoColorize, Stream};

use crate::display::table::{format_record_data, render_result};
use crate::resolver::{DnsComparison, DnsMultiQuery};

pub fn render_multi_query(multi: &DnsMultiQuery, use_color: bool) -> String {
    let mut out = String::new();
    if use_color {
        out.push_str(&format!(
            "\n{} {} {}\n",
            "Multi-server query:".if_supports_color(Stream::Stdout, |t| t.dimmed()),
            format!("{} {}", multi.record_type, multi.domain)
                .if_supports_color(Stream::Stdout, |t| t.bold()),
            format!("({} servers)", multi.results.len())
                .if_supports_color(Stream::Stdout, |t| t.dimmed()),
        ));
    } else {
        out.push_str(&format!(
            "\nMulti-server query: {} {} ({} servers)\n",
            multi.record_type, multi.domain, multi.results.len()
        ));
    }
    for result in &multi.results {
        if use_color {
            out.push_str(&format!(
                "\n{}\n",
                format!("─── {} ───", result.server_addr)
                    .if_supports_color(Stream::Stdout, |t| t.cyan()),
            ));
        } else {
            out.push_str(&format!("\n--- {} ---\n", result.server_addr));
        }
        out.push_str(&render_result(result, use_color));
    }
    out
}

pub fn render_comparison(cmp: &DnsComparison, use_color: bool) -> String {
    let left_set: HashSet<String> = cmp
        .left
        .answers
        .iter()
        .map(|r| format_record_data(&r.data))
        .collect();
    let right_set: HashSet<String> = cmp
        .right
        .answers
        .iter()
        .map(|r| format_record_data(&r.data))
        .collect();

    // Sorted union for deterministic display order
    let mut all: Vec<&String> = left_set.union(&right_set).collect();
    all.sort();

    let mut out = String::new();

    if use_color {
        out.push_str(&format!(
            "\n{} {}\n",
            "Comparing".if_supports_color(Stream::Stdout, |t| t.dimmed()),
            format!("{} {}", cmp.record_type, cmp.domain)
                .if_supports_color(Stream::Stdout, |t| t.bold())
        ));
        out.push_str(&format!(
            "  {}  {}\n\n",
            format!("← {}", cmp.left.server_addr)
                .if_supports_color(Stream::Stdout, |t| t.dimmed()),
            format!("→ {}", cmp.right.server_addr)
                .if_supports_color(Stream::Stdout, |t| t.dimmed()),
        ));
    } else {
        out.push_str(&format!(
            "\nComparing {} {}\n  ← {}  → {}\n\n",
            cmp.record_type, cmp.domain, cmp.left.server_addr, cmp.right.server_addr
        ));
    }

    let mut matches = 0usize;
    for data in &all {
        let in_left = left_set.contains(*data);
        let in_right = right_set.contains(*data);
        match (in_left, in_right) {
            (true, true) => {
                matches += 1;
                out.push_str(&format!("  =  {data}\n"));
            }
            (true, false) => {
                if use_color {
                    out.push_str(&format!(
                        "  {}  {data}  {}\n",
                        "<".if_supports_color(Stream::Stdout, |t| t.yellow()),
                        format!("(only ←{})", cmp.left.server_addr)
                            .if_supports_color(Stream::Stdout, |t| t.dimmed()),
                    ));
                } else {
                    out.push_str(&format!(
                        "  <  {data}  (only ←{})\n",
                        cmp.left.server_addr
                    ));
                }
            }
            (false, true) => {
                if use_color {
                    out.push_str(&format!(
                        "  {}  {data}  {}\n",
                        ">".if_supports_color(Stream::Stdout, |t| t.cyan()),
                        format!("(only →{})", cmp.right.server_addr)
                            .if_supports_color(Stream::Stdout, |t| t.dimmed()),
                    ));
                } else {
                    out.push_str(&format!(
                        "  >  {data}  (only →{})\n",
                        cmp.right.server_addr
                    ));
                }
            }
            _ => unreachable!(),
        }
    }

    let total = all.len();
    let summary = format!(
        "  {}/{} records match  [←{}: {} records, {}ms]  [→{}: {} records, {}ms]",
        matches,
        total,
        cmp.left.server_addr,
        cmp.left.answers.len(),
        cmp.left.duration_ms,
        cmp.right.server_addr,
        cmp.right.answers.len(),
        cmp.right.duration_ms,
    );
    if use_color {
        out.push_str(&format!(
            "\n{}\n",
            summary.if_supports_color(Stream::Stdout, |t| t.dimmed())
        ));
    } else {
        out.push_str(&format!("\n{summary}\n"));
    }

    out
}