use std::collections::VecDeque;
use futures::stream::{FuturesUnordered, StreamExt};
use crate::time::Instant;
use crate::tool_framework::{CallAnswer, ToolError, ToolInvocation, ToolRegistry};
use crate::BoxFuture;
type Running<'r> = BoxFuture<'r, (usize, Result<CallAnswer, ToolError>)>;
struct Slot {
call: ToolInvocation,
parallel: bool,
started: Option<Instant>,
answer: Option<CallAnswer>,
}
pub(super) struct Dispatcher<'r> {
registry: &'r ToolRegistry,
slots: Vec<Slot>,
queue: VecDeque<usize>,
running: FuturesUnordered<Running<'r>>,
parallel_running: usize,
exclusive_running: bool,
}
impl<'r> Dispatcher<'r> {
pub(super) fn new(registry: &'r ToolRegistry) -> Self {
Self {
registry,
slots: Vec::new(),
queue: VecDeque::new(),
running: FuturesUnordered::new(),
parallel_running: 0,
exclusive_running: false,
}
}
pub(super) fn push(&mut self, call: ToolInvocation, parallel: bool) {
self.slots.push(Slot {
call,
parallel,
started: None,
answer: None,
});
self.queue.push_back(self.slots.len() - 1);
self.start_ready();
}
pub(super) fn push_answered(&mut self, call: ToolInvocation, answer: CallAnswer) {
self.slots.push(Slot {
call,
parallel: true,
started: Some(Instant::now()),
answer: Some(answer),
});
}
fn start_ready(&mut self) {
while let Some(&index) = self.queue.front() {
let parallel = self.slots[index].parallel;
let may_start = if parallel {
!self.exclusive_running
} else {
!self.exclusive_running && self.parallel_running == 0
};
if !may_start {
return;
}
self.queue.pop_front();
if parallel {
self.parallel_running += 1;
} else {
self.exclusive_running = true;
}
let slot = &mut self.slots[index];
slot.started = Some(Instant::now());
let call = slot.call.clone();
let registry = self.registry;
self.running.push(Box::pin(async move {
(index, registry.answer_call(call).await)
}));
}
}
pub(super) fn is_idle(&self) -> bool {
self.queue.is_empty() && self.running.is_empty()
}
pub(super) async fn finished(&mut self) -> Result<usize, ToolError> {
let Some((index, result)) = self.running.next().await else {
return futures::future::pending().await;
};
if self.slots[index].parallel {
self.parallel_running -= 1;
} else {
self.exclusive_running = false;
}
let answer = result?;
self.slots[index].answer = Some(answer);
self.start_ready();
Ok(index)
}
pub(super) fn answer(&self, index: usize) -> Option<&CallAnswer> {
self.slots.get(index)?.answer.as_ref()
}
pub(super) fn take(&mut self) -> Vec<(ToolInvocation, Option<CallAnswer>)> {
self.queue.clear();
self.running = FuturesUnordered::new();
self.parallel_running = 0;
self.exclusive_running = false;
std::mem::take(&mut self.slots)
.into_iter()
.map(|slot| (slot.call, slot.answer))
.collect()
}
pub(super) fn abort(&mut self) -> Vec<CallAnswer> {
let started: Vec<Option<Instant>> = self.slots.iter().map(|slot| slot.started).collect();
self.take()
.into_iter()
.zip(started)
.map(|((call, answer), started)| match (answer, started) {
(Some(answer), _) => answer,
(None, Some(started)) => CallAnswer::failure(
&call,
format!(
"aborted by user after {:.1}s",
started.elapsed().as_secs_f64()
),
),
(None, None) => CallAnswer::aborted(&call),
})
.collect()
}
pub(super) fn finished_answers(&mut self) -> Vec<CallAnswer> {
self.take()
.into_iter()
.filter_map(|(_, answer)| answer)
.collect()
}
}