use dashmap::DashMap;
use std::sync::Arc;
use tokio::sync::{OwnedSemaphorePermit, Semaphore};
use crate::utils::adaptive_concurrency::{AIMDController, AdaptiveSemaphore};
#[derive(Clone, Debug)]
pub struct AdaptiveParams {
pub initial: usize,
pub min_limit: usize,
pub max_limit: usize,
pub increase_threshold: usize,
}
impl AdaptiveParams {
#[must_use]
pub fn new(
initial: usize,
min_limit: usize,
max_limit: usize,
increase_threshold: usize,
) -> Self {
let _ = AIMDController::with_params(initial, min_limit, max_limit, increase_threshold);
let clamped = initial.clamp(min_limit, max_limit);
Self {
initial: clamped,
min_limit,
max_limit,
increase_threshold,
}
}
}
impl Default for AdaptiveParams {
fn default() -> Self {
Self {
initial: 10,
min_limit: crate::utils::adaptive_concurrency::DEFAULT_MIN_LIMIT,
max_limit: crate::utils::adaptive_concurrency::DEFAULT_MAX_LIMIT,
increase_threshold: crate::utils::adaptive_concurrency::DEFAULT_INCREASE_THRESHOLD,
}
}
}
#[derive(Debug)]
enum TeamEntry {
Fixed(Arc<Semaphore>),
Adaptive {
adaptive: Arc<AdaptiveSemaphore>,
controller: Arc<AIMDController>,
},
}
impl TeamEntry {
fn to_handle(&self) -> TeamHandle {
match self {
TeamEntry::Fixed(sem) => TeamHandle::Fixed(Arc::clone(sem)),
TeamEntry::Adaptive {
adaptive,
controller,
} => TeamHandle::Adaptive {
adaptive: Arc::clone(adaptive),
controller: Arc::clone(controller),
},
}
}
}
#[derive(Clone, Debug)]
enum TeamHandle {
Fixed(Arc<Semaphore>),
Adaptive {
adaptive: Arc<AdaptiveSemaphore>,
controller: Arc<AIMDController>,
},
}
impl TeamHandle {
async fn acquire_owned(&self) -> Result<OwnedSemaphorePermit, tokio::sync::AcquireError> {
match self {
TeamHandle::Fixed(sem) => Arc::clone(sem).acquire_owned().await,
TeamHandle::Adaptive { adaptive, .. } => Ok(adaptive.acquire().await),
}
}
fn try_acquire_owned(&self) -> Option<OwnedSemaphorePermit> {
match self {
TeamHandle::Fixed(sem) => Arc::clone(sem).try_acquire_owned().ok(),
TeamHandle::Adaptive { adaptive, .. } => adaptive.try_acquire(),
}
}
fn current_target(&self) -> usize {
match self {
TeamHandle::Fixed(sem) => sem.available_permits(),
TeamHandle::Adaptive { controller, .. } => controller.current_limit(),
}
}
fn record_success(&self) -> usize {
match self {
TeamHandle::Fixed(sem) => sem.available_permits(),
TeamHandle::Adaptive {
controller,
adaptive,
..
} => {
let new_target = controller.record_success();
adaptive.set_target(new_target);
new_target
}
}
}
fn record_failure(&self) -> usize {
match self {
TeamHandle::Fixed(sem) => sem.available_permits(),
TeamHandle::Adaptive {
controller,
adaptive,
..
} => {
let new_target = controller.record_failure();
adaptive.set_target(new_target);
new_target
}
}
}
fn is_adaptive(&self) -> bool {
matches!(self, TeamHandle::Adaptive { .. })
}
}
#[derive(Clone, Debug)]
pub struct TeamSemaphore {
semaphores: Arc<DashMap<crate::domain::id::Id, TeamEntry>>,
default_permits: usize,
mode: SemaphoreMode,
max_teams: usize,
}
pub const DEFAULT_MAX_TEAMS: usize = 10000;
#[derive(Clone, Debug)]
enum SemaphoreMode {
Fixed,
Adaptive(AdaptiveParams),
}
impl std::fmt::Display for SemaphoreMode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
SemaphoreMode::Fixed => write!(f, "Fixed"),
SemaphoreMode::Adaptive(_) => write!(f, "Adaptive"),
}
}
}
impl TeamSemaphore {
pub fn new(default_permits: usize) -> Self {
Self {
semaphores: Arc::new(DashMap::new()),
default_permits,
mode: SemaphoreMode::Fixed,
max_teams: DEFAULT_MAX_TEAMS,
}
}
pub fn with_adaptive(params: AdaptiveParams) -> Self {
Self {
semaphores: Arc::new(DashMap::new()),
default_permits: params.initial,
mode: SemaphoreMode::Adaptive(params),
max_teams: DEFAULT_MAX_TEAMS,
}
}
pub fn with_max_teams(mut self, max_teams: usize) -> Self {
self.max_teams = max_teams.max(1);
self
}
pub fn max_teams(&self) -> usize {
self.max_teams
}
fn evict_one_for_new(&self) -> usize {
if self.semaphores.len() < self.max_teams {
return 0;
}
let mut evicted_team: Option<crate::domain::id::Id> = None;
for entry in self.semaphores.iter() {
let is_idle = match entry.value() {
TeamEntry::Fixed(sem) => sem.available_permits() >= self.default_permits,
TeamEntry::Adaptive { adaptive, .. } => {
adaptive.available_permits() >= self.default_permits
}
};
if is_idle {
evicted_team = Some(*entry.key());
break;
}
}
if let Some(team_id) = evicted_team {
self.semaphores.remove(&team_id);
1
} else {
0
}
}
pub fn team_count(&self) -> usize {
self.semaphores.len()
}
pub fn mode(&self) -> &str {
match &self.mode {
SemaphoreMode::Fixed => "Fixed",
SemaphoreMode::Adaptive(_) => "Adaptive",
}
}
pub fn default_permits(&self) -> usize {
self.default_permits
}
pub async fn acquire(
&self,
team_id: crate::domain::id::Id,
) -> Result<OwnedSemaphorePermit, tokio::sync::AcquireError> {
let handle = self.get_or_create(team_id);
handle.acquire_owned().await
}
pub fn try_acquire(&self, team_id: crate::domain::id::Id) -> Option<OwnedSemaphorePermit> {
let handle = self.get_or_create(team_id);
handle.try_acquire_owned()
}
pub fn record_success(&self, team_id: crate::domain::id::Id) -> usize {
let handle = self.get_or_create(team_id);
let target = handle.record_success();
emit_aimd_gauge(team_id, target);
target
}
pub fn record_failure(&self, team_id: crate::domain::id::Id) -> usize {
let handle = self.get_or_create(team_id);
let target = handle.record_failure();
emit_aimd_gauge(team_id, target);
target
}
pub fn on_memory_pressure(&self, critical: bool) -> usize {
let mut adaptive_teams = 0usize;
for entry in self.semaphores.iter() {
if let TeamEntry::Adaptive {
adaptive,
controller,
} = entry.value()
{
let new_target = controller.on_memory_pressure(critical);
adaptive.set_target(new_target);
emit_aimd_gauge(*entry.key(), new_target);
adaptive_teams += 1;
}
}
adaptive_teams
}
pub fn current_target(&self, team_id: crate::domain::id::Id) -> usize {
match self.lookup(team_id) {
Some(handle) => handle.current_target(),
None => self.default_permits,
}
}
pub fn is_team_adaptive(&self, team_id: crate::domain::id::Id) -> bool {
match self.lookup(team_id) {
Some(handle) => handle.is_adaptive(),
None => matches!(self.mode, SemaphoreMode::Adaptive(_)),
}
}
fn lookup(&self, team_id: crate::domain::id::Id) -> Option<TeamHandle> {
let entry = self.semaphores.get(&team_id)?;
let handle = entry.value().to_handle();
drop(entry);
Some(handle)
}
fn get_or_create(&self, team_id: crate::domain::id::Id) -> TeamHandle {
if let Some(handle) = self.lookup(team_id) {
return handle;
}
if self.semaphores.len() >= self.max_teams {
let _evicted = self.evict_one_for_new();
}
self.insert_team_entry(team_id)
}
fn insert_team_entry(&self, team_id: crate::domain::id::Id) -> TeamHandle {
use dashmap::mapref::entry::Entry;
match self.semaphores.entry(team_id) {
Entry::Occupied(o) => {
let handle = o.get().to_handle();
drop(o);
handle
}
Entry::Vacant(v) => {
let new_entry = self.new_team_entry();
let handle = new_entry.to_handle();
v.insert(new_entry);
handle
}
}
}
fn new_team_entry(&self) -> TeamEntry {
match &self.mode {
SemaphoreMode::Fixed => {
TeamEntry::Fixed(Arc::new(Semaphore::new(self.default_permits)))
}
SemaphoreMode::Adaptive(params) => {
let controller = Arc::new(AIMDController::with_params(
params.initial,
params.min_limit,
params.max_limit,
params.increase_threshold,
));
let adaptive = Arc::new(AdaptiveSemaphore::new(params.initial));
TeamEntry::Adaptive {
adaptive,
controller,
}
}
}
}
}
fn emit_aimd_gauge(team_id: crate::domain::id::Id, target: usize) {
let _ = team_id;
#[cfg(feature = "metrics")]
{
metrics::describe_gauge!(
"crawlrs_aimd_limit",
"Adaptive AIMD concurrency target (process-wide, last team update)"
);
metrics::gauge!("crawlrs_aimd_limit").set(target as f64);
}
#[cfg(not(feature = "metrics"))]
let _ = target;
}
#[cfg(test)]
mod tests {
use super::*;
use std::time::Duration;
#[test]
fn test_new_stores_default_permits() {
let sem = TeamSemaphore::new(5);
assert_eq!(sem.default_permits, 5);
assert_eq!(sem.mode(), "Fixed");
}
#[test]
fn test_with_max_teams_evicts_idle_teams() {
let sem = TeamSemaphore::new(2).with_max_teams(2);
let team_a = crate::domain::id::Id::generate();
let team_b = crate::domain::id::Id::generate();
let team_c = crate::domain::id::Id::generate();
let _handle_a = sem.get_or_create(team_a);
drop(_handle_a);
let _handle_b = sem.get_or_create(team_b);
drop(_handle_b);
let _handle_c = sem.get_or_create(team_c);
assert_eq!(sem.team_count(), 2);
}
#[test]
fn test_default_max_teams() {
let sem = TeamSemaphore::new(10);
assert_eq!(sem.max_teams(), DEFAULT_MAX_TEAMS);
}
#[test]
fn test_with_max_teams_keeps_busy_teams() {
let sem = TeamSemaphore::new(1).with_max_teams(2);
let team_a = crate::domain::id::Id::generate();
let team_b = crate::domain::id::Id::generate();
let team_c = crate::domain::id::Id::generate();
let _permit_a = sem.try_acquire(team_a).expect("first acquire");
let _handle_b = sem.get_or_create(team_b);
drop(_handle_b);
let _handle_c = sem.get_or_create(team_c);
assert_eq!(sem.team_count(), 2);
assert!(sem.semaphores.contains_key(&team_a));
assert!(sem.semaphores.contains_key(&team_c));
}
#[test]
fn test_new_with_zero_permits() {
let sem = TeamSemaphore::new(0);
assert_eq!(sem.default_permits, 0);
}
#[test]
fn test_zero_permits_try_acquire_returns_none_without_blocking() {
let sem = TeamSemaphore::new(0);
let team_id = crate::domain::id::Id::generate();
assert!(
sem.try_acquire(team_id).is_none(),
"zero-permit team must not hand out permits on the non-blocking path"
);
assert!(sem.semaphores.contains_key(&team_id));
}
#[test]
fn test_new_starts_with_empty_map() {
let sem = TeamSemaphore::new(3);
let team_id = crate::domain::id::Id::generate();
assert!(!sem.semaphores.contains_key(&team_id));
}
#[test]
fn test_get_or_create_creates_new_semaphore_fixed() {
let sem = TeamSemaphore::new(4);
let team_id = crate::domain::id::Id::generate();
let handle = sem.get_or_create(team_id);
assert!(!handle.is_adaptive());
assert!(handle.try_acquire_owned().is_some());
assert!(sem.semaphores.contains_key(&team_id));
}
#[test]
fn test_get_or_create_reuses_existing_semaphore() {
let sem = TeamSemaphore::new(1);
let team_id = crate::domain::id::Id::generate();
let first = sem.get_or_create(team_id);
let first_ptr = match &first {
TeamHandle::Fixed(s) => Arc::clone(s),
_ => unreachable!(),
};
let second = sem.get_or_create(team_id);
let second_ptr = match &second {
TeamHandle::Fixed(s) => Arc::clone(s),
_ => unreachable!(),
};
assert!(Arc::ptr_eq(&first_ptr, &second_ptr));
assert_eq!(sem.semaphores.len(), 1);
}
#[test]
fn test_get_or_create_isolates_different_teams() {
let sem = TeamSemaphore::new(2);
let team_a = crate::domain::id::Id::generate();
let team_b = crate::domain::id::Id::generate();
let handle_a = sem.get_or_create(team_a);
let handle_b = sem.get_or_create(team_b);
let sem_a = match &handle_a {
TeamHandle::Fixed(s) => Arc::clone(s),
_ => unreachable!(),
};
let sem_b = match &handle_b {
TeamHandle::Fixed(s) => Arc::clone(s),
_ => unreachable!(),
};
assert!(!Arc::ptr_eq(&sem_a, &sem_b));
assert_eq!(sem.semaphores.len(), 2);
}
#[tokio::test]
async fn test_acquire_returns_permit() {
let sem = TeamSemaphore::new(3);
let team_id = crate::domain::id::Id::generate();
let permit = sem.acquire(team_id).await;
assert!(permit.is_ok());
assert!(sem.semaphores.contains_key(&team_id));
}
#[tokio::test]
async fn test_acquire_within_limit_succeeds() {
let sem = TeamSemaphore::new(2);
let team_id = crate::domain::id::Id::generate();
let p1 = sem
.acquire(team_id)
.await
.expect("first acquire should succeed");
let p2 = sem
.acquire(team_id)
.await
.expect("second acquire should succeed");
let _ = (p1, p2);
}
#[tokio::test]
async fn test_acquire_over_limit_blocks_until_timeout() {
let sem = TeamSemaphore::new(1);
let team_id = crate::domain::id::Id::generate();
let _held_permit = sem
.acquire(team_id)
.await
.expect("first acquire should succeed");
let result = tokio::time::timeout(Duration::from_millis(50), sem.acquire(team_id)).await;
assert!(
result.is_err(),
"second acquire should time out when permits are exhausted"
);
}
#[tokio::test]
async fn test_acquire_permit_release_allows_next() {
let sem = TeamSemaphore::new(1);
let team_id = crate::domain::id::Id::generate();
{
let _permit = sem
.acquire(team_id)
.await
.expect("first acquire should succeed");
}
let result = tokio::time::timeout(Duration::from_millis(200), sem.acquire(team_id)).await;
assert!(
result.is_ok(),
"acquire should succeed after permit is dropped"
);
assert!(result.unwrap().is_ok());
}
#[tokio::test]
async fn test_acquire_isolates_concurrency_per_team() {
let sem = TeamSemaphore::new(1);
let team_a = crate::domain::id::Id::generate();
let team_b = crate::domain::id::Id::generate();
let _held_a = sem
.acquire(team_a)
.await
.expect("team A acquire should succeed");
let result = tokio::time::timeout(Duration::from_millis(200), sem.acquire(team_b)).await;
assert!(
result.is_ok(),
"team B acquire should not be blocked by team A"
);
assert!(result.unwrap().is_ok());
}
#[test]
fn test_clone_shares_underlying_state() {
let sem = TeamSemaphore::new(2);
let team_id = crate::domain::id::Id::generate();
let _handle = sem.get_or_create(team_id);
let cloned = sem.clone();
assert!(cloned.semaphores.contains_key(&team_id));
assert!(Arc::ptr_eq(&sem.semaphores, &cloned.semaphores));
}
#[tokio::test]
async fn test_single_tenant_degraded_global_concurrency_limit() {
use crate::common::constants::default_identity::DEFAULT_TEAM_ID;
let sem = TeamSemaphore::new(3);
let p1 = sem
.acquire(DEFAULT_TEAM_ID)
.await
.expect("first acquire should succeed");
let p2 = sem
.acquire(DEFAULT_TEAM_ID)
.await
.expect("second acquire should succeed");
let p3 = sem
.acquire(DEFAULT_TEAM_ID)
.await
.expect("third acquire should succeed");
let result_exhausted = sem.try_acquire(DEFAULT_TEAM_ID);
assert!(
result_exhausted.is_none(),
"try_acquire should return None when single-tenant permits are exhausted"
);
drop(p3);
let result_after_release = sem.try_acquire(DEFAULT_TEAM_ID);
assert!(
result_after_release.is_some(),
"try_acquire should return Some after a permit is dropped"
);
drop(p1);
drop(p2);
}
#[tokio::test]
async fn test_single_tenant_degraded_uses_only_default_team_id_entry() {
use crate::common::constants::default_identity::DEFAULT_TEAM_ID;
let sem = TeamSemaphore::new(2);
let _p1 = sem.acquire(DEFAULT_TEAM_ID).await.expect("first acquire");
let _p2 = sem.acquire(DEFAULT_TEAM_ID).await.expect("second acquire");
assert_eq!(
sem.semaphores.len(),
1,
"single-tenant mode should have exactly one semaphore entry"
);
assert!(
sem.semaphores.contains_key(&DEFAULT_TEAM_ID),
"semaphore entry must be keyed by DEFAULT_TEAM_ID"
);
}
#[test]
fn test_with_adaptive_creates_adaptive_mode() {
let params = AdaptiveParams {
initial: 5,
min_limit: 1,
max_limit: 50,
increase_threshold: 3,
};
let sem = TeamSemaphore::with_adaptive(params);
assert_eq!(sem.mode(), "Adaptive");
assert_eq!(sem.default_permits, 5);
}
#[test]
fn test_adaptive_params_default() {
let params = AdaptiveParams::default();
assert_eq!(params.initial, 10);
assert_eq!(params.min_limit, 1);
assert_eq!(params.max_limit, 100);
assert_eq!(params.increase_threshold, 10);
}
#[tokio::test]
async fn test_adaptive_acquire_creates_adaptive_entry() {
let sem = TeamSemaphore::with_adaptive(AdaptiveParams {
initial: 5,
..Default::default()
});
let team_id = crate::domain::id::Id::generate();
let _permit = sem.acquire(team_id).await.expect("acquire should succeed");
assert!(sem.is_team_adaptive(team_id));
}
#[tokio::test]
async fn test_adaptive_current_target_returns_controller_limit() {
let sem = TeamSemaphore::with_adaptive(AdaptiveParams {
initial: 10,
min_limit: 1,
max_limit: 100,
increase_threshold: 5,
});
let team_id = crate::domain::id::Id::generate();
let _permit = sem.acquire(team_id).await.expect("acquire");
assert_eq!(sem.current_target(team_id), 10);
}
#[tokio::test]
async fn test_adaptive_record_success_increases_target() {
let sem = TeamSemaphore::with_adaptive(AdaptiveParams {
initial: 10,
min_limit: 1,
max_limit: 100,
increase_threshold: 3,
});
let team_id = crate::domain::id::Id::generate();
let _permit = sem.acquire(team_id).await.expect("acquire");
sem.record_success(team_id);
sem.record_success(team_id);
let target_after_3 = sem.record_success(team_id);
assert_eq!(target_after_3, 11);
assert_eq!(sem.current_target(team_id), 11);
}
#[tokio::test]
async fn test_adaptive_record_failure_halves_target() {
let sem = TeamSemaphore::with_adaptive(AdaptiveParams {
initial: 10,
min_limit: 1,
max_limit: 100,
increase_threshold: 10,
});
let team_id = crate::domain::id::Id::generate();
let _permit = sem.acquire(team_id).await.expect("acquire");
let target = sem.record_failure(team_id);
assert_eq!(target, 5);
assert_eq!(sem.current_target(team_id), 5);
}
#[tokio::test]
async fn test_adaptive_record_failure_clamps_to_min() {
let sem = TeamSemaphore::with_adaptive(AdaptiveParams {
initial: 4,
min_limit: 1,
max_limit: 100,
increase_threshold: 10,
});
let team_id = crate::domain::id::Id::generate();
let _permit = sem.acquire(team_id).await.expect("acquire");
assert_eq!(sem.record_failure(team_id), 2);
assert_eq!(sem.record_failure(team_id), 1);
assert_eq!(sem.record_failure(team_id), 1);
}
#[tokio::test]
async fn test_adaptive_record_success_at_max_no_increase() {
let sem = TeamSemaphore::with_adaptive(AdaptiveParams {
initial: 9,
min_limit: 1,
max_limit: 10,
increase_threshold: 1,
});
let team_id = crate::domain::id::Id::generate();
let _permit = sem.acquire(team_id).await.expect("acquire");
assert_eq!(sem.record_success(team_id), 10);
assert_eq!(sem.record_success(team_id), 10);
}
#[tokio::test]
async fn test_adaptive_target_changes_affect_permits() {
let sem = TeamSemaphore::with_adaptive(AdaptiveParams {
initial: 2,
min_limit: 1,
max_limit: 10,
increase_threshold: 1,
});
let team_id = crate::domain::id::Id::generate();
let p1 = sem.acquire(team_id).await.expect("p1");
let p2 = sem.acquire(team_id).await.expect("p2");
assert!(sem.try_acquire(team_id).is_none());
sem.record_success(team_id);
let p3 = sem.try_acquire(team_id);
assert!(
p3.is_some(),
"should be able to acquire after target increase"
);
assert!(sem.try_acquire(team_id).is_none());
drop(p1);
drop(p2);
drop(p3);
}
#[tokio::test]
async fn test_adaptive_alternating_success_failure() {
let sem = TeamSemaphore::with_adaptive(AdaptiveParams {
initial: 10,
min_limit: 1,
max_limit: 100,
increase_threshold: 1,
});
let team_id = crate::domain::id::Id::generate();
let _permit = sem.acquire(team_id).await.expect("acquire");
assert_eq!(sem.record_success(team_id), 11);
assert_eq!(sem.record_failure(team_id), 5);
assert_eq!(sem.record_success(team_id), 6);
assert_eq!(sem.record_failure(team_id), 3);
}
#[tokio::test]
async fn test_fixed_mode_record_success_failure_are_noops() {
let sem = TeamSemaphore::new(5);
let team_id = crate::domain::id::Id::generate();
let _permit = sem.acquire(team_id).await.expect("acquire");
let target1 = sem.record_success(team_id);
let target2 = sem.record_failure(team_id);
assert_eq!(target1, 4);
assert_eq!(target2, 4);
assert_eq!(sem.current_target(team_id), 4);
}
#[tokio::test]
async fn test_adaptive_isolates_different_teams() {
let sem = TeamSemaphore::with_adaptive(AdaptiveParams {
initial: 10,
min_limit: 1,
max_limit: 100,
increase_threshold: 1,
});
let team_a = crate::domain::id::Id::generate();
let team_b = crate::domain::id::Id::generate();
let _pa = sem.acquire(team_a).await.expect("a");
let _pb = sem.acquire(team_b).await.expect("b");
assert_eq!(sem.record_success(team_a), 11);
assert_eq!(sem.current_target(team_b), 10);
assert_eq!(sem.record_failure(team_b), 5);
assert_eq!(sem.current_target(team_a), 11);
}
#[tokio::test]
async fn test_adaptive_record_success_propagates_to_semaphore() {
let sem = TeamSemaphore::with_adaptive(AdaptiveParams {
initial: 1,
min_limit: 1,
max_limit: 5,
increase_threshold: 1,
});
let team_id = crate::domain::id::Id::generate();
let _p1 = sem.acquire(team_id).await.expect("p1");
assert!(sem.try_acquire(team_id).is_none());
sem.record_success(team_id);
let p2 = sem.try_acquire(team_id);
assert!(
p2.is_some(),
"target increase should make new permit available"
);
}
#[tokio::test]
async fn test_adaptive_record_success_without_prior_acquire() {
let sem = TeamSemaphore::with_adaptive(AdaptiveParams {
initial: 5,
min_limit: 1,
max_limit: 100,
increase_threshold: 1,
});
let team_id = crate::domain::id::Id::generate();
let target = sem.record_success(team_id);
assert_eq!(target, 6);
assert_eq!(sem.current_target(team_id), 6);
}
#[tokio::test]
async fn test_adaptive_record_failure_without_prior_acquire() {
let sem = TeamSemaphore::with_adaptive(AdaptiveParams {
initial: 10,
min_limit: 1,
max_limit: 100,
increase_threshold: 10,
});
let team_id = crate::domain::id::Id::generate();
let target = sem.record_failure(team_id);
assert_eq!(target, 5);
}
#[test]
fn test_current_target_unknown_team_returns_default() {
let sem = TeamSemaphore::new(7);
let team_id = crate::domain::id::Id::generate();
assert_eq!(sem.current_target(team_id), 7);
}
#[test]
fn test_is_team_adaptive_unknown_team_returns_mode_flag() {
let fixed_sem = TeamSemaphore::new(5);
let adaptive_sem = TeamSemaphore::with_adaptive(AdaptiveParams::default());
let team_id = crate::domain::id::Id::generate();
assert!(!fixed_sem.is_team_adaptive(team_id));
assert!(adaptive_sem.is_team_adaptive(team_id));
}
#[test]
fn test_concurrent_get_or_create_no_duplicates() {
use std::sync::Barrier;
let sem = Arc::new(TeamSemaphore::new(5));
let team_id = crate::domain::id::Id::generate();
let barrier = Arc::new(Barrier::new(8));
let handles: Vec<_> = (0..8)
.map(|_| {
let s = sem.clone();
let b = barrier.clone();
std::thread::spawn(move || {
b.wait();
s.get_or_create(team_id);
})
})
.collect();
for h in handles {
h.join().expect("thread panicked");
}
assert_eq!(sem.semaphores.len(), 1);
assert!(sem.semaphores.contains_key(&team_id));
}
#[tokio::test]
async fn test_fixed_mode_memory_pressure_is_noop() {
let sem = TeamSemaphore::new(5);
let team_id = crate::domain::id::Id::generate();
let _permit = sem.acquire(team_id).await.expect("acquire");
assert_eq!(sem.on_memory_pressure(false), 0, "no adaptive teams");
assert_eq!(sem.on_memory_pressure(true), 0);
assert_eq!(sem.current_target(team_id), 4);
}
#[tokio::test]
async fn test_adaptive_memory_pressure_freezes_increase() {
let sem = TeamSemaphore::with_adaptive(AdaptiveParams {
initial: 10,
min_limit: 1,
max_limit: 100,
increase_threshold: 3,
});
let team_id = crate::domain::id::Id::generate();
let _permit = sem.acquire(team_id).await.expect("acquire");
for _ in 0..10 {
sem.on_memory_pressure(false);
sem.record_success(team_id);
sem.record_success(team_id);
}
assert_eq!(
sem.current_target(team_id),
10,
"renewed pressure must freeze +1 via set_target path"
);
}
#[tokio::test]
async fn test_adaptive_memory_critical_halves_target() {
let sem = TeamSemaphore::with_adaptive(AdaptiveParams {
initial: 16,
min_limit: 1,
max_limit: 100,
increase_threshold: 10,
});
let team_id = crate::domain::id::Id::generate();
let _permit = sem.acquire(team_id).await.expect("acquire");
assert_eq!(
sem.on_memory_pressure(true),
1,
"one adaptive team signaled"
);
assert_eq!(sem.current_target(team_id), 8, "16/2 via controller");
}
#[tokio::test]
async fn test_memory_pressure_broadcasts_to_all_teams() {
let sem = TeamSemaphore::with_adaptive(AdaptiveParams {
initial: 10,
min_limit: 1,
max_limit: 100,
increase_threshold: 10,
});
let team_a = crate::domain::id::Id::generate();
let team_b = crate::domain::id::Id::generate();
let _pa = sem.acquire(team_a).await.expect("a");
let _pb = sem.acquire(team_b).await.expect("b");
assert_eq!(sem.on_memory_pressure(true), 2, "both adaptive teams");
assert_eq!(sem.current_target(team_a), 5);
assert_eq!(sem.current_target(team_b), 5);
}
#[test]
fn test_memory_pressure_mixed_modes_no_deadlock() {
let fixed = TeamSemaphore::new(5);
let adaptive = TeamSemaphore::with_adaptive(AdaptiveParams::default());
let t = crate::domain::id::Id::generate();
assert!(fixed.try_acquire(t).is_some());
assert!(adaptive.try_acquire(t).is_some());
let fx = Arc::new(fixed);
let ad = Arc::new(adaptive);
let handles: Vec<_> = (0..4)
.map(|i| {
let (fx, ad) = (fx.clone(), ad.clone());
std::thread::spawn(move || {
for _ in 0..50 {
fx.on_memory_pressure(i % 2 == 0);
ad.on_memory_pressure(i % 2 == 1);
ad.record_success(t);
}
})
})
.collect();
for h in handles {
h.join().expect("thread panicked");
}
}
}