174 lines
6.4 KiB
Rust
174 lines
6.4 KiB
Rust
use egui::ScrollArea;
|
|
use enostr::{RelayLogEvent, SubsDebug};
|
|
|
|
pub struct RelayDebugView<'a> {
|
|
debug: &'a mut SubsDebug,
|
|
}
|
|
|
|
impl<'a> RelayDebugView<'a> {
|
|
pub fn new(debug: &'a mut SubsDebug) -> Self {
|
|
Self { debug }
|
|
}
|
|
}
|
|
|
|
impl RelayDebugView<'_> {
|
|
pub fn ui(&mut self, ui: &mut egui::Ui) {
|
|
ScrollArea::vertical()
|
|
.id_salt(ui.id().with("relays_debug"))
|
|
.max_height(ui.max_rect().height() / 2.0)
|
|
.show(ui, |ui| {
|
|
ui.label("Active Relays:");
|
|
for (relay_str, data) in self.debug.get_data() {
|
|
egui::CollapsingHeader::new(format!(
|
|
"{} {} {}",
|
|
relay_str,
|
|
format_total(&data.count),
|
|
format_sec(&data.count)
|
|
))
|
|
.default_open(true)
|
|
.show(ui, |ui| {
|
|
ui.horizontal_wrapped(|ui| {
|
|
for (i, sub_data) in data.sub_data.values().enumerate() {
|
|
ui.label(format!(
|
|
"Filter {} ({})",
|
|
i + 1,
|
|
format_sec(&sub_data.count)
|
|
))
|
|
.on_hover_cursor(egui::CursorIcon::Help)
|
|
.on_hover_text(sub_data.filter.to_string());
|
|
}
|
|
})
|
|
});
|
|
}
|
|
});
|
|
|
|
ui.separator();
|
|
egui::ComboBox::from_label("Show events from relay")
|
|
.selected_text(
|
|
self.debug
|
|
.relay_events_selection
|
|
.as_ref()
|
|
.map_or(String::new(), |s| s.clone()),
|
|
)
|
|
.show_ui(ui, |ui| {
|
|
let mut make_selection = None;
|
|
for relay in self.debug.get_data().keys() {
|
|
if ui
|
|
.selectable_label(
|
|
if let Some(s) = &self.debug.relay_events_selection {
|
|
*s == *relay
|
|
} else {
|
|
false
|
|
},
|
|
relay,
|
|
)
|
|
.clicked()
|
|
{
|
|
make_selection = Some(relay.clone());
|
|
}
|
|
}
|
|
if make_selection.is_some() {
|
|
self.debug.relay_events_selection = make_selection
|
|
}
|
|
});
|
|
let show_relay_evs =
|
|
|ui: &mut egui::Ui, relay: Option<String>, events: Vec<RelayLogEvent>| {
|
|
for ev in events {
|
|
ui.horizontal_wrapped(|ui| {
|
|
if let Some(r) = &relay {
|
|
ui.label("relay").on_hover_text(r.clone());
|
|
}
|
|
match ev {
|
|
RelayLogEvent::Send(client_message) => {
|
|
ui.label("SEND: ");
|
|
let msg = &match client_message {
|
|
enostr::ClientMessage::Event { .. } => "Event",
|
|
enostr::ClientMessage::Req { .. } => "Req",
|
|
enostr::ClientMessage::Close { .. } => "Close",
|
|
enostr::ClientMessage::Raw(_) => "Raw",
|
|
};
|
|
|
|
if let Ok(json) = client_message.to_json() {
|
|
ui.label(*msg).on_hover_text(json)
|
|
} else {
|
|
ui.label(*msg)
|
|
}
|
|
}
|
|
RelayLogEvent::Recieve(e) => {
|
|
ui.label("RECIEVE: ");
|
|
match e {
|
|
enostr::OwnedRelayEvent::Opened => ui.label("Opened"),
|
|
enostr::OwnedRelayEvent::Closed => ui.label("Closed"),
|
|
enostr::OwnedRelayEvent::Other(s) => {
|
|
ui.label("Other").on_hover_text(s)
|
|
}
|
|
enostr::OwnedRelayEvent::Error(s) => {
|
|
ui.label("Error").on_hover_text(s)
|
|
}
|
|
enostr::OwnedRelayEvent::Message(s) => {
|
|
ui.label("Message").on_hover_text(s)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
ScrollArea::vertical()
|
|
.id_salt(ui.id().with("events"))
|
|
.show(ui, |ui| {
|
|
if let Some(relay) = &self.debug.relay_events_selection {
|
|
if let Some(data) = self.debug.get_data().get(relay) {
|
|
show_relay_evs(ui, None, data.events.clone());
|
|
}
|
|
} else {
|
|
for (relay, data) in self.debug.get_data() {
|
|
show_relay_evs(ui, Some(relay.clone()), data.events.clone());
|
|
}
|
|
}
|
|
});
|
|
|
|
self.debug.try_increment_stats();
|
|
}
|
|
|
|
pub fn window(ctx: &egui::Context, debug: &mut SubsDebug) {
|
|
let mut open = true;
|
|
egui::Window::new("Relay Debugger")
|
|
.open(&mut open)
|
|
.show(ctx, |ui| {
|
|
RelayDebugView::new(debug).ui(ui);
|
|
});
|
|
}
|
|
}
|
|
|
|
fn format_sec(c: &enostr::TransferStats) -> String {
|
|
format!(
|
|
"⬇{} ⬆️{}",
|
|
byte_to_string(c.down_sec_prior),
|
|
byte_to_string(c.up_sec_prior)
|
|
)
|
|
}
|
|
|
|
fn format_total(c: &enostr::TransferStats) -> String {
|
|
format!(
|
|
"total: ⬇{} ⬆️{}",
|
|
byte_to_string(c.down_total),
|
|
byte_to_string(c.up_total)
|
|
)
|
|
}
|
|
|
|
const MB: usize = 1_048_576;
|
|
const KB: usize = 1024;
|
|
fn byte_to_string(b: usize) -> String {
|
|
if b >= MB {
|
|
let mbs = b as f32 / MB as f32;
|
|
format!("{:.2} MB", mbs)
|
|
} else if b >= KB {
|
|
let kbs = b as f32 / KB as f32;
|
|
format!("{:.2} KB", kbs)
|
|
} else {
|
|
format!("{} B", b)
|
|
}
|
|
}
|