use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use tokio::sync::Semaphore;
use crate::traits::Queue;
#[derive(Debug)]
pub enum BackpressureError {
LimitReached { topic: String },
}
impl std::fmt::Display for BackpressureError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::LimitReached { topic } => {
write!(f, "backpressure: in-flight limit reached for topic {topic}")
}
}
}
}
impl std::error::Error for BackpressureError {}
pub struct BackpressureEnforcer {
#[allow(dead_code)]
max_inflight: usize,
counters: Arc<std::sync::Mutex<std::collections::HashMap<String, Arc<AtomicU64>>>>,
#[allow(dead_code)]
global: Arc<Semaphore>,
}
impl BackpressureEnforcer {
pub fn new(max_inflight: usize) -> Self {
Self {
max_inflight,
counters: Arc::new(std::sync::Mutex::new(std::collections::HashMap::new())),
global: Arc::new(Semaphore::new(max_inflight.max(1))),
}
}
fn get_counter(&self, topic: &str) -> Arc<AtomicU64> {
let mut map = self.counters.lock().unwrap();
map.entry(topic.to_string())
.or_insert_with(|| Arc::new(AtomicU64::new(0)));
Arc::clone(map.get(topic).unwrap())
}
pub async fn try_enqueue<Q: Queue + ?Sized>(
&self,
queue: &Q,
topic: &str,
payload: Vec<u8>,
) -> Result<(), BackpressureError> {
let counter = self.get_counter(topic);
counter.fetch_add(1, Ordering::SeqCst);
match self.global.clone().try_acquire_owned() {
Ok(_permit) => {
let _ = queue.enqueue(topic, payload).await;
Ok(())
}
Err(_) => {
counter.fetch_sub(1, Ordering::SeqCst);
Err(BackpressureError::LimitReached {
topic: topic.to_string(),
})
}
}
}
pub fn inc_delivered(&self, topic: &str) {
self.get_counter(topic).fetch_add(1, Ordering::SeqCst);
}
pub fn dec_finished(&self, topic: &str) {
self.get_counter(topic).fetch_sub(1, Ordering::SeqCst);
}
pub fn inflight(&self, topic: &str) -> u64 {
self.get_counter(topic).load(Ordering::SeqCst)
}
}
pub async fn enqueue_with_backpressure<Q: Queue + ?Sized>(
enforcer: &BackpressureEnforcer,
queue: &Q,
topic: &str,
payloads: Vec<Vec<u8>>,
) -> Result<usize, BackpressureError> {
let mut rejected = 0;
for payload in payloads {
if enforcer.try_enqueue(queue, topic, payload).await.is_err() {
rejected += 1;
}
}
Ok(rejected)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::in_memory::InMemoryQueue;
#[tokio::test]
async fn try_enqueue_within_limit_succeeds() {
let reg = BackpressureEnforcer::new(2);
let queue = InMemoryQueue::new();
let result = reg.try_enqueue(&queue, "t", b"x".to_vec()).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn try_enqueue_rejects_when_full() {
let reg = BackpressureEnforcer::new(1);
let queue = InMemoryQueue::new();
let _first = reg.global.clone().acquire_owned().await.unwrap();
let result = reg.try_enqueue(&queue, "t", b"x".to_vec()).await;
assert!(matches!(
result,
Err(BackpressureError::LimitReached { .. })
));
}
}