use std::sync::OnceLock;
use parking_lot::Mutex;
const DEFAULT_PERMITS: usize = 2;
const UNLIMITED: usize = usize::MAX;
pub(crate) struct FanoutLimiter {
permits: usize,
in_use: Mutex<usize>,
}
impl FanoutLimiter {
fn new(permits: usize) -> Self {
Self {
permits,
in_use: Mutex::new(0),
}
}
pub(crate) fn try_acquire(&self) -> Option<FanoutPermit<'_>> {
if self.permits == UNLIMITED {
return Some(FanoutPermit { limiter: None });
}
let mut in_use = self.in_use.lock();
if *in_use >= self.permits {
return None;
}
*in_use += 1;
Some(FanoutPermit {
limiter: Some(self),
})
}
}
pub(crate) struct FanoutPermit<'a> {
limiter: Option<&'a FanoutLimiter>,
}
impl Drop for FanoutPermit<'_> {
fn drop(&mut self) {
if let Some(l) = self.limiter {
*l.in_use.lock() -= 1;
}
}
}
pub(crate) fn global() -> &'static FanoutLimiter {
static LIMITER: OnceLock<FanoutLimiter> = OnceLock::new();
LIMITER.get_or_init(|| {
let permits = match std::env::var("VALISE_QUERY_FANOUT")
.ok()
.and_then(|s| s.parse().ok())
{
Some(0) => UNLIMITED,
Some(k) => k,
None => DEFAULT_PERMITS,
};
FanoutLimiter::new(permits)
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn admits_up_to_permits_then_falls_back() {
let limiter = FanoutLimiter::new(2);
let p1 = limiter.try_acquire();
let p2 = limiter.try_acquire();
assert!(p1.is_some() && p2.is_some());
assert!(limiter.try_acquire().is_none());
drop(p1);
assert!(limiter.try_acquire().is_some());
}
#[test]
fn unlimited_always_admits_without_locking() {
let limiter = FanoutLimiter::new(UNLIMITED);
let _a = limiter.try_acquire().expect("unlimited admits");
let _b = limiter.try_acquire().expect("unlimited admits");
let _c = limiter.try_acquire().expect("unlimited admits");
}
}