use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
use dashmap::DashMap;
use crate::engines::provider::{ProxyCategory, ProxyProvider};
use crate::utils::proxy::redact_proxy_url;
const MAX_STICKY_BINDINGS: usize = 10_000;
pub struct ProxyEntry {
pub url: String,
healthy: AtomicBool,
cooldown_until: AtomicU64,
pub category: ProxyCategory,
}
impl std::fmt::Debug for ProxyEntry {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ProxyEntry")
.field("url", &redact_proxy_url(&self.url))
.field("healthy", &self.healthy.load(Ordering::Acquire))
.field(
"cooldown_until",
&self.cooldown_until.load(Ordering::Acquire),
)
.field("category", &self.category)
.finish()
}
}
impl ProxyEntry {
#[must_use]
pub fn new(url: String, category: ProxyCategory) -> Self {
Self {
url,
healthy: AtomicBool::new(true),
cooldown_until: AtomicU64::new(0),
category,
}
}
pub fn is_available(&self) -> bool {
let until = self.cooldown_until.load(Ordering::Acquire);
if until == 0 {
return self.healthy.load(Ordering::Acquire);
}
now_ms() >= until
}
pub fn mark_failure(&self, cooldown: Duration) {
let until = now_ms().saturating_add(cooldown.as_millis() as u64);
self.cooldown_until.store(until, Ordering::Release);
self.healthy.store(false, Ordering::Release);
}
pub fn mark_success(&self) {
self.cooldown_until.store(0, Ordering::Release);
self.healthy.store(true, Ordering::Release);
}
}
struct StickyBinding {
entry_idx: usize,
expires_at: Instant,
}
pub struct ProxyPool {
entries: Vec<Arc<ProxyEntry>>,
rr: AtomicUsize,
sticky: DashMap<String, StickyBinding>,
sticky_ttl: Duration,
default_cooldown: Duration,
sticky_max_capacity: usize,
last_cleanup_millis: AtomicU64,
}
impl ProxyPool {
#[must_use]
pub fn new(entries: Vec<ProxyEntry>, sticky_ttl: Duration, default_cooldown: Duration) -> Self {
let entries: Vec<Arc<ProxyEntry>> = entries.into_iter().map(Arc::new).collect();
let sticky_max_capacity = MAX_STICKY_BINDINGS;
Self {
entries,
rr: AtomicUsize::new(0),
sticky: DashMap::with_capacity(sticky_max_capacity),
sticky_ttl,
default_cooldown,
sticky_max_capacity,
last_cleanup_millis: AtomicU64::new(0),
}
}
#[must_use]
pub fn with_sticky_max_capacity(mut self, capacity: usize) -> Self {
self.sticky_max_capacity = capacity.max(1);
self
}
#[must_use]
pub fn from_urls(urls: Vec<String>, sticky_ttl: Duration, default_cooldown: Duration) -> Self {
let entries: Vec<ProxyEntry> = urls
.into_iter()
.map(|url| ProxyEntry::new(url, ProxyCategory::Html))
.collect();
Self::new(entries, sticky_ttl, default_cooldown)
}
pub fn next(&self, category: ProxyCategory) -> Option<String> {
let idx = self.rr_pick(category)?;
Some(self.entries[idx].url.clone())
}
pub fn sticky(&self, session_id: &str) -> Option<String> {
use dashmap::mapref::entry::Entry;
if let Some(binding) = self.sticky.get(session_id) {
if binding.expires_at > Instant::now() && self.entries[binding.entry_idx].is_available()
{
return Some(self.entries[binding.entry_idx].url.clone());
}
drop(binding);
}
if self.sticky.len() >= self.sticky_max_capacity {
let now = now_ms();
let last = self.last_cleanup_millis.load(Ordering::Relaxed);
if now.saturating_sub(last) > 60_000 {
self.evict_expired_sticky();
self.last_cleanup_millis.store(now, Ordering::Relaxed);
}
}
let at_capacity = self.sticky.len() >= self.sticky_max_capacity;
match self.sticky.entry(session_id.to_string()) {
Entry::Occupied(mut occ) => {
let binding = occ.get();
if binding.expires_at > Instant::now()
&& self.entries[binding.entry_idx].is_available()
{
return Some(self.entries[binding.entry_idx].url.clone());
}
let idx = self.rr_pick(ProxyCategory::Html)?;
occ.insert(StickyBinding {
entry_idx: idx,
expires_at: Instant::now() + self.sticky_ttl,
});
Some(self.entries[idx].url.clone())
}
Entry::Vacant(vac) => {
let idx = self.rr_pick(ProxyCategory::Html)?;
if !at_capacity {
vac.insert(StickyBinding {
entry_idx: idx,
expires_at: Instant::now() + self.sticky_ttl,
});
}
Some(self.entries[idx].url.clone())
}
}
}
pub fn mark_failure(&self, url: &str) {
for entry in &self.entries {
if entry.url == url {
entry.mark_failure(self.default_cooldown);
log::warn!(
"proxy_pool: marked failure (cooldown={}s): {}",
self.default_cooldown.as_secs(),
redact_proxy_url(url)
);
return;
}
}
log::warn!(
"proxy_pool: mark_failure url not found in pool: {}",
redact_proxy_url(url)
);
}
pub fn mark_success(&self, url: &str) {
for entry in &self.entries {
if entry.url == url {
entry.mark_success();
return;
}
}
log::debug!(
"proxy_pool: mark_success url not found in pool: {}",
redact_proxy_url(url)
);
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
#[must_use]
pub fn len(&self) -> usize {
self.entries.len()
}
fn rr_pick(&self, category: ProxyCategory) -> Option<usize> {
let total = self
.entries
.iter()
.filter(|e| e.category == category && e.is_available())
.count();
if total == 0 {
return None;
}
let rr_idx = self.rr.fetch_add(1, Ordering::AcqRel);
let target = rr_idx % total;
self.entries
.iter()
.enumerate()
.filter(|(_, e)| e.category == category && e.is_available())
.nth(target)
.map(|(i, _)| i)
}
fn evict_expired_sticky(&self) {
let now = Instant::now();
self.sticky.retain(|_, binding| binding.expires_at > now);
}
}
fn now_ms() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_millis() as u64)
.unwrap_or(0)
}
impl ProxyProvider for ProxyPool {
#[inline]
fn next(&self, category: ProxyCategory) -> Option<String> {
ProxyPool::next(self, category)
}
#[inline]
fn sticky(&self, session_id: &str) -> Option<String> {
ProxyPool::sticky(self, session_id)
}
#[inline]
fn mark_failure(&self, url: &str) {
ProxyPool::mark_failure(self, url);
}
#[inline]
fn mark_success(&self, url: &str) {
ProxyPool::mark_success(self, url);
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::thread;
fn make_pool(urls: Vec<&str>) -> ProxyPool {
let entries: Vec<ProxyEntry> = urls
.into_iter()
.map(|u| ProxyEntry::new(u.to_string(), ProxyCategory::Html))
.collect();
ProxyPool::new(entries, Duration::from_secs(60), Duration::from_secs(30))
}
fn make_pool_with_ttl(urls: Vec<&str>, sticky_ttl: Duration) -> ProxyPool {
let entries: Vec<ProxyEntry> = urls
.into_iter()
.map(|u| ProxyEntry::new(u.to_string(), ProxyCategory::Html))
.collect();
ProxyPool::new(entries, sticky_ttl, Duration::from_secs(30))
}
#[test]
fn next_round_robin_cycles_through_all_proxies() {
let pool = make_pool(vec!["http://a:8080", "http://b:8080", "http://c:8080"]);
let first = pool.next(ProxyCategory::Html).unwrap();
let second = pool.next(ProxyCategory::Html).unwrap();
let third = pool.next(ProxyCategory::Html).unwrap();
let fourth = pool.next(ProxyCategory::Html).unwrap();
assert_eq!(first, "http://a:8080");
assert_eq!(second, "http://b:8080");
assert_eq!(third, "http://c:8080");
assert_eq!(fourth, "http://a:8080");
}
#[test]
fn next_skips_proxies_in_cooldown() {
let pool = make_pool(vec!["http://a:8080", "http://b:8080"]);
pool.mark_failure("http://a:8080");
let url = pool.next(ProxyCategory::Html).unwrap();
assert_eq!(url, "http://b:8080");
let url2 = pool.next(ProxyCategory::Html).unwrap();
assert_eq!(url2, "http://b:8080");
}
#[test]
fn next_returns_none_when_all_proxies_in_cooldown() {
let pool = make_pool(vec!["http://a:8080"]);
pool.mark_failure("http://a:8080");
assert_eq!(pool.next(ProxyCategory::Html), None);
}
#[test]
fn next_returns_none_for_empty_pool() {
let pool = make_pool(vec![]);
assert_eq!(pool.next(ProxyCategory::Html), None);
assert!(pool.is_empty());
assert_eq!(pool.len(), 0);
}
#[test]
fn next_filters_by_category() {
let entries = vec![
ProxyEntry::new("http://html:8080".to_string(), ProxyCategory::Html),
ProxyEntry::new("http://media:8080".to_string(), ProxyCategory::Media),
];
let pool = ProxyPool::new(entries, Duration::from_secs(60), Duration::from_secs(30));
let html_url = pool.next(ProxyCategory::Html).unwrap();
assert_eq!(html_url, "http://html:8080");
let media_url = pool.next(ProxyCategory::Media).unwrap();
assert_eq!(media_url, "http://media:8080");
}
#[test]
fn next_returns_none_when_category_has_no_proxies() {
let entries = vec![ProxyEntry::new(
"http://html:8080".to_string(),
ProxyCategory::Html,
)];
let pool = ProxyPool::new(entries, Duration::from_secs(60), Duration::from_secs(30));
assert_eq!(pool.next(ProxyCategory::Media), None);
}
#[test]
fn sticky_returns_same_url_within_ttl() {
let pool = make_pool(vec!["http://a:8080", "http://b:8080"]);
let url1 = pool.sticky("session-1").unwrap();
let url2 = pool.sticky("session-1").unwrap();
let url3 = pool.sticky("session-1").unwrap();
let url4 = pool.sticky("session-1").unwrap();
assert_eq!(
url1, url2,
"same session_id should return same url within TTL"
);
assert_eq!(url2, url3, "sticky must be stable across multiple calls");
assert_eq!(url3, url4, "sticky must be stable across multiple calls");
assert!(
url1 == "http://a:8080" || url1 == "http://b:8080",
"sticky url must be one of the pool entries"
);
}
#[test]
fn sticky_different_sessions_get_different_urls() {
let pool = make_pool(vec!["http://a:8080", "http://b:8080"]);
let url1 = pool.sticky("session-1").unwrap();
let url2 = pool.sticky("session-2").unwrap();
assert_ne!(url1, url2, "different sessions should get different urls");
}
#[test]
fn sticky_reselects_after_ttl_expiry() {
let pool = make_pool_with_ttl(
vec!["http://a:8080", "http://b:8080"],
Duration::from_millis(1),
);
let _url1 = pool.sticky("session-1").unwrap();
thread::sleep(Duration::from_millis(5));
let url2 = pool.sticky("session-1").unwrap();
assert!(
url2 == "http://a:8080" || url2 == "http://b:8080",
"reselected url should be one of the pool entries"
);
let url3 = pool.sticky("session-1").unwrap();
assert_eq!(
url2, url3,
"after reselection, sticky should be stable again within new TTL"
);
}
#[test]
fn sticky_reselects_when_binding_in_cooldown() {
let pool = make_pool(vec!["http://a:8080", "http://b:8080"]);
let url1 = pool.sticky("session-1").unwrap();
pool.mark_failure(&url1);
let url2 = pool.sticky("session-1").unwrap();
assert_ne!(
url1, url2,
"sticky should reselect when binding is in cooldown"
);
assert!(
url2 == "http://a:8080" || url2 == "http://b:8080",
"reselected url must be a valid pool entry"
);
let url3 = pool.sticky("session-1").unwrap();
assert_eq!(
url2, url3,
"sticky should be stable after reselecting from cooldown"
);
}
#[test]
fn sticky_returns_none_when_all_in_cooldown() {
let pool = make_pool(vec!["http://a:8080"]);
pool.mark_failure("http://a:8080");
assert_eq!(pool.sticky("session-1"), None);
}
#[test]
fn sticky_returns_none_for_empty_pool() {
let pool = make_pool(vec![]);
assert_eq!(pool.sticky("session-1"), None);
}
#[test]
fn mark_failure_sets_cooldown() {
let pool = make_pool(vec!["http://a:8080"]);
pool.mark_failure("http://a:8080");
assert_eq!(pool.next(ProxyCategory::Html), None);
}
#[test]
fn mark_success_restores_health() {
let pool = make_pool(vec!["http://a:8080"]);
pool.mark_failure("http://a:8080");
assert_eq!(pool.next(ProxyCategory::Html), None);
pool.mark_success("http://a:8080");
let url = pool.next(ProxyCategory::Html).unwrap();
assert_eq!(url, "http://a:8080");
}
#[test]
fn mark_failure_unknown_url_does_not_panic() {
let pool = make_pool(vec!["http://a:8080"]);
pool.mark_failure("http://unknown:8080");
let url = pool.next(ProxyCategory::Html).unwrap();
assert_eq!(url, "http://a:8080");
}
#[test]
fn mark_success_unknown_url_does_not_panic() {
let pool = make_pool(vec!["http://a:8080"]);
pool.mark_success("http://unknown:8080");
let url = pool.next(ProxyCategory::Html).unwrap();
assert_eq!(url, "http://a:8080");
}
#[test]
fn from_urls_creates_pool_with_html_category() {
let pool = ProxyPool::from_urls(
vec!["http://a:8080".to_string(), "http://b:8080".to_string()],
Duration::from_secs(60),
Duration::from_secs(30),
);
assert_eq!(pool.len(), 2);
assert!(!pool.is_empty());
let url = pool.next(ProxyCategory::Html).unwrap();
assert_eq!(url, "http://a:8080");
}
#[test]
fn len_and_is_empty_reflect_pool_state() {
let empty_pool = make_pool(vec![]);
assert!(empty_pool.is_empty());
assert_eq!(empty_pool.len(), 0);
let pool = make_pool(vec!["http://a:8080", "http://b:8080"]);
assert!(!pool.is_empty());
assert_eq!(pool.len(), 2);
}
#[test]
fn concurrent_next_does_not_panic_and_returns_valid_urls() {
let pool = std::sync::Arc::new(make_pool(vec![
"http://a:8080",
"http://b:8080",
"http://c:8080",
"http://d:8080",
]));
let threads = 8;
let calls_per_thread = 100;
let mut handles = Vec::with_capacity(threads);
for _ in 0..threads {
let pool_clone = std::sync::Arc::clone(&pool);
handles.push(thread::spawn(move || {
let mut urls = Vec::with_capacity(calls_per_thread);
for _ in 0..calls_per_thread {
if let Some(url) = pool_clone.next(ProxyCategory::Html) {
urls.push(url);
}
}
urls
}));
}
let mut total_urls = 0usize;
for handle in handles {
let urls = handle.join().expect("thread should not panic");
for url in &urls {
assert!(
url == "http://a:8080"
|| url == "http://b:8080"
|| url == "http://c:8080"
|| url == "http://d:8080",
"concurrent next() returned invalid url: {}",
url
);
}
total_urls += urls.len();
}
assert_eq!(
total_urls,
threads * calls_per_thread,
"all concurrent next() calls should return Some (no cooldown)"
);
}
#[test]
fn concurrent_mark_failure_and_next_does_not_data_race() {
let pool = std::sync::Arc::new(make_pool(vec![
"http://a:8080",
"http://b:8080",
"http://c:8080",
"http://d:8080",
]));
let valid_urls = std::sync::Arc::new(vec![
"http://a:8080".to_string(),
"http://b:8080".to_string(),
"http://c:8080".to_string(),
"http://d:8080".to_string(),
]);
let threads = 6;
let mut handles = Vec::with_capacity(threads);
for t in 0..threads {
let pool_clone = std::sync::Arc::clone(&pool);
let valid_urls_clone = std::sync::Arc::clone(&valid_urls);
handles.push(thread::spawn(move || {
for i in 0..50 {
let url = &valid_urls_clone[(t + i) % valid_urls_clone.len()];
if i % 2 == 0 {
pool_clone.mark_failure(url);
} else {
pool_clone.mark_success(url);
}
if let Some(returned) = pool_clone.next(ProxyCategory::Html) {
assert!(
valid_urls_clone.contains(&returned),
"concurrent next() returned url not in pool: {}",
returned
);
}
}
}));
}
for handle in handles {
handle
.join()
.expect("thread should not panic under concurrent access");
}
}
#[test]
fn concurrent_sticky_same_session_returns_consistent_url() {
let pool = std::sync::Arc::new(make_pool(vec![
"http://a:8080",
"http://b:8080",
"http://c:8080",
]));
let threads = 4;
let calls_per_thread = 20;
let mut handles = Vec::with_capacity(threads);
for _ in 0..threads {
let pool_clone = std::sync::Arc::clone(&pool);
handles.push(thread::spawn(move || {
let mut urls = Vec::with_capacity(calls_per_thread);
for _ in 0..calls_per_thread {
if let Some(url) = pool_clone.sticky("shared-session") {
urls.push(url);
}
}
urls
}));
}
let mut all_urls: Vec<String> = Vec::new();
for handle in handles {
let urls = handle.join().expect("sticky thread should not panic");
for url in &urls {
assert!(
url == "http://a:8080" || url == "http://b:8080" || url == "http://c:8080",
"concurrent sticky() returned invalid url: {}",
url
);
}
all_urls.extend(urls);
}
let first_url = &all_urls[0];
for url in &all_urls {
assert_eq!(
url, first_url,
"all concurrent sticky() calls with same session_id must return the same URL"
);
}
}
#[test]
fn sticky_capacity_limit_evicts_expired_entries() {
let pool = std::sync::Arc::new(
make_pool(vec!["http://a:8080", "http://b:8080"]).with_sticky_max_capacity(3),
);
pool.sticky("session-1").unwrap();
pool.sticky("session-2").unwrap();
pool.sticky("session-3").unwrap();
assert_eq!(pool.sticky.len(), 3);
{
let now = Instant::now();
for mut entry in pool.sticky.iter_mut() {
entry.expires_at = now - Duration::from_secs(1);
}
}
let url = pool.sticky("session-4");
assert!(url.is_some(), "sticky should return a URL even at capacity");
assert!(
pool.sticky.len() <= 3,
"sticky table should not exceed capacity after eviction: len={}",
pool.sticky.len()
);
assert!(
pool.sticky.contains_key("session-4"),
"session-4 binding should be inserted after eviction"
);
}
#[test]
fn sticky_capacity_limit_degrades_gracefully_when_all_valid() {
let pool = std::sync::Arc::new(
make_pool(vec!["http://a:8080", "http://b:8080"]).with_sticky_max_capacity(2),
);
pool.sticky("session-1").unwrap();
pool.sticky("session-2").unwrap();
assert_eq!(pool.sticky.len(), 2);
let url = pool.sticky("session-3");
assert!(
url.is_some(),
"sticky should still return a proxy URL when at capacity (degraded)"
);
assert!(
url.as_ref() == Some(&"http://a:8080".to_string())
|| url.as_ref() == Some(&"http://b:8080".to_string()),
"degraded sticky should return a valid pool URL"
);
assert!(
!pool.sticky.contains_key("session-3"),
"session-3 should NOT be bound when at capacity with all valid entries"
);
assert!(
pool.sticky.len() <= 2,
"sticky table should not exceed capacity: len={}",
pool.sticky.len()
);
}
#[test]
fn sticky_capacity_limit_still_returns_valid_binding_for_existing_session() {
let pool = std::sync::Arc::new(
make_pool(vec!["http://a:8080", "http://b:8080"]).with_sticky_max_capacity(1),
);
let url1 = pool.sticky("session-1").unwrap();
assert_eq!(pool.sticky.len(), 1);
let url2 = pool.sticky("session-2").unwrap();
assert!(
url2 == "http://a:8080" || url2 == "http://b:8080",
"degraded sticky should return a valid pool URL"
);
assert!(
!pool.sticky.contains_key("session-2"),
"session-2 should not be bound (at capacity)"
);
let url1_again = pool.sticky("session-1").unwrap();
assert_eq!(
url1, url1_again,
"existing valid binding should still be honored despite capacity limit"
);
}
#[test]
fn concurrent_sticky_touctou_race_all_threads_get_same_url() {
let pool = std::sync::Arc::new(
make_pool_with_ttl(
vec![
"http://a:8080",
"http://b:8080",
"http://c:8080",
"http://d:8080",
],
Duration::from_millis(50),
)
.with_sticky_max_capacity(100),
);
let initial_url = pool.sticky("race-session").unwrap();
thread::sleep(Duration::from_millis(60));
let threads = 8;
let barrier = std::sync::Arc::new(std::sync::Barrier::new(threads));
let mut handles = Vec::with_capacity(threads);
for _ in 0..threads {
let pool_clone = std::sync::Arc::clone(&pool);
let barrier_clone = std::sync::Arc::clone(&barrier);
handles.push(thread::spawn(move || {
barrier_clone.wait();
pool_clone.sticky("race-session").unwrap()
}));
}
let mut results = Vec::with_capacity(threads);
for handle in handles {
results.push(handle.join().expect("thread should not panic"));
}
let first = &results[0];
for (i, url) in results.iter().enumerate() {
assert_eq!(
url, first,
"thread {} returned different URL (TOCTOU race not fixed): got {}, expected {}",
i, url, first
);
}
assert!(
first == "http://a:8080"
|| first == "http://b:8080"
|| first == "http://c:8080"
|| first == "http://d:8080",
"returned URL should be a valid pool entry: {}",
first
);
let _ = initial_url; }
#[test]
fn concurrent_sticky_different_sessions_independent_bindings() {
let pool = std::sync::Arc::new(make_pool(vec![
"http://a:8080",
"http://b:8080",
"http://c:8080",
]));
let sessions: Vec<String> = (0..10).map(|i| format!("session-{}", i)).collect();
let sessions_arc = std::sync::Arc::new(sessions);
let threads = 10;
let mut handles = Vec::with_capacity(threads);
for t in 0..threads {
let pool_clone = std::sync::Arc::clone(&pool);
let sessions_clone = std::sync::Arc::clone(&sessions_arc);
handles.push(thread::spawn(move || {
let session = &sessions_clone[t];
let url1 = pool_clone.sticky(session).unwrap();
let url2 = pool_clone.sticky(session).unwrap();
let url3 = pool_clone.sticky(session).unwrap();
assert_eq!(url1, url2, "same session should return same url (call 2)");
assert_eq!(url2, url3, "same session should return same url (call 3)");
url1
}));
}
for (t, handle) in handles.into_iter().enumerate() {
let url = handle.join().expect("thread should not panic");
assert!(
url == "http://a:8080" || url == "http://b:8080" || url == "http://c:8080",
"thread {} returned invalid url: {}",
t,
url
);
}
}
}