use std::collections::{HashSet, VecDeque};
use std::net::SocketAddr;
use std::sync::Arc;
use tokio::sync::{mpsc, RwLock};
const MAX_WAITING: usize = 1024;
pub struct UploadSlotManager {
max_slots: usize,
unchoked: RwLock<HashSet<SocketAddr>>,
waiting: RwLock<VecDeque<SocketAddr>>,
signals: RwLock<std::collections::HashMap<SocketAddr, mpsc::UnboundedSender<bool>>>,
}
impl UploadSlotManager {
pub fn new(max_slots: usize) -> Self {
Self {
max_slots: max_slots.max(1),
unchoked: RwLock::new(HashSet::new()),
waiting: RwLock::new(VecDeque::new()),
signals: RwLock::new(std::collections::HashMap::new()),
}
}
pub async fn register(&self, addr: SocketAddr, signal: mpsc::UnboundedSender<bool>) {
self.signals.write().await.insert(addr, signal);
}
pub async fn unregister(&self, addr: SocketAddr) {
self.signals.write().await.remove(&addr);
let was_unchoked = self.unchoked.write().await.remove(&addr);
self.waiting.write().await.retain(|peer| *peer != addr);
if was_unchoked {
self.promote_waiters().await;
}
}
pub async fn on_interested(&self, addr: SocketAddr) {
if self.unchoked.read().await.contains(&addr) {
return;
}
{
let waiting = self.waiting.read().await;
if waiting.contains(&addr) {
return;
}
}
if self.unchoked.read().await.len() < self.max_slots {
self.grant(addr).await;
} else {
let mut waiting = self.waiting.write().await;
if waiting.len() >= MAX_WAITING {
return;
}
waiting.push_back(addr);
}
}
pub async fn on_not_interested(&self, addr: SocketAddr) {
self.waiting.write().await.retain(|peer| *peer != addr);
if self.unchoked.write().await.remove(&addr) {
self.send(addr, false).await;
self.promote_waiters().await;
}
}
pub async fn rotate(&self) {
let victim = {
let waiting = self.waiting.read().await;
if waiting.is_empty() {
return;
}
let unchoked = self.unchoked.read().await;
if unchoked.len() < self.max_slots {
return;
}
unchoked.iter().copied().next()
};
let Some(victim) = victim else {
return;
};
self.unchoked.write().await.remove(&victim);
{
let mut waiting = self.waiting.write().await;
if !waiting.contains(&victim) && waiting.len() < MAX_WAITING {
waiting.push_back(victim);
}
}
self.send(victim, false).await;
self.promote_waiters().await;
}
pub fn spawn_rotator(self: &Arc<Self>, interval_secs: u64) -> Option<tokio::task::JoinHandle<()>> {
if interval_secs == 0 {
return None;
}
let slots = Arc::clone(self);
let interval = std::time::Duration::from_secs(interval_secs.max(1));
Some(tokio::spawn(async move {
let mut tick = tokio::time::interval(interval);
tick.tick().await;
loop {
tick.tick().await;
slots.rotate().await;
}
}))
}
pub async fn is_unchoked(&self, addr: SocketAddr) -> bool {
self.unchoked.read().await.contains(&addr)
}
async fn grant(&self, addr: SocketAddr) {
{
let mut unchoked = self.unchoked.write().await;
if unchoked.len() >= self.max_slots {
drop(unchoked);
let mut waiting = self.waiting.write().await;
if !waiting.contains(&addr) && waiting.len() < MAX_WAITING {
waiting.push_back(addr);
}
return;
}
unchoked.insert(addr);
}
self.send(addr, true).await;
}
async fn send(&self, addr: SocketAddr, unchoke: bool) {
if let Some(tx) = self.signals.read().await.get(&addr) {
let _ = tx.send(unchoke);
}
}
async fn promote_waiters(&self) {
loop {
if self.unchoked.read().await.len() >= self.max_slots {
break;
}
let next = self.waiting.write().await.pop_front();
let Some(addr) = next else {
break;
};
self.grant(addr).await;
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use tokio::sync::mpsc;
#[tokio::test]
async fn grants_up_to_max_slots() {
let slots = UploadSlotManager::new(2);
let (tx_a, mut rx_a) = mpsc::unbounded_channel();
let (tx_b, mut rx_b) = mpsc::unbounded_channel();
let (tx_c, mut rx_c) = mpsc::unbounded_channel();
let a: SocketAddr = "127.0.0.1:6001".parse().expect("addr");
let b: SocketAddr = "127.0.0.1:6002".parse().expect("addr");
let c: SocketAddr = "127.0.0.1:6003".parse().expect("addr");
slots.register(a, tx_a).await;
slots.register(b, tx_b).await;
slots.register(c, tx_c).await;
slots.on_interested(a).await;
slots.on_interested(b).await;
slots.on_interested(c).await;
assert!(slots.is_unchoked(a).await);
assert!(slots.is_unchoked(b).await);
assert!(!slots.is_unchoked(c).await);
assert_eq!(rx_a.recv().await, Some(true));
assert_eq!(rx_b.recv().await, Some(true));
assert!(rx_c.try_recv().is_err());
slots.on_not_interested(a).await;
assert!(slots.is_unchoked(c).await);
assert_eq!(rx_c.recv().await, Some(true));
}
#[tokio::test]
async fn rotate_promotes_waiting_peer() {
let slots = UploadSlotManager::new(1);
let (tx_a, mut rx_a) = mpsc::unbounded_channel();
let (tx_b, mut rx_b) = mpsc::unbounded_channel();
let a: SocketAddr = "127.0.0.1:6011".parse().expect("addr");
let b: SocketAddr = "127.0.0.1:6012".parse().expect("addr");
slots.register(a, tx_a).await;
slots.register(b, tx_b).await;
slots.on_interested(a).await;
slots.on_interested(b).await;
assert!(slots.is_unchoked(a).await);
assert!(!slots.is_unchoked(b).await);
assert_eq!(rx_a.recv().await, Some(true));
slots.rotate().await;
assert!(!slots.is_unchoked(a).await);
assert!(slots.is_unchoked(b).await);
assert_eq!(rx_a.recv().await, Some(false));
assert_eq!(rx_b.recv().await, Some(true));
}
}