use super::engine::SourceAuthority;
use super::*;
use std::{collections::HashMap, time::Duration};
pub(super) async fn coordinator_loop(rt: Arc<GroupRuntime>, mut event_rx: mpsc::Receiver<Event>) {
let mut slots: HashMap<u32, ClaimSlot> = HashMap::new();
loop {
while let Ok(event) = event_rx.try_recv() {
handle_event(&rt, &mut slots, event).await;
}
if rt.cancel.is_cancelled() {
for slot in slots.values() {
slot.source.quiesce();
}
}
let finished: Vec<_> = slots
.iter()
.filter_map(|(p, slot)| {
if slot.source.active()
&& slot
.reader
.as_ref()
.is_some_and(|reader| reader.is_finished())
{
rt.core.degraded.store(true, Ordering::Release);
slot.source.quiesce();
}
if !slot.source.can_commit() {
slot.source.lose();
}
(!slot.source.active()
&& rt.core.drained(&slot.source)
&& slot.reader.as_ref().is_none_or(|h| h.is_finished()))
.then_some(*p)
})
.collect();
let mut released = false;
for partition in finished {
let mut slot = slots.remove(&partition).expect("claim");
if let Some(reader) = slot.reader.take() {
let _ = reader.await;
}
rt.owner_ctx
.lock()
.expect("owner context")
.remove(&partition);
if let Some(guard) = slot.guard.take() {
if slot.source.can_commit() {
slot.source.begin_release();
if guard.unlock().await.is_err() {
rt.core.abandoned_source(&slot.source);
} else {
slot.source.unreleased.store(false, Ordering::Release);
released = true;
}
} else {
rt.core.abandoned_source(&slot.source);
guard.abandon();
}
}
rt.claimed
.write()
.expect("claimed")
.retain(|p| *p != partition);
}
if released {
let _: redis::RedisResult<i64> = redis::cmd("PUBLISH")
.arg(rt.layout.wake())
.arg("")
.query_async(&mut rt.client.conn())
.await;
}
if rt.cancel.is_cancelled() && slots.is_empty() {
return;
}
tokio::select! {
event = event_rx.recv() => {
if let Some(event) = event {
handle_event(&rt, &mut slots, event).await;
}
}
_ = tokio::time::sleep(Duration::from_millis(10)) => {
}
}
}
}
async fn handle_event(rt: &Arc<GroupRuntime>, slots: &mut HashMap<u32, ClaimSlot>, event: Event) {
match event {
Event::ClaimAcquired { p, guard } => {
if slots.contains_key(&p)
|| rt.cancel.is_cancelled()
|| rt.core.roots_closed.load(Ordering::Acquire)
{
let _ = guard.unlock().await;
return;
}
let Some(identity) = BatchIdentity::new_claim() else {
let _ = guard.unlock().await;
return;
};
let stamp = match &rt.fence_meta {
Some(meta) => match fencing::acquire_stamp(&rt.client, &rt.layout, meta, p).await {
Ok(stamp) => Some(stamp),
Err(_) => {
let _ = guard.unlock().await;
return;
}
},
None => None,
};
let parked = match disposition::takeover_disposition(&rt.client, &rt.layout, p).await {
Ok(disposition::TakeoverDisposition::NotParked) => false,
Ok(disposition::TakeoverDisposition::Frozen { .. }) => true,
Ok(disposition::TakeoverDisposition::AutoResumeDlq { operation_id, .. }) => {
let fence_key = rt
.fence_meta
.as_ref()
.map(|_| fencing::fence_key(&rt.layout))
.unwrap_or_default();
let lease = disposition::OwnerLease {
partition: p,
operation_id: &operation_id,
holder: guard.holder(),
lock_key: guard.lock_key(),
fence_key: &fence_key,
round: rt.fence_meta.as_ref().map_or(0, |m| m.round),
nonce: rt.fence_meta.as_ref().map_or("", |m| m.nonce.as_str()),
counter: stamp.as_ref().map_or(0, |s| s.counter),
};
disposition::dlq_from_parked(&rt.client, &rt.layout, p, &lease)
.await
.is_err()
}
_ => {
let _ = guard.unlock().await;
return;
}
};
let source = SourceAuthority::new(rt, p, identity, &guard, stamp.clone());
source.parked.store(parked, Ordering::Release);
rt.owner_ctx.lock().expect("owner context").insert(
p,
OwnerCtx {
holder: guard.holder().into(),
counter: stamp.as_ref().map_or(0, |s| s.counter),
},
);
rt.core.register_source(&source);
let reader = tokio::spawn(source::source_loop(rt.clone(), source.clone()));
slots.insert(
p,
ClaimSlot {
source,
guard: Some(guard),
reader: Some(reader),
},
);
rt.claimed.write().expect("claimed").push(p);
}
Event::RetainShare { target } => {
let active = slots.values().filter(|slot| slot.source.active()).count();
let excess = active.saturating_sub(target);
for slot in slots
.values()
.filter(|slot| slot.source.can_start())
.take(excess)
{
slot.source.quiesce();
}
}
Event::ParkResolved { p } => {
if let Some(slot) = slots.get(&p) {
if slot.source.can_commit() && !rt.core.roots_closed.load(Ordering::Acquire) {
rt.core.resume_source(&slot.source);
}
}
}
}
}