100 lines
3.1 KiB
Rust
100 lines
3.1 KiB
Rust
use super::*;
|
|
use cursive_table_view::*;
|
|
use std::cmp::Ordering;
|
|
use veilid_core::PeerTableData;
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
|
|
pub enum PeerTableColumn {
|
|
NodeId,
|
|
Address,
|
|
LatencyAvg,
|
|
TransferDownAvg,
|
|
TransferUpAvg,
|
|
}
|
|
|
|
// impl PeerTableColumn {
|
|
// fn as_str(&self) -> &str {
|
|
// match self {
|
|
// PeerTableColumn::NodeId => "Node Id",
|
|
// PeerTableColumn::Address => "Address",
|
|
// PeerTableColumn::LatencyAvg => "Latency",
|
|
// PeerTableColumn::TransferDownAvg => "Down",
|
|
// PeerTableColumn::TransferUpAvg => "Up",
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
fn format_ts(ts: u64) -> String {
|
|
let secs = timestamp_to_secs(ts);
|
|
if secs >= 1.0 {
|
|
format!("{:.2}s", timestamp_to_secs(ts))
|
|
} else {
|
|
format!("{:.2}ms", timestamp_to_secs(ts) * 1000.0)
|
|
}
|
|
}
|
|
|
|
fn format_bps(bps: u64) -> String {
|
|
if bps >= 1024u64 * 1024u64 * 1024u64 {
|
|
format!("{:.2}GB/s", (bps / (1024u64 * 1024u64)) as f64 / 1024.0)
|
|
} else if bps >= 1024u64 * 1024u64 {
|
|
format!("{:.2}MB/s", (bps / 1024u64) as f64 / 1024.0)
|
|
} else if bps >= 1024u64 {
|
|
format!("{:.2}KB/s", bps as f64 / 1024.0)
|
|
} else {
|
|
format!("{:.2}B/s", bps as f64)
|
|
}
|
|
}
|
|
|
|
impl TableViewItem<PeerTableColumn> for PeerTableData {
|
|
fn to_column(&self, column: PeerTableColumn) -> String {
|
|
match column {
|
|
PeerTableColumn::NodeId => self.node_id.encode(),
|
|
PeerTableColumn::Address => format!(
|
|
"{:?}:{}",
|
|
self.peer_address.protocol_type(),
|
|
self.peer_address.to_socket_addr()
|
|
),
|
|
PeerTableColumn::LatencyAvg => format!(
|
|
"{}",
|
|
self.peer_stats
|
|
.latency
|
|
.as_ref()
|
|
.map(|l| format_ts(l.average))
|
|
.unwrap_or("---".to_owned())
|
|
),
|
|
PeerTableColumn::TransferDownAvg => format_bps(self.peer_stats.transfer.down.average),
|
|
PeerTableColumn::TransferUpAvg => format_bps(self.peer_stats.transfer.up.average),
|
|
}
|
|
}
|
|
|
|
fn cmp(&self, other: &Self, column: PeerTableColumn) -> Ordering
|
|
where
|
|
Self: Sized,
|
|
{
|
|
match column {
|
|
PeerTableColumn::NodeId => self.node_id.cmp(&other.node_id),
|
|
PeerTableColumn::Address => self.to_column(column).cmp(&other.to_column(column)),
|
|
PeerTableColumn::LatencyAvg => self
|
|
.peer_stats
|
|
.latency
|
|
.as_ref()
|
|
.map(|l| l.average)
|
|
.cmp(&other.peer_stats.latency.as_ref().map(|l| l.average)),
|
|
PeerTableColumn::TransferDownAvg => self
|
|
.peer_stats
|
|
.transfer
|
|
.down
|
|
.average
|
|
.cmp(&other.peer_stats.transfer.down.average),
|
|
PeerTableColumn::TransferUpAvg => self
|
|
.peer_stats
|
|
.transfer
|
|
.up
|
|
.average
|
|
.cmp(&other.peer_stats.transfer.up.average),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type PeersTableView = TableView<PeerTableData, PeerTableColumn>;
|