use std::collections::VecDeque;
use super::DhtTask;
pub struct TaskExecutor {
max_concurrent: usize,
running: Vec<Box<dyn DhtTask>>,
queue: VecDeque<Box<dyn DhtTask>>,
}
impl TaskExecutor {
pub fn new(max_concurrent: usize) -> Self {
Self {
max_concurrent,
running: Vec::new(),
queue: VecDeque::new(),
}
}
pub fn add_task(&mut self, task: Box<dyn DhtTask>) {
self.queue.push_back(task);
}
pub fn update(&mut self) {
self.running.retain(|t| !t.finished());
while self.running.len() < self.max_concurrent {
let Some(mut task) = self.queue.pop_front() else {
break;
};
task.startup();
self.running.push(task);
}
}
pub fn running_count(&self) -> usize {
self.running.len()
}
pub fn queue_size(&self) -> usize {
self.queue.len()
}
}
pub struct DhtTaskQueue {
immediate: TaskExecutor,
periodic1: TaskExecutor,
periodic2: TaskExecutor,
}
impl DhtTaskQueue {
pub fn new() -> Self {
Self {
immediate: TaskExecutor::new(15),
periodic1: TaskExecutor::new(5),
periodic2: TaskExecutor::new(5),
}
}
pub fn add_immediate(&mut self, task: Box<dyn DhtTask>) {
self.immediate.add_task(task);
}
pub fn add_periodic1(&mut self, task: Box<dyn DhtTask>) {
self.periodic1.add_task(task);
}
pub fn add_periodic2(&mut self, task: Box<dyn DhtTask>) {
self.periodic2.add_task(task);
}
pub fn execute(&mut self) {
self.immediate.update();
self.periodic1.update();
self.periodic2.update();
}
pub fn total_tasks(&self) -> usize {
self.immediate.running_count()
+ self.immediate.queue_size()
+ self.periodic1.running_count()
+ self.periodic1.queue_size()
+ self.periodic2.running_count()
+ self.periodic2.queue_size()
}
}
impl Default for DhtTaskQueue {
fn default() -> Self {
Self::new()
}
}