Files
furumi-web/src/podcasts/limits.rs
T
sanapachandClaude Opus 5.5 cfebe1898f Bound user-started feed and audio requests per account
Feed downloads and proxy streams have per-account and server-wide
limits, new subscriptions stop at 1000 per account, and scheduled
refreshes take accounts in turns.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-20 15:12:38 +02:00

124 lines
4.1 KiB
Rust

//! Bounds on the outbound work signed-in users can start: feed downloads
//! they ask for ("add RSS", manual refresh) and audio proxy streams. Each
//! kind has a per-account and a server-wide limit on requests in flight, so
//! one account cannot tie up the server's memory, connections or bandwidth.
//! Scheduled refreshes are bounded by the job itself (`runner::RUN_LIMIT`,
//! `runner::RUN_CONCURRENCY`, `runner::RUN_PER_ACCOUNT`).
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
/// Feed downloads one account may run at once ("add RSS", refresh).
pub(crate) const FEED_FETCHES_PER_ACCOUNT: usize = 2;
/// Feed downloads started by users, server-wide (each may buffer up to
/// `fetch::MAX_FEED_BYTES`).
pub(crate) const FEED_FETCHES_TOTAL: usize = 16;
/// Audio proxy responses one account may stream at once (a player opens a
/// new range request when seeking while the old one is still closing).
pub(crate) const PROXY_STREAMS_PER_ACCOUNT: usize = 4;
/// Audio proxy responses streamed at once, server-wide.
pub(crate) const PROXY_STREAMS_TOTAL: usize = 64;
/// Seconds a refused client is asked to wait (`Retry-After`).
pub(crate) const RETRY_AFTER_SECS: u64 = 5;
#[derive(Debug, Default)]
struct Counts {
total: usize,
accounts: HashMap<i64, usize>,
}
/// Requests in flight per account and in total.
#[derive(Debug, Clone)]
pub(crate) struct ConcurrencyLimit {
per_account: usize,
total: usize,
counts: Arc<Mutex<Counts>>,
}
impl ConcurrencyLimit {
pub(crate) fn new(per_account: usize, total: usize) -> Self {
Self {
per_account,
total,
counts: Arc::default(),
}
}
/// A slot for one request of `user_id`, released when the permit is
/// dropped; `None` when the account or the server is at its limit.
pub(crate) fn try_acquire(&self, user_id: i64) -> Option<Permit> {
let mut counts = self
.counts
.lock()
.unwrap_or_else(|error| error.into_inner());
let account = counts.accounts.get(&user_id).copied().unwrap_or(0);
if account >= self.per_account || counts.total >= self.total {
return None;
}
counts.total += 1;
counts.accounts.insert(user_id, account + 1);
Some(Permit {
user_id,
counts: Arc::clone(&self.counts),
})
}
#[cfg(test)]
fn in_flight(&self, user_id: i64) -> (usize, usize) {
let counts = self.counts.lock().unwrap();
(
counts.accounts.get(&user_id).copied().unwrap_or(0),
counts.total,
)
}
}
/// One request in flight (see [`ConcurrencyLimit::try_acquire`]).
#[derive(Debug)]
pub(crate) struct Permit {
user_id: i64,
counts: Arc<Mutex<Counts>>,
}
impl Drop for Permit {
fn drop(&mut self) {
let mut counts = self
.counts
.lock()
.unwrap_or_else(|error| error.into_inner());
counts.total = counts.total.saturating_sub(1);
if let Some(account) = counts.accounts.get_mut(&self.user_id) {
*account = account.saturating_sub(1);
if *account == 0 {
counts.accounts.remove(&self.user_id);
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn accounts_and_the_server_are_bounded_until_permits_are_dropped() {
let limit = ConcurrencyLimit::new(2, 3);
let a1 = limit.try_acquire(1).unwrap();
let a2 = limit.try_acquire(1).unwrap();
assert!(limit.try_acquire(1).is_none(), "per account");
let b1 = limit.try_acquire(2).unwrap();
assert!(limit.try_acquire(3).is_none(), "server-wide");
assert_eq!(limit.in_flight(1), (2, 3));
drop(a1);
assert_eq!(limit.in_flight(1), (1, 2));
let a3 = limit.try_acquire(1).unwrap();
drop((a2, a3, b1));
assert_eq!(limit.in_flight(1), (0, 0));
assert!(limit.counts.lock().unwrap().accounts.is_empty());
// Clones share the counts.
let clone = limit.clone();
let _held = clone.try_acquire(4).unwrap();
assert_eq!(limit.in_flight(4), (1, 1));
}
}