use log::info;
use std::sync::Arc;
use crate::bootstrap::fluxweir_gateway::FluxweirGatewayHandle;
use crate::bootstrap::infrastructure::InfrastructureComponents;
use crate::bootstrap::infrastructure::Repositories;
use crate::config::settings::Settings;
use crate::domain::services::content_extractor::ContentExtractionFacade;
use crate::domain::services::content_extractor::QualityGateConfig;
use crate::domain::services::extraction_service::{ExtractionService, ExtractionServiceTrait};
use crate::domain::services::llm::{ExplicitErrorCarrier, LLMServiceTrait};
use crate::domain::services::rag_strategy::{
ChunkerConfig, EmbeddingProvider, FallbackEmbeddingProvider, RagExtractionRuntime,
};
use crate::domain::services::rerank::{FallbackRerankProvider, RerankProvider, SearchReranker};
use crate::domain::services::search_service::{SearchService, SearchServiceTrait};
use crate::domain::services::searxng::{
ReqwestSearxngTransport, SearxngInstanceService, SearxngInstanceServiceImpl,
};
use crate::engines::engine_client::EngineClient;
use crate::search::client::SearchClientTrait;
use crate::search::engine_trait::SearchEngine;
use crate::search::smart as smart_search;
use crate::utils::robots::RobotsChecker;
#[cfg(feature = "gateway")]
use crate::infrastructure::services::fluxweir_providers::{
build_client as build_fluxweir_client, FluxweirEmbeddingProvider, FluxweirRerankProvider,
FLUXWEIR_EMBED_MODEL, FLUXWEIR_RERANK_MODEL,
};
use crate::infrastructure::services::http_rerank_provider::{HttpRerankProvider, RerankFormat};
#[cfg(feature = "rag-local")]
use crate::infrastructure::services::vecboost_provider::VecboostProvider;
pub(super) struct SearchStack {
pub(super) robots_checker: Arc<RobotsChecker>,
pub(super) search_engine_service: Arc<dyn SearchEngine>,
pub(super) search_service: Arc<dyn SearchServiceTrait>,
pub(super) searxng_instances: Option<Arc<dyn SearxngInstanceService>>,
pub(super) embedding_provider: Option<Arc<dyn EmbeddingProvider>>,
pub(super) rerank_provider: Option<Arc<dyn RerankProvider>>,
pub(super) fluxweir_gateway: FluxweirGatewayHandle,
}
pub(super) async fn init_search_stack(
infrastructure: &InfrastructureComponents,
settings: &Settings,
http_client: &Arc<reqwest::Client>,
engine_client: &Arc<EngineClient>,
) -> SearchStack {
let repositories = &infrastructure.repositories;
let robots_checker = Arc::new(RobotsChecker::new(
http_client.clone(),
&settings.robots,
Some(infrastructure.cache_service.clone()),
None,
));
let searxng = init_searxng_services(repositories, settings, http_client);
let search_engine_service: Arc<dyn SearchEngine> =
init_search_engine(engine_client.clone(), settings, searxng.engine);
let search_client: Arc<dyn SearchClientTrait> = Arc::new(
crate::search::client::SearchClient::with_configured_engines(
engine_client.clone(),
http_client.clone(),
&settings.search,
searxng.instances.clone(),
),
);
let rag = init_rag_or_panic(settings).await;
let search_reranker = Arc::new(SearchReranker::new(
rag.rerank.clone(),
settings.rag.search_rerank_top_n,
));
let fluxweir_gateway = init_fluxweir_gateway_or_panic(infrastructure, settings).await;
let search_service = init_search_service(
repositories,
settings,
search_client.clone(),
search_reranker,
Some(search_engine_service.clone()),
);
SearchStack {
robots_checker,
search_engine_service,
search_service,
searxng_instances: searxng.instances,
embedding_provider: rag.embedding,
rerank_provider: rag.rerank,
fluxweir_gateway,
}
}
async fn init_rag_or_panic(settings: &Settings) -> RagComponents {
match init_rag_components(settings).await {
Ok(components) => components,
Err(e) => panic!("RAG capability init failed (check [rag] config / features): {e}"),
}
}
async fn init_fluxweir_gateway_or_panic(
infrastructure: &InfrastructureComponents,
settings: &Settings,
) -> FluxweirGatewayHandle {
match crate::bootstrap::fluxweir_gateway::init_fluxweir_gateway(
settings,
Some(infrastructure.db.clone_inner()),
&settings.database.url,
)
.await
{
Ok(handle) => handle,
Err(e) => {
panic!("fluxweir gateway init failed (check [fluxweir] config / features): {e:#}")
}
}
}
struct SearxngStack {
instances: Option<Arc<dyn SearxngInstanceService>>,
engine: Option<Arc<dyn SearchEngine>>,
}
fn init_searxng_services(
repositories: &Repositories,
settings: &Settings,
http_client: &Arc<reqwest::Client>,
) -> SearxngStack {
let searxng_transport: Option<Arc<dyn crate::domain::services::searxng::SearxngTransport>> =
if settings.search.searxng.enabled {
Some(Arc::new(ReqwestSearxngTransport::new(
http_client.clone(),
settings.search.searxng.user_agent.clone(),
)))
} else {
None
};
let searxng_instances: Option<Arc<dyn SearxngInstanceService>> =
match searxng_transport.as_ref() {
Some(transport) => {
let concrete = Arc::new(SearxngInstanceServiceImpl::new(
repositories.searxng_instance_repo.clone(),
transport.clone(),
settings.search.searxng.clone(),
));
concrete.spawn_bootstrap();
info!(
"SearXNG instance service enabled (pool_target={})",
settings.search.searxng.pool_target
);
Some(concrete as Arc<dyn SearxngInstanceService>)
}
None => {
info!("SearXNG disabled by config (search.searxng.enabled=false)");
None
}
};
let searxng_search_engine: Option<Arc<dyn SearchEngine>> =
match (searxng_instances.as_ref(), searxng_transport.as_ref()) {
(Some(service), Some(transport)) => Some(Arc::new(
crate::search::client::searxng::SearxngSearchEngine::new(
service.clone(),
transport.clone(),
std::time::Duration::from_secs(settings.search.timeout_seconds),
settings.search.searxng.max_failover_attempts,
),
) as Arc<dyn SearchEngine>),
_ => None,
};
SearxngStack {
instances: searxng_instances,
engine: searxng_search_engine,
}
}
pub(super) struct LlmStack {
pub(super) llm_service: Arc<dyn LLMServiceTrait>,
pub(super) extraction_service: Arc<dyn ExtractionServiceTrait>,
pub(super) content_extractor: Arc<ContentExtractionFacade>,
}
pub(super) fn init_llm_stack(
settings: &Settings,
http_client: &Arc<reqwest::Client>,
fluxweir_gateway: &FluxweirGatewayHandle,
embedding_provider: Option<Arc<dyn EmbeddingProvider>>,
) -> LlmStack {
let llm_service = init_llm_service(settings, http_client.clone(), fluxweir_gateway);
let extraction_service: Arc<dyn ExtractionServiceTrait> =
match &embedding_provider {
Some(provider) => Arc::new(ExtractionService::new(llm_service.clone()).with_rag(
Arc::new(RagExtractionRuntime::new(
ChunkerConfig::default(),
provider.clone(),
settings.rag.rag_top_k,
)),
)),
None => Arc::new(ExtractionService::new(llm_service.clone())),
};
let content_extractor = Arc::new(ContentExtractionFacade::with_quality_config(
Some(llm_service.clone()),
QualityGateConfig::active(
settings.content_extraction.min_word_count,
settings.content_extraction.replacement_length_ratio,
settings.content_extraction.prose_min_sentence_words,
settings.content_extraction.prose_max_link_density,
),
));
LlmStack {
llm_service,
extraction_service,
content_extractor,
}
}
pub(super) fn init_search_engine(
engine_client: Arc<EngineClient>,
settings: &Settings,
searxng_engine: Option<Arc<dyn SearchEngine>>,
) -> Arc<dyn SearchEngine> {
info!("Initializing SmartSearchEngine (concurrent Baidu+Bing+Sogou + RRF fusion)");
let mut engine = smart_search::SmartSearchEngine::new(engine_client)
.with_engine_timeout(settings.search.timeout_seconds);
if let Some(extra) = searxng_engine {
info!("SearXNG joins smart aggregation fan-out (RRF)");
engine = engine.with_additional_engine(extra);
}
Arc::new(engine)
}
pub(super) fn init_search_service(
repositories: &Repositories,
settings: &Settings,
search_client: Arc<dyn SearchClientTrait>,
reranker: Arc<SearchReranker>,
smart_engine: Option<Arc<dyn SearchEngine>>,
) -> Arc<dyn SearchServiceTrait> {
let mut service = SearchService::new(
repositories.crawl_repo.clone(),
repositories.task_repo.clone(),
repositories.credits_repo.clone(),
Arc::new(settings.clone()),
search_client,
reranker,
);
if let Some(smart) = smart_engine {
service = service.with_smart_engine(smart);
}
Arc::new(service)
}
pub(super) struct RagComponents {
pub(super) embedding: Option<Arc<dyn EmbeddingProvider>>,
pub(super) rerank: Option<Arc<dyn RerankProvider>>,
}
pub(super) async fn init_rag_components(settings: &Settings) -> Result<RagComponents, String> {
if !settings.rag.enabled {
return Ok(RagComponents {
embedding: None,
rerank: None,
});
}
settings.rag.validate_providers()?;
let rag = &settings.rag;
let fluxweir_fallback = build_rag_fallback(settings);
let embedding = resolve_embedding_provider(rag, fluxweir_fallback.as_ref()).await?;
let rerank = resolve_rerank_provider(rag, fluxweir_fallback).await?;
Ok(RagComponents { embedding, rerank })
}
type RagFallbackProviders = (Arc<dyn EmbeddingProvider>, Arc<dyn RerankProvider>);
#[cfg(feature = "gateway")]
fn build_rag_fallback(settings: &Settings) -> Option<RagFallbackProviders> {
if !(settings.fluxweir.enabled && settings.fluxweir.rag_fallback) {
return None;
}
match build_fluxweir_client(settings) {
Some(client) => {
log::info!(
"fluxweir RAG fallback enabled (embed={}, rerank={})",
FLUXWEIR_EMBED_MODEL,
FLUXWEIR_RERANK_MODEL
);
Some((
Arc::new(FluxweirEmbeddingProvider::new(
client.clone(),
FLUXWEIR_EMBED_MODEL,
settings.rag.local_dimensions,
)),
Arc::new(FluxweirRerankProvider::new(client, FLUXWEIR_RERANK_MODEL)),
))
}
None => {
log::warn!("fluxweir.enabled but API key unresolvable; RAG fallback disabled");
None
}
}
}
#[cfg(not(feature = "gateway"))]
fn build_rag_fallback(_settings: &Settings) -> Option<RagFallbackProviders> {
None
}
async fn resolve_embedding_provider(
rag: &crate::config::rag::RagSettings,
fluxweir_fallback: Option<&RagFallbackProviders>,
) -> Result<Option<Arc<dyn EmbeddingProvider>>, String> {
let embedding: Option<Arc<dyn EmbeddingProvider>> = match rag.embedding_provider.as_str() {
"" => None,
#[cfg(feature = "rag-local")]
"local" => match VecboostProvider::new(rag).await {
Ok(provider) => Some(Arc::new(provider)),
Err(e) if fluxweir_fallback.is_some() => {
log::warn!(
"vecboost embedding provider init failed, using fluxweir fallback only: {e}"
);
None
}
Err(e) => return Err(format!("vecboost embedding provider init failed: {e}")),
},
_ => None,
};
Ok(
match (embedding, fluxweir_fallback.map(|(e, _)| e.clone())) {
(Some(primary), Some(secondary)) => {
Some(Arc::new(FallbackEmbeddingProvider::new(primary, secondary))
as Arc<dyn EmbeddingProvider>)
}
(Some(primary), None) => Some(primary),
(None, Some(secondary)) => Some(secondary),
(None, None) => None,
},
)
}
async fn resolve_rerank_provider(
rag: &crate::config::rag::RagSettings,
fluxweir_fallback: Option<RagFallbackProviders>,
) -> Result<Option<Arc<dyn RerankProvider>>, String> {
let rerank: Option<Arc<dyn RerankProvider>> = match rag.rerank_provider.as_str() {
"" => None,
#[cfg(feature = "rag-local")]
"local" => match VecboostProvider::new(rag).await {
Ok(provider) => Some(Arc::new(provider)),
Err(e) if fluxweir_fallback.is_some() => {
log::warn!(
"vecboost rerank provider init failed, using fluxweir fallback only: {e}"
);
None
}
Err(e) => return Err(format!("vecboost rerank provider init failed: {e}")),
},
"http" => Some(Arc::new(
HttpRerankProvider::new(
&rag.rerank_endpoint,
Some(&rag.rerank_model),
RerankFormat::parse(&rag.rerank_format)
.map_err(|e| format!("rag rerank_format invalid: {e}"))?,
rag.rerank_api_key(),
rag.rerank_timeout_seconds,
)
.map_err(|e| format!("http rerank provider init failed: {e}"))?,
)),
_ => None,
};
Ok(match (rerank, fluxweir_fallback.map(|(_, r)| r)) {
(Some(primary), Some(secondary)) => {
Some(Arc::new(FallbackRerankProvider::new(primary, secondary))
as Arc<dyn RerankProvider>)
}
(Some(primary), None) => Some(primary),
(None, Some(secondary)) => Some(secondary),
(None, None) => None,
})
}
pub(super) fn init_llm_service(
#[cfg_attr(not(feature = "gateway"), allow(unused_variables))] settings: &Settings,
_http_client: Arc<reqwest::Client>,
#[cfg_attr(not(feature = "gateway"), allow(unused_variables))]
fluxweir_gateway: &crate::bootstrap::fluxweir_gateway::FluxweirGatewayHandle,
) -> Arc<dyn LLMServiceTrait> {
#[cfg(feature = "gateway")]
if settings.fluxweir.enabled {
let base_url = fluxweir_gateway
.base_url()
.expect("fluxweir gateway enabled but handle has no base_url (init order bug)")
.to_string();
let api_key = settings
.fluxweir
.api_key()
.expect("fluxweir enabled but no API key resolvable (validate order bug)");
let client = fluxweir::sdk::FluxweirClientBuilder::new()
.base_url(base_url)
.api_key(api_key)
.timeout(std::time::Duration::from_secs(
settings.fluxweir.request_timeout_secs,
))
.build()
.expect("fluxweir SDK client build failed");
log::info!(
"LLM carrier: FluxweirLlmCarrier via fluxweir gateway at {}",
fluxweir_gateway.base_url().unwrap_or("<unknown>")
);
return Arc::new(
crate::infrastructure::services::fluxweir_llm_carrier::FluxweirLlmCarrier::new(
client, settings,
),
);
}
let _ = fluxweir_gateway;
Arc::new(ExplicitErrorCarrier)
}
#[cfg(test)]
mod tests {
use super::*;
fn make_http_client() -> Arc<reqwest::Client> {
Arc::new(reqwest::Client::new())
}
fn make_engine_client() -> Arc<EngineClient> {
Arc::new(EngineClient::new())
}
#[tokio::test]
async fn test_init_llm_service_defaults_to_explicit_error_carrier() {
let settings = crate::bootstrap::config::load_settings().expect("Failed to load settings");
let http_client = make_http_client();
let service = init_llm_service(&settings, http_client, &Default::default());
let schema = serde_json::json!({"type": "object"});
let err = service
.extract_data("text", &schema, "json")
.await
.expect_err("默认装配必须显式失败");
let message = format!("{err:#}");
assert!(
message.contains("未接入承载方"),
"default carrier must be explicit: {message}"
);
assert!(
Arc::strong_count(&service) >= 1,
"init_llm_service should return a valid Arc"
);
}
#[test]
fn test_init_search_engine_creates_instance() {
let settings = crate::bootstrap::config::load_settings().expect("Failed to load settings");
let engine_client = make_engine_client();
let search_engine = init_search_engine(engine_client, &settings, None);
assert!(
Arc::strong_count(&search_engine) >= 1,
"init_search_engine should return a valid Arc<dyn SearchEngine>"
);
}
#[test]
fn test_init_search_engine_with_ab_test_disabled() {
let settings = crate::bootstrap::config::load_settings().expect("Failed to load settings");
let engine_client = make_engine_client();
let _search_engine = init_search_engine(engine_client, &settings, None);
}
#[test]
fn test_init_search_engine_with_ab_test_enabled() {
let settings = crate::bootstrap::config::load_settings().expect("Failed to load settings");
let engine_client = make_engine_client();
let _search_engine = init_search_engine(engine_client, &settings, None);
}
use crate::bootstrap::infrastructure::{init_database, init_repositories};
use crate::common::test_support::testcontainers_fixtures as tcf;
async fn require_docker() -> bool {
tcf::docker_available().await
}
#[tokio::test]
async fn tc_init_search_service_with_repos() {
if !require_docker().await {
eprintln!("[skip] Docker unavailable — tc_init_search_service_with_repos");
return;
}
let pg = match tcf::PgHandle::start().await {
Ok(p) => p,
Err(e) => {
eprintln!("[skip] failed to start postgres container: {e}");
return;
}
};
let settings = tcf::settings_with_urls(&pg.url).unwrap();
let db = match init_database(&settings).await {
Ok(d) => d,
Err(e) => {
eprintln!("[skip] failed to init database pool: {e}");
return;
}
};
let repos = init_repositories(db.clone(), &settings);
let engine_client = Arc::new(EngineClient::new());
let search_client: Arc<dyn SearchClientTrait> =
Arc::new(crate::search::client::SearchClient::new(engine_client));
let service = init_search_service(
&repos,
&settings,
search_client,
Arc::new(SearchReranker::new(None, 25)),
None,
);
assert!(Arc::strong_count(&service) >= 1);
}
}