use std::time::{Duration, Instant};
use rand::Rng;
use crate::engine::peer_stats::PeerStats;
pub use crate::engine::bt_choke_hooks::{
add_peer_to_tracking, check_snubbed_peers, handle_snubbed_peer,
handle_snubbed_peer_by_identity, on_data_received_from_peer,
on_data_received_from_peer_by_identity, on_peer_choke, on_peer_unchoke, on_piece_received,
optimistically_unchoke_by_identity, rotate_choke_by_identity, select_best_peer_for_request,
select_best_peer_for_request_by_identity,
};
const SEEDER_RECENT_UNCHOKE_TIME_FRAME: Duration = Duration::from_secs(20);
const LEECHER_REGULAR_UNCHOKE_WINDOW: Duration = Duration::from_secs(30);
const LEECHER_REGULAR_UNCHOKE_SLOTS: usize = 3;
#[derive(Debug, Clone)]
struct SeederPeerEntry {
#[allow(dead_code)]
identity: crate::engine::choking_algorithm::PeerIdentity,
index: usize,
outstanding_upload: bool,
last_am_unchoking: Instant,
recent_unchoking: bool,
upload_speed: i64,
}
impl SeederPeerEntry {
fn from_peer(index: usize, peer: &PeerStats) -> Self {
let now = Instant::now();
let last_am_unchoking = peer.last_unchoke_at;
let recent_unchoking =
now.duration_since(last_am_unchoking) < SEEDER_RECENT_UNCHOKE_TIME_FRAME;
Self {
identity: peer.into(),
index,
outstanding_upload: peer.outstanding_upload_count > 0,
last_am_unchoking,
recent_unchoking,
upload_speed: peer.upload_speed as i64,
}
}
}
impl Ord for SeederPeerEntry {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
match (self.outstanding_upload, other.outstanding_upload) {
(true, false) => return std::cmp::Ordering::Less,
(false, true) => return std::cmp::Ordering::Greater,
_ => {}
}
match (self.recent_unchoking, other.recent_unchoking) {
(true, false) => return std::cmp::Ordering::Less,
(false, true) => return std::cmp::Ordering::Greater,
(true, true) => {
return other.last_am_unchoking.cmp(&self.last_am_unchoking);
}
_ => {}
}
other
.upload_speed
.cmp(&self.upload_speed)
.then_with(|| self.identity.cmp(&other.identity))
}
}
impl PartialOrd for SeederPeerEntry {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl PartialEq for SeederPeerEntry {
fn eq(&self, other: &Self) -> bool {
self.index == other.index
}
}
impl Eq for SeederPeerEntry {}
#[derive(Debug, Clone)]
struct LeecherPeerEntry {
#[allow(dead_code)]
identity: crate::engine::choking_algorithm::PeerIdentity,
index: usize,
download_speed: i64,
regular_unchoker: bool,
}
impl LeecherPeerEntry {
fn from_peer(index: usize, peer: &PeerStats) -> Self {
let now = Instant::now();
let regular_unchoker = peer.peer_interested
&& peer
.last_data_time
.is_some_and(|t| now.duration_since(t) < LEECHER_REGULAR_UNCHOKE_WINDOW);
Self {
identity: peer.into(),
index,
download_speed: peer.download_speed as i64,
regular_unchoker,
}
}
}
impl Ord for LeecherPeerEntry {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
other
.download_speed
.cmp(&self.download_speed)
.then_with(|| self.identity.cmp(&other.identity))
}
}
impl PartialOrd for LeecherPeerEntry {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl PartialEq for LeecherPeerEntry {
fn eq(&self, other: &Self) -> bool {
self.index == other.index
}
}
impl Eq for LeecherPeerEntry {}
#[derive(Debug, Clone)]
pub struct BtLeecherStateChoke {
round: u32,
last_round: Option<Instant>,
}
impl BtLeecherStateChoke {
pub fn new() -> Self {
Self {
round: 0,
last_round: None, }
}
pub fn execute_choke_by_identity(&mut self, peers: &mut [&mut PeerStats]) {
self.execute_choke(peers);
}
pub fn execute_choke(&mut self, peers: &mut [&mut PeerStats]) {
tracing::debug!("Leecher state, {} choke round started", self.round);
self.last_round = Some(Instant::now());
let mut entries: Vec<LeecherPeerEntry> = Vec::new();
for (i, peer) in peers.iter_mut().enumerate() {
if peer.is_banned {
continue;
}
peer.am_choking = true;
if peer.is_snubbed {
peer.opt_unchoking = false;
continue;
}
entries.push(LeecherPeerEntry::from_peer(i, peer));
}
if self.round == 0 {
self.planned_optimistic_unchoke(&mut entries, peers);
}
self.regular_unchoke(&mut entries, peers);
self.round = (self.round + 1) % 3;
}
fn planned_optimistic_unchoke(
&mut self,
entries: &mut [LeecherPeerEntry],
peers: &mut [&mut PeerStats],
) {
for entry in entries.iter() {
peers[entry.index].opt_unchoking = false;
}
let choked_interested: Vec<usize> = entries
.iter()
.filter(|e| peers[e.index].am_choking && peers[e.index].peer_interested)
.map(|e| e.index)
.collect();
if choked_interested.is_empty() {
return;
}
let mut rng = rand::thread_rng();
let pick = choked_interested[rng.gen_range(0..choked_interested.len())];
peers[pick].opt_unchoking = true;
tracing::debug!("POU (leecher): peer idx={}", pick);
}
fn regular_unchoke(&mut self, entries: &mut [LeecherPeerEntry], peers: &mut [&mut PeerStats]) {
entries.sort_by(|a, b| match (a.regular_unchoker, b.regular_unchoker) {
(true, false) => std::cmp::Ordering::Less,
(false, true) => std::cmp::Ordering::Greater,
_ => a.cmp(b),
});
let first_non_regular = entries
.iter()
.position(|e| !e.regular_unchoker)
.unwrap_or(entries.len());
if first_non_regular < entries.len() {
let mut rng = rand::thread_rng();
for i in (first_non_regular..entries.len()).rev() {
let range_size = i - first_non_regular;
if range_size == 0 {
break;
}
let j = first_non_regular + rng.gen_range(0..=range_size);
entries.swap(i, j);
}
}
let mut count = LEECHER_REGULAR_UNCHOKE_SLOTS as i32;
let mut fast_opt_unchoker = false;
for entry in entries.iter() {
if count <= 0 {
break;
}
let peer = &mut peers[entry.index];
if !peer.peer_interested {
count -= 1;
continue;
}
peer.am_choking = false;
peer.record_unchoke();
count -= 1;
tracing::debug!(
"RU (leecher): peer idx={}, dlspd={}",
entry.index,
entry.download_speed
);
if peer.opt_unchoking {
fast_opt_unchoker = true;
peer.opt_unchoking = false;
}
}
if fast_opt_unchoker {
for entry in entries.iter() {
if !peers[entry.index].peer_interested {
continue;
}
peers[entry.index].opt_unchoking = true;
tracing::debug!("OU (leecher): peer idx={}", entry.index);
break;
}
}
}
pub fn round(&self) -> u32 {
self.round
}
#[cfg(test)]
pub fn set_round(&mut self, round: u32) {
self.round = round;
}
pub fn last_round_time(&self) -> Option<Instant> {
self.last_round
}
pub fn should_execute(&self, interval: Duration) -> bool {
match self.last_round {
None => true,
Some(t) => t.elapsed() >= interval,
}
}
}
impl Default for BtLeecherStateChoke {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug, Clone)]
pub struct BtSeederStateChoke {
round: u32,
last_round: Option<Instant>,
base_unchoke_slots: usize,
}
impl BtSeederStateChoke {
pub fn new() -> Self {
Self {
round: 0,
last_round: None, base_unchoke_slots: 4,
}
}
pub fn with_slots(slots: usize) -> Self {
Self {
round: 0,
last_round: None,
base_unchoke_slots: slots,
}
}
pub fn execute_choke_by_identity(&mut self, peers: &mut [&mut PeerStats]) {
self.execute_choke(peers);
}
pub fn execute_choke(&mut self, peers: &mut [&mut PeerStats]) {
tracing::debug!("Seeder state, {} choke round started", self.round);
self.last_round = Some(Instant::now());
let mut entries: Vec<SeederPeerEntry> = Vec::new();
for (i, peer) in peers.iter_mut().enumerate() {
if peer.is_banned {
continue;
}
peer.am_choking = true;
if peer.peer_interested {
entries.push(SeederPeerEntry::from_peer(i, peer));
continue;
}
peer.opt_unchoking = false;
}
self.unchoke_peers(&mut entries, peers);
self.round = (self.round + 1) % 3;
}
fn unchoke_peers(&mut self, entries: &mut [SeederPeerEntry], peers: &mut [&mut PeerStats]) {
let regular_slots = if self.round == 2 {
self.base_unchoke_slots
} else {
self.base_unchoke_slots.saturating_sub(1)
};
entries.sort();
let split_point = entries.len().min(regular_slots);
for entry in entries.iter().take(split_point) {
let peer = &mut peers[entry.index];
peer.am_choking = false;
peer.record_unchoke();
tracing::debug!(
"RU (seeder): peer idx={}, ulspd={}",
entry.index,
entry.upload_speed
);
}
if self.round < 2 {
for entry in entries.iter() {
peers[entry.index].opt_unchoking = false;
}
if entries.len() > split_point {
let mut rng = rand::thread_rng();
let pick_idx = split_point + rng.gen_range(0..entries.len() - split_point);
let picked_index = entries[pick_idx].index;
peers[picked_index].opt_unchoking = true;
peers[picked_index].am_choking = false;
peers[picked_index].record_optimistic_unchoke();
tracing::debug!("POU (seeder): peer idx={}", picked_index);
}
}
}
pub fn last_round_time(&self) -> Option<Instant> {
self.last_round
}
pub fn round(&self) -> u32 {
self.round
}
#[cfg(test)]
pub fn set_round(&mut self, round: u32) {
self.round = round;
}
pub fn should_execute(&self, interval: Duration) -> bool {
match self.last_round {
None => true,
Some(t) => t.elapsed() >= interval,
}
}
}
impl Default for BtSeederStateChoke {
fn default() -> Self {
Self::new()
}
}