use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use super::config::RateLimiterConfig;
use super::token_bucket::TokenBucket;
pub(super) struct RateLimiterInner {
pub(super) download: TokenBucket,
pub(super) upload: TokenBucket,
pub(super) download_limited: AtomicBool,
pub(super) upload_limited: AtomicBool,
}
#[derive(Clone)]
pub struct RateLimiter {
pub(super) inner: Arc<RateLimiterInner>,
}
impl RateLimiter {
pub fn new(config: &RateLimiterConfig) -> Self {
let dl_rate = config.download_rate();
let ul_rate = config.upload_rate();
let dl_burst = config.download_burst();
let ul_burst = config.upload_burst();
let download = match dl_rate {
Some(rate) if rate > 0 => TokenBucket::new(rate, dl_burst),
_ => TokenBucket::unlimited(),
};
let upload = match ul_rate {
Some(rate) if rate > 0 => TokenBucket::new(rate, ul_burst),
_ => TokenBucket::unlimited(),
};
Self {
inner: Arc::new(RateLimiterInner {
download,
upload,
download_limited: AtomicBool::new(dl_rate.is_some_and(|r| r > 0)),
upload_limited: AtomicBool::new(ul_rate.is_some_and(|r| r > 0)),
}),
}
}
pub fn unlimited() -> Self {
Self::new(&RateLimiterConfig::default())
}
pub async fn acquire_download(&self, bytes: u64) {
self.inner.download.acquire(bytes).await;
}
pub async fn acquire_upload(&self, bytes: u64) {
self.inner.upload.acquire(bytes).await;
}
#[allow(clippy::unused_async)]
pub async fn try_acquire_download(&self, bytes: u64) -> bool {
self.inner.download.try_acquire(bytes)
}
#[allow(clippy::unused_async)]
pub async fn try_acquire_upload(&self, bytes: u64) -> bool {
self.inner.upload.try_acquire(bytes)
}
pub fn is_download_limited(&self) -> bool {
self.inner.download_limited.load(Ordering::Relaxed)
}
pub fn is_upload_limited(&self) -> bool {
self.inner.upload_limited.load(Ordering::Relaxed)
}
pub async fn config(&self) -> RateLimiterConfig {
RateLimiterConfig::new(
if self.inner.download.is_unlimited() {
None
} else {
Some(self.inner.download.rate() as u64)
},
if self.inner.upload.is_unlimited() {
None
} else {
Some(self.inner.upload.rate() as u64)
},
)
}
pub fn set_download_rate(&self, rate: Option<u64>) {
match rate {
Some(r) if r > 0 => {
self.inner.download.set_unlimited(false);
self.inner.download.set_rate(r);
self.inner.download_limited.store(true, Ordering::Relaxed);
}
_ => {
self.inner.download.set_unlimited(true);
self.inner.download_limited.store(false, Ordering::Relaxed);
}
}
}
pub fn set_upload_rate(&self, rate: Option<u64>) {
match rate {
Some(r) if r > 0 => {
self.inner.upload.set_unlimited(false);
self.inner.upload.set_rate(r);
self.inner.upload_limited.store(true, Ordering::Relaxed);
}
_ => {
self.inner.upload.set_unlimited(true);
self.inner.upload_limited.store(false, Ordering::Relaxed);
}
}
}
}