use std::collections::{HashMap, HashSet};
use std::net::SocketAddr;
use std::path::{Path, PathBuf};
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use kdl::{KdlDocument, KdlNode};
use crate::config::ResilienceConfig;
use crate::error::{Error, Result};
use crate::integrity::{open_tracked, seal_tracked, IntegrityConfig, IntegrityManifest};
const MAX_PEER_LEDGER: usize = 4096;
const MAX_NEW_DISCOVERY_PER_CALL: usize = 32;
#[derive(Debug, Clone, Default)]
pub struct PeerRecord {
pub failures: u32,
pub successes: u32,
pub last_seen: u64,
pub last_fail: u64,
pub banned_until: u64,
}
#[derive(Debug, Default)]
pub struct PeerLedger {
peers: HashMap<SocketAddr, PeerRecord>,
}
impl PeerLedger {
pub fn load(records: impl IntoIterator<Item = (SocketAddr, PeerRecord)>) -> Self {
let mut ledger = Self {
peers: records.into_iter().collect(),
};
ledger.enforce_cap();
ledger
}
fn enforce_cap(&mut self) {
while self.peers.len() > MAX_PEER_LEDGER {
let oldest = self
.peers
.iter()
.min_by_key(|(_, record)| record.last_seen)
.map(|(addr, _)| *addr);
if let Some(addr) = oldest {
self.peers.remove(&addr);
} else {
break;
}
}
}
pub fn record_success(&mut self, addr: SocketAddr) {
let now = unix_now();
let entry = self.peers.entry(addr).or_default();
entry.failures = 0;
entry.successes = entry.successes.saturating_add(1);
entry.last_seen = now;
entry.banned_until = 0;
self.enforce_cap();
}
pub fn record_failure(&mut self, addr: SocketAddr, cfg: &ResilienceConfig) {
let now = unix_now();
let entry = self.peers.entry(addr).or_default();
entry.failures = entry.failures.saturating_add(1);
entry.last_fail = now;
entry.last_seen = now;
if entry.failures >= cfg.max_peer_failures {
entry.banned_until = now.saturating_add(cfg.peer_ban_secs);
}
self.enforce_cap();
}
pub fn ban_now(&mut self, addr: SocketAddr, cfg: &ResilienceConfig) {
let now = unix_now();
let entry = self.peers.entry(addr).or_default();
entry.failures = cfg.max_peer_failures.max(1);
entry.last_fail = now;
entry.last_seen = now;
entry.banned_until = now.saturating_add(cfg.peer_ban_secs);
self.enforce_cap();
}
pub fn is_available(&self, addr: SocketAddr, _cfg: &ResilienceConfig) -> bool {
let Some(record) = self.peers.get(&addr) else {
return true;
};
let now = unix_now();
record.banned_until == 0 || now >= record.banned_until
}
pub fn prune_expired_bans(&mut self, cfg: &ResilienceConfig) {
let now = unix_now();
for record in self.peers.values_mut() {
if record.banned_until != 0 && now >= record.banned_until {
record.banned_until = 0;
record.failures = record.failures.min(cfg.max_peer_failures.saturating_sub(1));
}
}
}
pub fn reconnect_candidates(&self, active: &HashSet<SocketAddr>) -> Vec<SocketAddr> {
let mut candidates: Vec<_> = self
.peers
.iter()
.filter(|(addr, _)| !active.contains(addr))
.map(|(addr, record)| (*addr, record.successes, record.failures, record.last_seen))
.collect();
candidates.sort_by(|a, b| {
b.1.cmp(&a.1)
.then(a.2.cmp(&b.2))
.then(b.3.cmp(&a.3))
});
candidates
.into_iter()
.map(|(addr, _, _, _)| addr)
.collect()
}
pub fn iter(&self) -> impl Iterator<Item = (&SocketAddr, &PeerRecord)> {
self.peers.iter()
}
pub fn note_discovered(&mut self, addrs: &[SocketAddr]) -> usize {
self.note_discovered_capped(addrs, MAX_NEW_DISCOVERY_PER_CALL)
}
pub fn note_discovered_capped(&mut self, addrs: &[SocketAddr], max_new: usize) -> usize {
let now = unix_now();
let mut added = 0usize;
for addr in addrs {
if let Some(existing) = self.peers.get_mut(addr) {
existing.last_seen = now;
continue;
}
if added >= max_new {
break;
}
self.peers.insert(
*addr,
PeerRecord {
last_seen: now,
..PeerRecord::default()
},
);
added = added.saturating_add(1);
}
self.enforce_cap();
added
}
}
#[derive(Debug, Clone, Default)]
pub struct ResumeCheckpoint {
pub info_hash_hex: String,
pub bytes_downloaded: u64,
pub completed_pieces: HashSet<u32>,
pub peers: HashMap<SocketAddr, PeerRecord>,
pub saved_at: u64,
}
impl ResumeCheckpoint {
pub fn path_for(root: &Path) -> PathBuf {
IntegrityManifest::sidecar_dir(root).join("resume.kdl")
}
pub fn to_kdl(&self) -> String {
let mut lines = vec![
format!("info-hash \"{}\"", self.info_hash_hex),
format!("bytes-downloaded {}", self.bytes_downloaded),
format!("saved-at {}", self.saved_at),
"completed-pieces {".into(),
];
let mut pieces: Vec<_> = self.completed_pieces.iter().copied().collect();
pieces.sort_unstable();
for piece in pieces {
lines.push(format!(" piece {piece}"));
}
lines.push("}".into());
lines.push("known-peers {".into());
for (addr, record) in &self.peers {
lines.push(format!(
" peer addr=\"{addr}\" failures={} successes={} last-seen={} last-fail={} banned-until={}",
record.failures,
record.successes,
record.last_seen,
record.last_fail,
record.banned_until
));
}
lines.push("}".into());
lines.join("\n")
}
pub fn from_kdl(input: &str) -> Result<Self> {
let doc = input
.parse::<KdlDocument>()
.map_err(|err| Error::Store(format!("resume parse: {err}")))?;
let info_hash_hex = doc
.get("info-hash")
.and_then(|node| node.entries().first())
.and_then(|entry| entry.value().as_string())
.ok_or_else(|| Error::Store("resume missing info-hash".into()))?
.to_string();
let bytes_downloaded = doc
.get("bytes-downloaded")
.and_then(|node| node.entries().first())
.and_then(|entry| entry.value().as_integer())
.unwrap_or(0) as u64;
let saved_at = doc
.get("saved-at")
.and_then(|node| node.entries().first())
.and_then(|entry| entry.value().as_integer())
.unwrap_or(0) as u64;
let mut completed_pieces = HashSet::new();
if let Some(node) = doc.get("completed-pieces").and_then(|n| n.children()) {
for entry in node.nodes() {
if entry.name().value() == "piece" {
if let Some(index) = entry.entries().first().and_then(|e| e.value().as_integer())
{
completed_pieces.insert(u32_from_kdl(index, "piece")?);
}
}
}
}
let mut peers = HashMap::new();
if let Some(node) = doc.get("known-peers").and_then(|n| n.children()) {
for entry in node.nodes() {
if entry.name().value() != "peer" {
continue;
}
let addr = entry
.get("addr")
.and_then(|v| v.as_string())
.ok_or_else(|| Error::Store("peer entry missing addr".into()))?
.parse::<SocketAddr>()
.map_err(|err| Error::Store(format!("peer addr parse: {err}")))?;
peers.insert(
addr,
PeerRecord {
failures: prop_u32(entry, "failures")?,
successes: prop_u32(entry, "successes")?,
last_seen: prop_u64(entry, "last-seen")?,
last_fail: prop_u64(entry, "last-fail")?,
banned_until: prop_u64(entry, "banned-until")?,
},
);
}
}
Ok(Self {
info_hash_hex,
bytes_downloaded,
completed_pieces,
peers,
saved_at,
})
}
pub async fn load_under_root(root: &Path, config: &IntegrityConfig) -> Result<Self> {
let relative = Path::new(".torrentdht").join("resume.kdl");
let stored = match crate::security::read_bytes_under_root_async(root, &relative).await {
Ok(bytes) => bytes,
Err(Error::Io(err)) if err.kind() == std::io::ErrorKind::NotFound => {
return Ok(Self::default());
}
Err(err) => return Err(err),
};
let context = format!("resume:{}", relative.display());
let plain = open_tracked(config, &stored, &context)?;
Self::from_kdl(std::str::from_utf8(&plain).map_err(|_| Error::Store("resume utf-8".into()))?)
}
pub async fn save_under_root(&self, root: &Path, config: &IntegrityConfig) -> Result<()> {
let relative = Path::new(".torrentdht").join("resume.kdl");
let kdl = self.to_kdl();
let context = format!("resume:{}", relative.display());
let sealed = seal_tracked(config, kdl.as_bytes(), &context)?;
crate::security::write_bytes_under_root_async(root, &relative, sealed).await
}
pub async fn load(path: &Path, config: &IntegrityConfig) -> Result<Self> {
let root = path
.parent()
.and_then(|p| p.parent())
.ok_or_else(|| Error::Store("resume path missing download root".into()))?;
Self::load_under_root(root, config).await
}
pub async fn save(&self, path: &Path, config: &IntegrityConfig) -> Result<()> {
let root = path
.parent()
.and_then(|p| p.parent())
.ok_or_else(|| Error::Store("resume path missing download root".into()))?;
self.save_under_root(root, config).await
}
}
pub fn unix_now() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or(Duration::ZERO)
.as_secs()
}
fn prop_u32(node: &KdlNode, key: &str) -> Result<u32> {
let value = node
.get(key)
.and_then(|value| value.as_integer())
.unwrap_or(0);
u32_from_kdl(value, key)
}
fn prop_u64(node: &KdlNode, key: &str) -> Result<u64> {
let value = node
.get(key)
.and_then(|value| value.as_integer())
.unwrap_or(0);
if value < 0 {
return Err(Error::Store(format!("{key} must be non-negative")));
}
Ok(value as u64)
}
fn u32_from_kdl(value: i128, field: &str) -> Result<u32> {
if !(0..=u32::MAX as i128).contains(&value) {
return Err(Error::Store(format!("{field} out of range")));
}
Ok(value as u32)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn peer_ledger_bans_after_failures() {
let cfg = ResilienceConfig {
max_peer_failures: 2,
peer_ban_secs: 60,
..ResilienceConfig::default()
};
let addr: SocketAddr = "127.0.0.1:6882".parse().expect("addr");
let mut ledger = PeerLedger::default();
ledger.record_failure(addr, &cfg);
assert!(ledger.is_available(addr, &cfg));
ledger.record_failure(addr, &cfg);
assert!(!ledger.is_available(addr, &cfg));
ledger.record_success(addr);
assert!(ledger.is_available(addr, &cfg));
}
#[test]
fn resume_checkpoint_roundtrip() {
let mut checkpoint = ResumeCheckpoint {
info_hash_hex: "abc".into(),
bytes_downloaded: 42,
completed_pieces: [0, 2].into_iter().collect(),
saved_at: 1,
..ResumeCheckpoint::default()
};
let addr: SocketAddr = "10.0.0.1:6881".parse().expect("addr");
checkpoint.peers.insert(
addr,
PeerRecord {
failures: 1,
last_seen: 99,
..PeerRecord::default()
},
);
let parsed = ResumeCheckpoint::from_kdl(&checkpoint.to_kdl()).expect("parse");
assert_eq!(parsed.completed_pieces, checkpoint.completed_pieces);
assert_eq!(parsed.bytes_downloaded, 42);
assert_eq!(parsed.peers.get(&addr).map(|r| r.failures), Some(1));
}
}