use std::collections::VecDeque;
use std::net::SocketAddr;
use std::time::{Duration, Instant};
use crate::constants;
const EMA_ALPHA: f64 = constants::PEER_STATS_EMA_ALPHA;
pub(crate) const RATE_WINDOW: Duration = Duration::from_secs(10);
pub(crate) const RATE_SAMPLE_INTERVAL: Duration = Duration::from_secs(1);
pub const BAD_DATA_THRESHOLD: u32 = constants::PEER_STATS_BAD_DATA_THRESHOLD as u32;
#[derive(Clone, Default)]
pub(crate) struct SpeedWindow {
samples: VecDeque<(Instant, u64)>,
}
impl SpeedWindow {
pub(crate) fn speed_at(&self, now: Instant) -> u64 {
let (bytes_in_window, oldest_sample) = self.totals_at(now);
let Some(oldest_sample) = oldest_sample else {
return 0;
};
let elapsed_millis = now
.saturating_duration_since(oldest_sample)
.as_millis()
.max(1);
((u128::from(bytes_in_window) * 1000) / elapsed_millis).min(u128::from(u64::MAX)) as u64
}
pub(crate) fn has_samples_at(&self, now: Instant) -> bool {
self.samples
.iter()
.any(|(sample_time, _)| now.saturating_duration_since(*sample_time) <= RATE_WINDOW)
}
fn totals_at(&self, now: Instant) -> (u64, Option<Instant>) {
let mut bytes_in_window = 0u64;
let mut oldest_sample = None;
for (sample_time, bytes) in &self.samples {
if now.saturating_duration_since(*sample_time) <= RATE_WINDOW {
bytes_in_window = bytes_in_window.saturating_add(*bytes);
oldest_sample.get_or_insert(*sample_time);
}
}
(bytes_in_window, oldest_sample)
}
pub(crate) fn record(&mut self, bytes: u64, at: Instant) {
if bytes == 0 {
return;
}
self.remove_expired(at);
if let Some((last_sample, last_bytes)) = self.samples.back_mut()
&& at.saturating_duration_since(*last_sample) < RATE_SAMPLE_INTERVAL
{
*last_bytes = last_bytes.saturating_add(bytes);
} else {
self.samples.push_back((at, bytes));
}
}
pub(crate) fn next_expiration_after(&self, now: Instant) -> Option<Instant> {
self.samples.iter().find_map(|(sample_time, _)| {
sample_time
.checked_add(RATE_WINDOW)?
.checked_add(Duration::from_nanos(1))
.filter(|deadline| *deadline > now)
})
}
fn remove_expired(&mut self, now: Instant) {
while let Some((sample_time, _)) = self.samples.front().copied() {
if now.saturating_duration_since(sample_time) <= RATE_WINDOW {
break;
}
self.samples.pop_front();
}
}
}
#[derive(Default)]
pub(crate) struct SwarmUploadRate {
window: std::sync::Mutex<SpeedWindow>,
changed: tokio::sync::Notify,
}
impl SwarmUploadRate {
pub(crate) fn record(&self, bytes: u64, at: Instant) {
self.window
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.record(bytes, at);
self.changed.notify_one();
}
pub(crate) fn speed_at(&self, now: Instant) -> u64 {
self.window
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.speed_at(now)
}
pub(crate) fn next_expiration_after(&self, now: Instant) -> Option<Instant> {
self.window
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.next_expiration_after(now)
}
pub(crate) fn changed(&self) -> &tokio::sync::Notify {
&self.changed
}
}
#[derive(Clone)]
pub struct PeerStats {
pub peer_id: [u8; 20],
pub addr: SocketAddr,
pub uploaded_bytes: u64,
pub downloaded_bytes: u64,
pub upload_speed: f64,
pub download_speed: f64,
pub avg_upload_speed: u64,
pub avg_download_speed: u64,
pub am_choking: bool,
pub am_interested: bool,
pub peer_choking: bool,
pub peer_interested: bool,
pub is_snubbed: bool,
pub opt_unchoking: bool,
pub outstanding_upload_count: usize,
pub bad_data_count: u32,
pub snub_count: u32,
pub is_banned: bool,
pub ban_reason: Option<String>,
pub last_message_received_at: Instant,
pub last_data_time: Option<Instant>,
pub last_upload_time: Option<Instant>,
pub last_unchoke_at: Instant,
pub last_optimistic_unchoke_at: Instant,
created_at: Instant,
last_upload_tick: Instant,
last_download_tick: Instant,
upload_rate_window: SpeedWindow,
download_rate_window: SpeedWindow,
}
impl PeerStats {
pub fn new(peer_id: [u8; 20], addr: SocketAddr) -> Self {
let now = Instant::now();
Self {
peer_id,
addr,
uploaded_bytes: 0,
downloaded_bytes: 0,
upload_speed: 0.0,
download_speed: 0.0,
avg_upload_speed: 0,
avg_download_speed: 0,
am_choking: true,
am_interested: false,
peer_choking: true,
peer_interested: false,
is_snubbed: false,
opt_unchoking: false,
outstanding_upload_count: 0,
bad_data_count: 0,
snub_count: 0,
is_banned: false,
ban_reason: None,
last_message_received_at: now,
last_data_time: None,
last_upload_time: None,
last_unchoke_at: now,
last_optimistic_unchoke_at: now,
created_at: now,
last_upload_tick: now,
last_download_tick: now,
upload_rate_window: SpeedWindow::default(),
download_rate_window: SpeedWindow::default(),
}
}
pub fn on_data_sent(&mut self, bytes: u64) {
self.uploaded_bytes += bytes;
let now = Instant::now();
self.last_upload_time = Some(now);
self.upload_rate_window.record(bytes, now);
let elapsed = now - self.last_upload_tick;
self.last_upload_tick = now;
if elapsed.is_zero() {
return; }
let instant_rate = bytes as f64 / elapsed.as_secs_f64();
if self.upload_speed == 0.0 && self.uploaded_bytes == bytes {
self.upload_speed = instant_rate;
} else {
self.upload_speed = EMA_ALPHA * instant_rate + (1.0 - EMA_ALPHA) * self.upload_speed;
}
let total_elapsed = self.created_at.elapsed().as_secs_f64();
if total_elapsed > 0.0 {
self.avg_upload_speed = (self.uploaded_bytes as f64 / total_elapsed) as u64;
}
}
pub(crate) fn recent_upload_speed_at(&self, now: Instant) -> u64 {
self.upload_rate_window.speed_at(now)
}
pub(crate) fn next_upload_speed_deadline(&self, now: Instant) -> Option<Instant> {
self.upload_rate_window.next_expiration_after(now)
}
pub(crate) fn recent_download_speed_at(&self, now: Instant) -> u64 {
self.download_rate_window.speed_at(now)
}
#[cfg(test)]
pub(crate) fn record_download_rate_at(&mut self, bytes: u64, at: Instant) {
self.download_rate_window.record(bytes, at);
}
#[cfg(test)]
pub(crate) fn record_upload_rate_at(&mut self, bytes: u64, at: Instant) {
self.upload_rate_window.record(bytes, at);
}
pub fn on_data_received(&mut self, bytes: u64) {
self.downloaded_bytes += bytes;
let now = Instant::now();
self.download_rate_window.record(bytes, now);
self.last_message_received_at = now;
self.last_data_time = Some(now);
self.is_snubbed = false;
let elapsed = now - self.last_download_tick;
self.last_download_tick = now;
if elapsed.is_zero() {
return;
}
let instant_rate = bytes as f64 / elapsed.as_secs_f64();
if self.download_speed == 0.0 && self.downloaded_bytes == bytes {
self.download_speed = instant_rate;
} else {
self.download_speed =
EMA_ALPHA * instant_rate + (1.0 - EMA_ALPHA) * self.download_speed;
}
let total_elapsed = self.created_at.elapsed().as_secs_f64();
if total_elapsed > 0.0 {
self.avg_download_speed = (self.downloaded_bytes as f64 / total_elapsed) as u64;
}
}
pub fn check_snubbed(&mut self, timeout_secs: u64) -> bool {
self.check_snubbed_at(timeout_secs, Instant::now())
}
pub(crate) fn check_snubbed_at(&mut self, timeout_secs: u64, now: Instant) -> bool {
if !self.is_snubbed
&& now.saturating_duration_since(self.last_message_received_at)
>= Duration::from_secs(timeout_secs)
{
self.is_snubbed = true;
self.snub_count = self.snub_count.saturating_add(1);
return true;
}
false
}
pub(crate) fn next_snubbed_deadline(&self, timeout_secs: u64) -> Option<Instant> {
if self.is_snubbed {
return None;
}
self.last_message_received_at
.checked_add(Duration::from_secs(timeout_secs))
}
pub fn reset_snubbed(&mut self) {
self.is_snubbed = false;
}
pub fn record_unchoke(&mut self) {
self.am_choking = false;
self.last_unchoke_at = Instant::now();
}
pub fn record_choke(&mut self) {
self.am_choking = true;
}
pub fn record_optimistic_unchoke(&mut self) {
self.record_optimistic_unchoke_at(Instant::now());
}
pub(crate) fn record_optimistic_unchoke_at(&mut self, now: Instant) {
self.am_choking = false;
self.last_optimistic_unchoke_at = now;
}
pub fn time_since_last_unchoke(&self) -> Duration {
self.last_unchoke_at.elapsed()
}
pub fn time_since_last_optimistic_unchoke(&self) -> Duration {
self.last_optimistic_unchoke_at.elapsed()
}
pub fn age(&self) -> Duration {
self.created_at.elapsed()
}
pub fn connection_duration_secs(&self) -> u64 {
self.created_at.elapsed().as_secs()
}
pub fn increment_bad_data(&mut self) -> bool {
self.bad_data_count = self.bad_data_count.saturating_add(1);
self.bad_data_count >= BAD_DATA_THRESHOLD
}
pub fn decrement_bad_data(&mut self) {
self.bad_data_count = self.bad_data_count.saturating_sub(1);
}
pub fn ban_peer(&mut self, reason: String) {
self.is_banned = true;
self.ban_reason = Some(reason);
}
pub fn is_eligible_for_selection(&self) -> bool {
!self.is_banned
}
}