use std::collections::HashSet;
use std::sync::Arc;
use crate::cache::{Cache, Queue};
use crate::{
config::ResolverConfig,
error::Error,
orchestrate::{resolve_core, Resolution, UnresolvedReason},
Resolver,
};
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct DrainSummary {
pub resolved: usize,
pub unresolved: usize,
pub still_pending: usize,
}
pub struct BatchResolver<R: Resolver> {
resolver: R,
cache: Arc<dyn Cache>,
queue: Arc<dyn Queue>,
config: ResolverConfig,
batch_size: usize,
}
impl<R: Resolver> BatchResolver<R> {
pub fn new(
resolver: R,
cache: impl Cache + 'static,
queue: impl Queue + 'static,
config: ResolverConfig,
) -> Self {
Self { resolver, cache: Arc::new(cache), queue: Arc::new(queue), config, batch_size: 16 }
}
#[must_use]
pub fn with_batch_size(mut self, n: usize) -> Self {
self.batch_size = n.max(1);
self
}
pub fn queue(&self) -> &dyn Queue {
self.queue.as_ref()
}
pub async fn enqueue(&self, id: &str, query: &str) -> Result<(), Error> {
self.queue.enqueue(id, query).await?;
Ok(())
}
pub async fn drain(&self) -> Result<DrainSummary, Error> {
let mut summary = DrainSummary::default();
let mut seen: HashSet<String> = HashSet::new();
loop {
let batch = self.queue.claim_pending(self.batch_size).await?;
let fresh: Vec<_> = batch.into_iter().filter(|it| !seen.contains(&it.id)).collect();
if fresh.is_empty() {
break;
}
for item in fresh {
seen.insert(item.id.clone());
match resolve_core(&self.resolver, self.cache.as_ref(), &self.config, &item.query)
.await?
{
Resolution::Resolved(target) => {
self.queue.mark_resolved(&item.id, target.id).await?;
summary.resolved += 1;
}
Resolution::Unresolved { reason: UnresolvedReason::Offline, .. } => {
self.queue.release(&item.id).await?;
summary.still_pending += 1;
}
Resolution::Unresolved { .. } => {
self.queue.mark_unresolved(&item.id).await?;
summary.unresolved += 1;
}
}
}
}
Ok(summary)
}
}