use std::sync::Arc;
use std::time::Duration;
use async_trait::async_trait;
use thiserror::Error;
use crate::domain::repositories::searxng_instance_repository::SearxngInstance;
pub mod dataset;
pub mod http;
pub mod pool;
pub mod probe;
pub mod service;
mod collector;
#[cfg(test)]
pub(crate) mod test_support;
pub use dataset::{admit, parse_dataset, AdmissionReject, Dataset, DatasetEntry};
pub use http::ReqwestSearxngTransport;
pub use pool::InstancePool;
pub use probe::{probe_instance, probe_url, ProbeOutcome};
pub use service::SearxngInstanceServiceImpl;
#[derive(Debug, Clone, Error)]
pub enum SearxngError {
#[error("searxng network error: {0}")]
Network(String),
#[error("searxng request timed out after {0:?}")]
Timeout(Duration),
#[error("searxng returned HTTP status {0}")]
BadHttpStatus(u16),
#[error("searxng instance rate limited")]
RateLimited,
#[error("searxng parse error: {0}")]
Parse(String),
#[error("searxng dataset fetch failed: {0}")]
DatasetFetch(String),
#[error("searxng repository error: {0}")]
Repository(String),
#[error("searxng disabled")]
Disabled,
#[error("no searxng instance available")]
NoInstanceAvailable,
}
impl SearxngError {
pub fn from_status(status: u16) -> Self {
if status == 429 {
SearxngError::RateLimited
} else {
SearxngError::BadHttpStatus(status)
}
}
pub fn class(&self) -> &'static str {
match self {
SearxngError::Network(_) => "network",
SearxngError::Timeout(_) => "timeout",
SearxngError::BadHttpStatus(_) => "bad_http_status",
SearxngError::RateLimited => "rate_limited",
SearxngError::Parse(_) => "parse",
SearxngError::DatasetFetch(_) => "dataset_fetch",
SearxngError::Repository(_) => "repository",
SearxngError::Disabled => "disabled",
SearxngError::NoInstanceAvailable => "no_instance_available",
}
}
}
#[async_trait]
pub trait SearxngTransport: Send + Sync {
async fn get_json(
&self,
url: &str,
timeout: Duration,
) -> Result<(u16, serde_json::Value), SearxngError>;
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CollectorReport {
pub skipped: bool,
pub fetched: usize,
pub seen: usize,
pub admitted_new: usize,
pub updated: usize,
pub retired: usize,
pub errors: usize,
}
impl CollectorReport {
pub fn skipped() -> Self {
Self {
skipped: true,
..Default::default()
}
}
}
#[derive(Debug, Clone)]
pub struct PoolMember {
pub instance: SearxngInstance,
}
impl PoolMember {
pub fn url(&self) -> &str {
&self.instance.url
}
}
#[derive(Debug, Clone)]
pub enum InstanceOutcome {
Success {
latency_ms: i64,
},
Failure {
error: SearxngError,
},
}
impl InstanceOutcome {
pub fn is_success(&self) -> bool {
matches!(self, InstanceOutcome::Success { .. })
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum BreakerMirror {
Closed,
Open,
HalfOpen,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PoolMemberState {
pub url: String,
pub state: crate::domain::repositories::searxng_instance_repository::SearxngInstanceState,
pub latency_ms: Option<i64>,
pub breaker: BreakerMirror,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PoolSnapshot {
pub target: usize,
pub members: Vec<PoolMemberState>,
pub health: crate::search::types::EngineHealth,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct HealthReport {
pub probed: usize,
pub promoted: usize,
pub demoted: usize,
pub retired: usize,
pub errors: usize,
}
#[async_trait]
pub trait SearxngInstanceService: Send + Sync {
fn acquire(&self, exclude: &[String]) -> Option<Arc<PoolMember>>;
async fn report(&self, url: &str, outcome: InstanceOutcome);
async fn collect(&self) -> Result<CollectorReport, SearxngError>;
async fn health_cycle(&self) -> HealthReport;
async fn pool_snapshot(&self) -> PoolSnapshot;
async fn list_instances(
&self,
limit: u64,
offset: u64,
) -> Result<Vec<SearxngInstance>, SearxngError>;
fn health(&self) -> crate::search::types::EngineHealth;
}