use std::collections::{HashSet, VecDeque};
#[cfg(test)]
#[path = "tests/announce_list.rs"]
mod tests;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AnnounceEvent {
Started,
StartedAfterCompletion,
Downloading,
Stopped,
Completed,
Seeding,
Halted,
}
impl AnnounceEvent {
pub fn next_event(self) -> Self {
match self {
Self::Started => Self::Downloading,
Self::StartedAfterCompletion => Self::Seeding,
Self::Stopped => Self::Halted,
Self::Completed => Self::Seeding,
other => other,
}
}
pub fn next_event_if_after_started(self) -> Self {
match self {
Self::Stopped => Self::Halted,
Self::Completed => Self::Seeding,
other => other,
}
}
pub fn accepts_stopped_event(self) -> bool {
matches!(
self,
Self::Downloading | Self::Stopped | Self::Completed | Self::Seeding
)
}
pub fn accepts_completed_event(self) -> bool {
matches!(self, Self::Downloading | Self::Completed)
}
pub fn as_event_string(self) -> &'static str {
match self {
Self::Started | Self::StartedAfterCompletion => "started",
Self::Stopped => "stopped",
Self::Completed => "completed",
Self::Downloading | Self::Seeding | Self::Halted => "",
}
}
}
impl From<AnnounceEvent> for super::udp_tracker_protocol::UdpEvent {
fn from(event: AnnounceEvent) -> Self {
match event {
AnnounceEvent::Started | AnnounceEvent::StartedAfterCompletion => Self::Started,
AnnounceEvent::Completed => Self::Completed,
AnnounceEvent::Stopped => Self::Stopped,
AnnounceEvent::Downloading | AnnounceEvent::Seeding | AnnounceEvent::Halted => {
Self::None
}
}
}
}
#[derive(Debug, Clone)]
pub struct AnnounceTier {
pub event: AnnounceEvent,
pub urls: VecDeque<String>,
}
impl AnnounceTier {
pub fn new(urls: VecDeque<String>) -> Self {
Self {
event: AnnounceEvent::Started,
urls,
}
}
pub fn from_urls(urls: Vec<String>) -> Self {
Self {
event: AnnounceEvent::Started,
urls: urls.into_iter().collect(),
}
}
pub fn next_event(&mut self) {
self.event = self.event.next_event();
}
pub fn next_event_if_after_started(&mut self) {
self.event = self.event.next_event_if_after_started();
}
pub fn accepts_stopped_event(&self) -> bool {
self.event.accepts_stopped_event()
}
pub fn accepts_completed_event(&self) -> bool {
self.event.accepts_completed_event()
}
}
#[derive(Debug, Clone)]
pub struct AnnounceList {
pub(crate) tiers: Vec<AnnounceTier>,
current_tier: usize,
current_tracker: usize,
current_tracker_initialized: bool,
}
impl AnnounceList {
pub fn empty() -> Self {
Self {
tiers: Vec::new(),
current_tier: 0,
current_tracker: 0,
current_tracker_initialized: false,
}
}
pub fn new(announce_list: &[Vec<String>], announce: &Option<String>) -> Self {
let mut tiers = Vec::new();
if !announce_list.is_empty() {
for tier_urls in announce_list {
if tier_urls.is_empty() {
continue;
}
tiers.push(AnnounceTier::from_urls(tier_urls.clone()));
}
} else if let Some(url) = announce {
let mut urls = VecDeque::new();
urls.push_back(url.clone());
tiers.push(AnnounceTier::new(urls));
}
let mut list = Self {
tiers,
current_tier: 0,
current_tracker: 0,
current_tracker_initialized: false,
};
list.reset_iterator();
list
}
fn reset_iterator(&mut self) {
self.current_tier = 0;
if !self.tiers.is_empty() && !self.tiers[0].urls.is_empty() {
self.current_tracker = 0;
self.current_tracker_initialized = true;
} else {
self.current_tracker_initialized = false;
}
}
pub fn get_announce(&self) -> Option<&str> {
if self.current_tracker_initialized {
self.tiers
.get(self.current_tier)
.and_then(|t| t.urls.get(self.current_tracker))
.map(|s| s.as_str())
} else {
None
}
}
pub fn get_event(&self) -> AnnounceEvent {
if self.current_tracker_initialized {
self.tiers
.get(self.current_tier)
.map(|t| t.event)
.unwrap_or(AnnounceEvent::Started)
} else {
AnnounceEvent::Started
}
}
pub fn set_event(&mut self, event: AnnounceEvent) {
if self.current_tracker_initialized
&& let Some(tier) = self.tiers.get_mut(self.current_tier)
{
tier.event = event;
}
}
pub fn get_event_string(&self) -> &'static str {
if self.current_tracker_initialized {
self.tiers
.get(self.current_tier)
.map(|t| t.event.as_event_string())
.unwrap_or("")
} else {
""
}
}
pub fn announce_success(&mut self) {
if !self.current_tracker_initialized {
return;
}
if let Some(tier) = self.tiers.get_mut(self.current_tier) {
tier.next_event();
if self.current_tracker < tier.urls.len() {
let url = tier.urls.remove(self.current_tracker).unwrap();
tier.urls.push_front(url);
}
}
self.current_tier = 0;
if !self.tiers.is_empty() && !self.tiers[0].urls.is_empty() {
self.current_tracker = 0;
self.current_tracker_initialized = true;
} else {
self.current_tracker_initialized = false;
}
}
pub fn announce_failure(&mut self) {
if !self.current_tracker_initialized {
return;
}
if let Some(tier) = self.tiers.get(self.current_tier) {
self.current_tracker += 1;
if self.current_tracker >= tier.urls.len() {
if let Some(tier) = self.tiers.get_mut(self.current_tier) {
tier.next_event_if_after_started();
}
self.current_tier += 1;
if self.current_tier >= self.tiers.len() {
self.current_tracker_initialized = false;
} else {
self.current_tracker = 0;
}
}
}
}
pub fn count_stopped_allowed_tier(&self) -> usize {
self.tiers
.iter()
.filter(|t| t.accepts_stopped_event())
.count()
}
pub fn count_completed_allowed_tier(&self) -> usize {
self.tiers
.iter()
.filter(|t| t.accepts_completed_event())
.count()
}
pub fn move_to_stopped_allowed_tier(&mut self) {
let start = self.current_tier.min(self.tiers.len());
for i in start..self.tiers.len() {
if self.tiers[i].accepts_stopped_event() {
self.current_tier = i;
self.current_tracker = 0;
self.current_tracker_initialized = true;
return;
}
}
for i in 0..start {
if self.tiers[i].accepts_stopped_event() {
self.current_tier = i;
self.current_tracker = 0;
self.current_tracker_initialized = true;
return;
}
}
}
pub fn move_to_completed_allowed_tier(&mut self) {
let start = self.current_tier.min(self.tiers.len());
for i in start..self.tiers.len() {
if self.tiers[i].accepts_completed_event() {
self.current_tier = i;
self.current_tracker = 0;
self.current_tracker_initialized = true;
return;
}
}
for i in 0..start {
if self.tiers[i].accepts_completed_event() {
self.current_tier = i;
self.current_tracker = 0;
self.current_tracker_initialized = true;
return;
}
}
}
pub fn current_tier_accepts_stopped_event(&self) -> bool {
if self.current_tracker_initialized {
self.tiers
.get(self.current_tier)
.map(|t| t.accepts_stopped_event())
.unwrap_or(false)
} else {
false
}
}
pub fn current_tier_accepts_completed_event(&self) -> bool {
if self.current_tracker_initialized {
self.tiers
.get(self.current_tier)
.map(|t| t.accepts_completed_event())
.unwrap_or(false)
} else {
false
}
}
pub fn all_tiers_failed(&self) -> bool {
self.current_tier >= self.tiers.len()
}
pub fn reset_tier(&mut self) {
self.reset_iterator();
}
pub fn shuffle(&mut self) {
use rand::seq::SliceRandom;
let mut rng = rand::rng();
for tier in &mut self.tiers {
let mut urls: Vec<String> = tier.urls.drain(..).collect();
urls.shuffle(&mut rng);
tier.urls = urls.into_iter().collect();
}
}
pub fn tier_count(&self) -> usize {
self.tiers.len()
}
pub fn get_tracker_url(&self, tier_idx: usize, entry_idx: usize) -> Option<&String> {
self.tiers.get(tier_idx).and_then(|t| t.urls.get(entry_idx))
}
pub fn contains_url(&self, url: &str) -> bool {
self.tiers
.iter()
.any(|tier| tier.urls.iter().any(|candidate| candidate == url))
}
pub fn reconfigure(&mut self, announce_list: &[Vec<String>]) {
self.tiers.clear();
for tier_urls in announce_list {
if tier_urls.is_empty() {
continue;
}
self.tiers.push(AnnounceTier::from_urls(tier_urls.clone()));
}
self.reset_iterator();
}
pub fn reconfigure_from_url(&mut self, url: &str) {
let mut urls = VecDeque::new();
urls.push_back(url.to_string());
self.tiers.push(AnnounceTier::new(urls));
self.reset_iterator();
}
pub fn append_tiers(&mut self, tiers: &[Vec<String>]) -> Vec<String> {
let was_exhausted =
!self.current_tracker_initialized || self.current_tier >= self.tiers.len();
let mut existing = self
.tiers
.iter()
.flat_map(|tier| tier.urls.iter().cloned())
.collect::<HashSet<_>>();
let mut added = Vec::new();
let first_added_tier = self.tiers.len();
for tier_urls in tiers {
let unique_urls = tier_urls
.iter()
.filter(|url| !url.is_empty() && existing.insert((*url).clone()))
.cloned()
.collect::<Vec<_>>();
if unique_urls.is_empty() {
continue;
}
added.extend(unique_urls.iter().cloned());
self.tiers.push(AnnounceTier::from_urls(unique_urls));
}
if !added.is_empty() && was_exhausted {
self.current_tier = first_added_tier;
self.current_tracker = 0;
self.current_tracker_initialized = true;
}
added
}
}