use crate::search::{Capabilities, SearchProvider};
use crate::types::{ErrorInfo, FileQuery};
use futures::StreamExt;
use std::sync::Arc;
use std::time::Duration;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ProbeStatus {
Results(usize),
Empty,
Skipped,
Failed(ErrorInfo),
Timeout,
}
impl ProbeStatus {
pub fn is_failure(&self) -> bool {
matches!(self, ProbeStatus::Failed(_) | ProbeStatus::Timeout)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ProviderProbe {
pub provider: String,
pub status: ProbeStatus,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ProviderCapabilities {
pub provider: String,
pub capabilities: Capabilities,
pub answered: bool,
}
pub async fn provider_capabilities(
providers: Vec<Arc<dyn SearchProvider>>,
timeout: Duration,
) -> Vec<ProviderCapabilities> {
let checks = providers.into_iter().map(|provider| async move {
let name = provider.name().to_owned();
match tokio::time::timeout(timeout, provider.capabilities()).await {
Ok(capabilities) => ProviderCapabilities {
provider: name,
capabilities,
answered: true,
},
Err(_) => ProviderCapabilities {
provider: name,
capabilities: Capabilities::universal(),
answered: false,
},
}
});
futures::future::join_all(checks).await
}
pub async fn probe(
query: FileQuery,
providers: Vec<Arc<dyn SearchProvider>>,
timeout: Duration,
) -> Vec<ProviderProbe> {
let checks = providers.into_iter().map(|provider| {
let probe = query.clone();
async move {
let name = provider.name().to_owned();
if !provider.capabilities().await.accepts(&probe) {
return ProviderProbe {
provider: name,
status: ProbeStatus::Skipped,
};
}
let mut stream = provider.search(&probe);
let mut count = 0usize;
let mut failure = None;
let finished = tokio::time::timeout(timeout, async {
while let Some(item) = stream.next().await {
match item {
Ok(_) => count += 1,
Err(error) => {
failure = Some(error);
break;
}
}
}
})
.await;
let status = if finished.is_err() {
ProbeStatus::Timeout
} else if let Some(error) = failure {
ProbeStatus::Failed(ErrorInfo {
code: error.code,
message: error.message,
})
} else if count == 0 {
ProbeStatus::Empty
} else {
ProbeStatus::Results(count)
};
ProviderProbe {
provider: name,
status,
}
}
});
futures::future::join_all(checks).await
}