mytheclipse_queue/
backpressure_enqueue.rs1use std::collections::HashMap;
8use std::sync::atomic::{AtomicU64, Ordering};
9use std::sync::{Arc, Mutex};
10
11use crate::error::QueueError;
12use crate::traits::Queue;
13
14#[derive(Debug)]
16pub enum BackpressureError {
17 LimitReached { topic: String },
19 Enqueue(QueueError),
21}
22
23impl std::fmt::Display for BackpressureError {
24 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
25 match self {
26 Self::LimitReached { topic } => {
27 write!(f, "backpressure: in-flight limit reached for topic {topic}")
28 }
29 Self::Enqueue(e) => write!(f, "backpressure: enqueue failed: {e}"),
30 }
31 }
32}
33
34impl std::error::Error for BackpressureError {
35 fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
36 match self {
37 Self::LimitReached { .. } => None,
38 Self::Enqueue(e) => Some(e),
39 }
40 }
41}
42
43pub struct BackpressureEnforcer {
50 max_per_topic: u64,
52 counters: Mutex<HashMap<String, Arc<AtomicU64>>>,
54}
55
56impl BackpressureEnforcer {
57 pub fn new(max_inflight: usize) -> Self {
61 Self {
62 max_per_topic: max_inflight.max(1) as u64,
63 counters: Mutex::new(HashMap::new()),
64 }
65 }
66
67 fn counter(&self, topic: &str) -> Arc<AtomicU64> {
69 let mut map = self.counters.lock().expect("counter map poisoned");
70 Arc::clone(map.entry(topic.to_owned()).or_default())
71 }
72
73 fn take_slot(&self, topic: &str) -> Result<Arc<AtomicU64>, BackpressureError> {
78 let counter = self.counter(topic);
79 let mut current = counter.load(Ordering::Acquire);
80 loop {
81 if current >= self.max_per_topic {
82 return Err(BackpressureError::LimitReached {
83 topic: topic.to_owned(),
84 });
85 }
86 match counter.compare_exchange_weak(
87 current,
88 current + 1,
89 Ordering::AcqRel,
90 Ordering::Acquire,
91 ) {
92 Ok(_) => return Ok(counter),
93 Err(actual) => current = actual,
94 }
95 }
96 }
97
98 pub async fn try_enqueue<Q: Queue + ?Sized>(
104 &self,
105 queue: &Q,
106 topic: &str,
107 payload: Vec<u8>,
108 ) -> Result<(), BackpressureError> {
109 let counter = self.take_slot(topic)?;
110 match queue.enqueue(topic, payload).await {
111 Ok(()) => Ok(()),
112 Err(e) => {
113 counter.fetch_sub(1, Ordering::AcqRel);
114 Err(BackpressureError::Enqueue(e))
115 }
116 }
117 }
118
119 pub fn dec_finished(&self, topic: &str) {
124 let counter = self.counter(topic);
125 let mut current = counter.load(Ordering::Acquire);
126 while current > 0 {
127 match counter.compare_exchange_weak(
128 current,
129 current - 1,
130 Ordering::AcqRel,
131 Ordering::Acquire,
132 ) {
133 Ok(_) => return,
134 Err(actual) => current = actual,
135 }
136 }
137 }
138
139 pub fn inflight(&self, topic: &str) -> u64 {
141 self.counter(topic).load(Ordering::Acquire)
142 }
143}
144
145pub async fn enqueue_with_backpressure<Q: Queue + ?Sized>(
150 enforcer: &BackpressureEnforcer,
151 queue: &Q,
152 topic: &str,
153 payloads: Vec<Vec<u8>>,
154) -> Result<usize, BackpressureError> {
155 let mut rejected = 0;
156 for payload in payloads {
157 match enforcer.try_enqueue(queue, topic, payload).await {
158 Ok(()) => {}
159 Err(BackpressureError::LimitReached { .. }) => rejected += 1,
160 Err(e) => return Err(e),
161 }
162 }
163 Ok(rejected)
164}
165
166#[cfg(test)]
167mod tests {
168 use super::*;
169 use crate::in_memory::InMemoryQueue;
170
171 #[tokio::test]
172 async fn try_enqueue_within_limit_succeeds() {
173 let reg = BackpressureEnforcer::new(2);
174 let queue = InMemoryQueue::new();
175 assert!(reg.try_enqueue(&queue, "t", b"x".to_vec()).await.is_ok());
176 assert_eq!(reg.inflight("t"), 1);
177 }
178
179 #[tokio::test]
180 async fn try_enqueue_rejects_when_full() {
181 let reg = BackpressureEnforcer::new(1);
182 let queue = InMemoryQueue::new();
183
184 reg.try_enqueue(&queue, "t", b"x".to_vec()).await.unwrap();
185 assert!(matches!(
186 reg.try_enqueue(&queue, "t", b"y".to_vec()).await,
187 Err(BackpressureError::LimitReached { .. })
188 ));
189 }
190
191 #[tokio::test]
192 async fn finished_jobs_release_capacity() {
193 let reg = BackpressureEnforcer::new(1);
194 let queue = InMemoryQueue::new();
195
196 reg.try_enqueue(&queue, "t", b"x".to_vec()).await.unwrap();
197 reg.dec_finished("t");
198 assert_eq!(reg.inflight("t"), 0);
199 assert!(reg.try_enqueue(&queue, "t", b"y".to_vec()).await.is_ok());
200 }
201
202 #[tokio::test]
203 async fn topics_are_capped_independently() {
204 let reg = BackpressureEnforcer::new(1);
205 let queue = InMemoryQueue::new();
206
207 reg.try_enqueue(&queue, "a", b"x".to_vec()).await.unwrap();
208 assert!(reg.try_enqueue(&queue, "b", b"y".to_vec()).await.is_ok());
209 }
210
211 #[tokio::test]
212 async fn unmatched_finish_does_not_wrap_the_counter() {
213 let reg = BackpressureEnforcer::new(1);
214 reg.dec_finished("t");
215 reg.dec_finished("t");
216 assert_eq!(reg.inflight("t"), 0);
217 }
218}