use std::time::{Duration, Instant};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RequestSlot {
pub index: u32,
pub begin: u32,
pub length: u32,
pub block_index: u32,
pub cuid: u64,
pub dispatched_at: Instant,
}
impl RequestSlot {
pub fn new(index: u32, begin: u32, length: u32, block_size: u32) -> Self {
let block_index = begin.checked_div(block_size).unwrap_or(0);
Self {
index,
begin,
length,
block_index,
cuid: 0,
dispatched_at: Instant::now(),
}
}
pub fn with_cuid(index: u32, begin: u32, length: u32, block_size: u32, cuid: u64) -> Self {
let mut slot = Self::new(index, begin, length, block_size);
slot.cuid = cuid;
slot
}
pub fn is_timed_out(&self, timeout: Duration) -> bool {
self.dispatched_at.elapsed() > timeout
}
pub fn matches(&self, index: u32, begin: u32, length: u32) -> bool {
self.index == index && self.begin == begin && self.length == length
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum InactiveReason {
MutualUninterested,
NoDataExchange,
SeederToSeeder,
}
impl std::fmt::Display for InactiveReason {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
InactiveReason::MutualUninterested => write!(f, "mutual_uninterested"),
InactiveReason::NoDataExchange => write!(f, "no_data_exchange"),
InactiveReason::SeederToSeeder => write!(f, "seeder_to_seeder"),
}
}
}
#[derive(Debug, Clone)]
pub struct FloodingStat {
choke_unchoke_count: u32,
keepalive_count: u32,
pub(crate) last_reset: Instant,
check_interval: Duration,
choke_unchoke_threshold: u32,
keepalive_threshold: u32,
}
impl FloodingStat {
pub fn new() -> Self {
Self {
choke_unchoke_count: 0,
keepalive_count: 0,
last_reset: Instant::now(),
check_interval: Duration::from_secs(5),
choke_unchoke_threshold: 2,
keepalive_threshold: 2,
}
}
pub fn inc_choke_unchoke_count(&mut self) {
self.choke_unchoke_count += 1;
}
pub fn inc_keepalive_count(&mut self) {
self.keepalive_count += 1;
}
pub fn check_and_reset(&mut self) -> bool {
if self.last_reset.elapsed() >= self.check_interval {
let flooding = self.choke_unchoke_count >= self.choke_unchoke_threshold
|| self.keepalive_count >= self.keepalive_threshold;
self.reset();
flooding
} else {
false
}
}
pub fn reset(&mut self) {
self.choke_unchoke_count = 0;
self.keepalive_count = 0;
self.last_reset = Instant::now();
}
pub fn choke_unchoke_count(&self) -> u32 {
self.choke_unchoke_count
}
pub fn keepalive_count(&self) -> u32 {
self.keepalive_count
}
}
impl Default for FloodingStat {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug, Clone)]
pub struct ActiveInteractionChecker {
inactive_since: Instant,
mutual_uninterested_timeout: Duration,
inactivity_timeout: Duration,
last_data_exchange: Instant,
}
impl ActiveInteractionChecker {
pub fn new() -> Self {
Self {
inactive_since: Instant::now(),
mutual_uninterested_timeout: Duration::from_secs(30),
inactivity_timeout: Duration::from_secs(60),
last_data_exchange: Instant::now(),
}
}
pub fn check(
&self,
am_interested: bool,
peer_interested: bool,
is_seeder: bool,
peer_is_seeder: bool,
) -> Option<InactiveReason> {
let elapsed = self.inactive_since.elapsed();
if is_seeder && peer_is_seeder {
return Some(InactiveReason::SeederToSeeder);
}
if !am_interested && !peer_interested && elapsed >= self.mutual_uninterested_timeout {
return Some(InactiveReason::MutualUninterested);
}
if elapsed >= self.inactivity_timeout {
return Some(InactiveReason::NoDataExchange);
}
None
}
pub fn reset_timer(&mut self) {
self.inactive_since = Instant::now();
}
pub fn record_data_exchange(&mut self) {
self.last_data_exchange = Instant::now();
}
}
impl Default for ActiveInteractionChecker {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug, Clone, Default)]
pub struct SlotCheckResult {
pub timed_out: bool,
pub cancelled_blocks: Vec<(u32, u32, u32)>,
}
#[derive(Debug)]
enum PendingMessage {
Control(Vec<u8>),
Upload {
data: Vec<u8>,
index: u32,
begin: u32,
length: u32,
},
}
#[derive(Debug)]
pub struct BtMessageDispatcher {
block_size: u32,
pub(crate) request_slots: Vec<RequestSlot>,
message_queue: Vec<PendingMessage>,
upload_speed_exceeded: bool,
group_upload_speed_exceeded: bool,
request_timeout: Duration,
}
impl BtMessageDispatcher {
pub fn new(block_size: u32) -> Self {
Self {
block_size,
request_slots: Vec::new(),
message_queue: Vec::new(),
upload_speed_exceeded: false,
group_upload_speed_exceeded: false,
request_timeout: Duration::from_secs(60),
}
}
pub fn add_request_slot(&mut self, index: u32, begin: u32, length: u32) {
let slot = RequestSlot::new(index, begin, length, self.block_size);
self.request_slots.push(slot);
}
pub fn remove_request_slot(&mut self, index: u32, begin: u32, length: u32) -> bool {
if let Some(pos) = self
.request_slots
.iter()
.position(|s| s.matches(index, begin, length))
{
self.request_slots.swap_remove(pos);
true
} else {
false
}
}
pub fn add_request_message(&mut self, data: Vec<u8>, _index: u32, _begin: u32, _length: u32) {
self.message_queue.push(PendingMessage::Control(data));
}
pub fn add_control_message(&mut self, data: Vec<u8>) {
self.message_queue.push(PendingMessage::Control(data));
}
pub fn add_upload_message(&mut self, data: Vec<u8>, index: u32, begin: u32, length: u32) {
self.message_queue.push(PendingMessage::Upload {
data,
index,
begin,
length,
});
}
pub fn do_choked_action<F>(&mut self, is_in_allowed_fast: F) -> Vec<RequestSlot>
where
F: Fn(u32) -> bool,
{
let mut removed = Vec::new();
self.request_slots.retain(|slot| {
if is_in_allowed_fast(slot.index) {
true } else {
removed.push(slot.clone());
false
}
});
removed
}
pub fn do_choking_action(&mut self) {
self.message_queue
.retain(|msg| !matches!(msg, PendingMessage::Upload { .. }));
}
pub fn do_cancel_sending_piece_action(&mut self, index: u32, begin: u32, length: u32) {
self.message_queue.retain(|msg| {
!matches!(msg, PendingMessage::Upload {
index: idx,
begin: b,
length: l,
..
} if *idx == index && *b == begin && *l == length)
});
}
pub fn do_abort_outstanding_request_action(&mut self, piece_index: u32) -> Vec<RequestSlot> {
let mut removed = Vec::new();
self.request_slots.retain(|slot| {
if slot.index == piece_index {
removed.push(slot.clone());
false
} else {
true
}
});
removed
}
pub fn check_request_slots<F>(&mut self, is_block_acquired: F) -> SlotCheckResult
where
F: Fn(u32, u32) -> bool,
{
let mut result = SlotCheckResult::default();
let timeout = self.request_timeout;
self.request_slots.retain(|slot| {
if slot.is_timed_out(timeout) {
result.timed_out = true;
return false;
}
if is_block_acquired(slot.index, slot.block_index) {
result
.cancelled_blocks
.push((slot.index, slot.begin, slot.length));
return false;
}
true
});
result
}
pub fn count_request_slots(&self) -> usize {
self.request_slots.len()
}
pub fn has_outstanding_requests(&self) -> bool {
!self.request_slots.is_empty()
}
pub fn is_outstanding_request(&self, index: u32, block_index: u32) -> bool {
self.request_slots
.iter()
.any(|s| s.index == index && s.block_index == block_index)
}
pub fn drain_sendable_messages(&mut self) -> Vec<Vec<u8>> {
let mut sendable = Vec::new();
let mut deferred = Vec::new();
let upload_limited = self.is_upload_limited();
for msg in self.message_queue.drain(..) {
match msg {
PendingMessage::Control(data) => {
sendable.push(data);
}
PendingMessage::Upload {
data,
index,
begin,
length,
} => {
if upload_limited {
deferred.push(PendingMessage::Upload {
data,
index,
begin,
length,
});
} else {
sendable.push(data);
}
}
}
}
if !deferred.is_empty() {
deferred.append(&mut self.message_queue);
self.message_queue = deferred;
}
sendable
}
pub fn has_pending_messages(&self) -> bool {
!self.message_queue.is_empty()
}
pub fn count_messages(&self) -> usize {
self.message_queue.len()
}
pub fn set_upload_speed_exceeded(&mut self, exceeded: bool) {
self.upload_speed_exceeded = exceeded;
}
pub fn set_group_upload_speed_exceeded(&mut self, exceeded: bool) {
self.group_upload_speed_exceeded = exceeded;
}
pub fn is_upload_limited(&self) -> bool {
self.upload_speed_exceeded || self.group_upload_speed_exceeded
}
pub fn clear(&mut self) {
self.request_slots.clear();
self.message_queue.clear();
self.upload_speed_exceeded = false;
self.group_upload_speed_exceeded = false;
}
}