torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
use std::collections::{HashSet, VecDeque};
use std::net::SocketAddr;
use std::sync::Arc;

use tokio::sync::{mpsc, RwLock};

/// Cap waiting interested peers to bound memory under flood.
const MAX_WAITING: usize = 1024;

/// Limits concurrent upload (unchoked) peers per swarm.
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;
        }
    }

    /// Optimistic unchoke: rotate one slot to a waiting peer when all slots are full.
    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;
            // Re-check under lock to avoid exceeding max_slots (TOCTOU).
            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));
    }
}