use std::collections::VecDeque;
use std::fmt;
use std::panic::AssertUnwindSafe;
use std::sync::Arc;
use futures::FutureExt;
use tokio::sync::{Mutex, Notify, OwnedSemaphorePermit, Semaphore};
use tokio_util::sync::CancellationToken;
use tracing::{debug, trace, warn};
#[allow(clippy::double_must_use)]
#[async_trait::async_trait]
pub trait DhtTask: Send + fmt::Debug {
async fn run(self: Box<Self>);
fn name(&self) -> &'static str;
}
pub type BoxedDhtTask = Box<dyn DhtTask>;
pub const DEFAULT_NUM_CONCURRENT: usize = 15;
pub struct DhtTaskExecutor {
inner: Arc<Mutex<DhtTaskExecutorInner>>,
semaphore: Arc<Semaphore>,
num_concurrent: usize,
shutdown: CancellationToken,
idle_notify: Arc<Notify>,
}
struct DhtTaskExecutorInner {
queue: VecDeque<BoxedDhtTask>,
executing: usize,
peak_queue_size: usize,
}
impl DhtTaskExecutor {
pub fn new(num_concurrent: usize) -> Self {
let num_concurrent = num_concurrent.max(1);
Self {
inner: Arc::new(Mutex::new(DhtTaskExecutorInner {
queue: VecDeque::new(),
executing: 0,
peak_queue_size: 0,
})),
semaphore: Arc::new(Semaphore::new(num_concurrent)),
num_concurrent,
shutdown: CancellationToken::new(),
idle_notify: Arc::new(Notify::new()),
}
}
pub fn concurrency_limit(&self) -> usize {
self.num_concurrent
}
pub fn is_cancelled(&self) -> bool {
self.shutdown.is_cancelled()
}
pub async fn add_task(&self, task: BoxedDhtTask) -> bool {
if self.shutdown.is_cancelled() {
return false;
}
let task_name = task.name();
let mut inner = self.inner.lock().await;
if self.shutdown.is_cancelled() {
return false;
}
inner.queue.push_back(task);
inner.peak_queue_size = inner.peak_queue_size.max(inner.queue.len());
trace!(
task = task_name,
queue_len = inner.queue.len(),
executing = inner.executing,
"DHT task enqueued"
);
drop(inner);
self.dispatch_pending().await;
true
}
pub async fn try_add_task_if_idle(&self, task: BoxedDhtTask) -> bool {
if self.shutdown.is_cancelled() {
return false;
}
let task_name = task.name();
let mut inner = self.inner.lock().await;
if self.shutdown.is_cancelled() {
return false;
}
if inner.executing != 0 || !inner.queue.is_empty() {
return false;
}
inner.queue.push_back(task);
inner.peak_queue_size = inner.peak_queue_size.max(inner.queue.len());
trace!(task = task_name, "DHT idle periodic task enqueued");
drop(inner);
self.dispatch_pending().await;
true
}
pub async fn executing_count(&self) -> usize {
self.inner.lock().await.executing
}
pub async fn queue_size(&self) -> usize {
self.inner.lock().await.queue.len()
}
pub async fn peak_queue_size(&self) -> usize {
self.inner.lock().await.peak_queue_size
}
async fn dispatch_pending(&self) {
if self.shutdown.is_cancelled() {
return;
}
let sem = Arc::clone(&self.semaphore);
loop {
let task = {
let mut inner = self.inner.lock().await;
if inner.queue.is_empty() {
break;
}
inner.queue.pop_front()
};
let Some(task) = task else { break };
let task_name = task.name();
match sem.clone().try_acquire_owned() {
Ok(permit) => {
let mut inner = self.inner.lock().await;
inner.executing += 1;
drop(inner);
debug!(task = task_name, "DHT task dispatched");
self.spawn_task(task, permit);
}
Err(_) => {
let mut inner = self.inner.lock().await;
if !self.shutdown.is_cancelled() {
inner.queue.push_front(task);
}
break;
}
}
}
}
async fn run_task(task: BoxedDhtTask, shutdown: &CancellationToken) {
let task_name = task.name();
let result = AssertUnwindSafe(async {
tokio::select! {
_ = shutdown.cancelled() => {}
_ = task.run() => {}
}
})
.catch_unwind()
.await;
if result.is_err() {
warn!(task = task_name, "DHT task panicked; executor continues");
}
}
fn spawn_task(&self, task: BoxedDhtTask, _permit: OwnedSemaphorePermit) {
let inner = Arc::clone(&self.inner);
let semaphore = Arc::clone(&self.semaphore);
let shutdown = self.shutdown.clone();
let idle_notify = Arc::clone(&self.idle_notify);
let run_and_redispatch = async move {
let _held = _permit;
Self::run_task(task, &shutdown).await;
{
let mut guard = inner.lock().await;
guard.executing = guard.executing.saturating_sub(1);
}
idle_notify.notify_one();
drop(_held);
loop {
if shutdown.is_cancelled() {
let mut guard = inner.lock().await;
guard.queue.clear();
break;
}
let next_task = {
let mut guard = inner.lock().await;
guard.queue.pop_front()
};
let Some(next_task) = next_task else { break };
match semaphore.clone().try_acquire_owned() {
Ok(permit) => {
{
let mut guard = inner.lock().await;
guard.executing += 1;
}
debug!(
task = next_task.name(),
"DHT task dispatched (after completion)"
);
let _held2 = permit;
Self::run_task(next_task, &shutdown).await;
{
let mut guard = inner.lock().await;
guard.executing = guard.executing.saturating_sub(1);
}
idle_notify.notify_one();
drop(_held2);
}
Err(_) => {
let mut guard = inner.lock().await;
if !shutdown.is_cancelled() {
guard.queue.push_front(next_task);
}
break;
}
}
}
};
tokio::spawn(run_and_redispatch);
}
pub async fn shutdown(&self) {
self.cancel();
self.inner.lock().await.queue.clear();
loop {
let notified = self.idle_notify.notified();
if self.executing_count().await == 0 {
break;
}
notified.await;
}
}
pub fn cancel(&self) {
self.shutdown.cancel();
}
}
impl fmt::Debug for DhtTaskExecutor {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DhtTaskExecutor")
.field("num_concurrent", &self.num_concurrent)
.finish()
}
}