use std::sync::Arc;
use trait_kit::{AsyncKit, AsyncReady};
use crate::application::use_cases::create_scrape::CreateScrapeUseCaseTrait;
use crate::di::modules::{
EngineModule, IdModule, InfrastructureModule, ModuleBuildError, ServiceModule, SettingsModule,
};
use crate::domain::repositories::crawl_repository::CrawlRepository;
use crate::domain::repositories::credits_repository::CreditsRepository;
#[cfg(feature = "teams")]
use crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository;
use crate::domain::repositories::scrape_result_repository::ScrapeResultRepository;
use crate::domain::repositories::task_repository::TaskRepository;
use crate::domain::repositories::tasks_backlog_repository::TasksBacklogRepository;
#[cfg(feature = "webhook")]
use crate::domain::repositories::webhook_event_repository::WebhookEventRepository;
#[cfg(feature = "webhook")]
use crate::domain::repositories::webhook_repository::WebhookRepository;
use crate::domain::services::audit_service::AuditServiceTrait;
use crate::domain::services::content_extractor::ContentExtractionFacade;
use crate::domain::services::extraction_service::ExtractionServiceTrait;
#[cfg(feature = "teams")]
use crate::domain::services::geo_location::GeoLocationService;
use crate::domain::services::id_service::IdService;
use crate::domain::services::llm::LLMServiceTrait;
use crate::domain::services::rag_strategy::EmbeddingProvider;
use crate::domain::services::rate_limiting_service::RateLimitingService;
use crate::domain::services::rerank::RerankProvider;
use crate::domain::services::search_service::SearchServiceTrait;
use crate::domain::services::searxng::SearxngInstanceService;
use crate::domain::services::team_semaphore::TeamSemaphore;
#[cfg(feature = "teams")]
use crate::domain::services::team_service::TeamService;
use crate::domain::services::webhook_service::WebhookService;
use crate::engines::engine_client::EngineClient;
use crate::engines::router::EngineRouter;
use crate::i18n::I18nBundle;
use crate::queue::task_queue::TaskQueue;
use crate::search::client::SearchClient;
use crate::infrastructure::events::{BroadcastEventBus, EventBus};
use crate::infrastructure::oxcache::CacheService;
use crate::utils::robots::RobotsCheckerTrait;
use crate::workers::coalesce_coordinator::RequestCoalescer;
use dbnexus::DbPool;
#[derive(Clone)]
pub struct CrawlRsState {
pub db_pool: Arc<DbPool>,
pub id_service: Arc<IdService>,
pub task_repo: Arc<dyn TaskRepository>,
pub credits_repo: Arc<dyn CreditsRepository>,
pub crawl_repo: Arc<dyn CrawlRepository>,
pub result_repo: Arc<dyn ScrapeResultRepository>,
#[cfg(feature = "webhook")]
pub webhook_repo: Arc<dyn WebhookRepository>,
#[cfg(feature = "webhook")]
pub webhook_event_repo: Arc<dyn WebhookEventRepository>,
pub tasks_backlog_repo: Arc<dyn TasksBacklogRepository>,
pub task_queue: Arc<dyn TaskQueue>,
pub rate_limiting_service: Arc<dyn RateLimitingService>,
#[cfg(feature = "teams")]
pub team_service: Arc<TeamService>,
pub webhook_service: Arc<dyn WebhookService>,
pub robots_checker: Arc<dyn RobotsCheckerTrait>,
pub team_semaphore: Arc<TeamSemaphore>,
pub request_coalescer: Arc<RequestCoalescer>,
pub engine_router: Arc<EngineRouter>,
pub engine_client: Arc<EngineClient>,
pub create_scrape_use_case: Arc<dyn CreateScrapeUseCaseTrait>,
pub search_client: Arc<SearchClient>,
pub search_service: Arc<dyn SearchServiceTrait>,
pub searxng_instances: Option<Arc<dyn SearxngInstanceService>>,
pub llm_service: Arc<dyn LLMServiceTrait>,
pub extraction_service: Arc<dyn ExtractionServiceTrait>,
pub embedding_provider: Option<Arc<dyn EmbeddingProvider>>,
pub rerank_provider: Option<Arc<dyn RerankProvider>>,
pub fluxweir_gateway: crate::bootstrap::fluxweir_gateway::FluxweirGatewayHandle,
pub content_extractor: Arc<ContentExtractionFacade>,
pub cache_service: Arc<dyn CacheService>,
pub audit_service: Arc<dyn AuditServiceTrait>,
#[cfg(feature = "webhook")]
pub webhook_worker: Arc<crate::workers::webhook_worker::WebhookWorker>,
pub backlog_worker: Arc<crate::workers::backlog_worker::BacklogWorker>,
pub expiration_worker: Arc<crate::workers::expiration_worker::ExpirationWorker>,
#[cfg(feature = "teams")]
pub geo_location_service: Arc<dyn GeoLocationService>,
#[cfg(feature = "teams")]
pub geo_restriction_repo: Arc<dyn GeoRestrictionRepository>,
pub i18n_bundle: Arc<I18nBundle>,
pub event_bus: Arc<dyn EventBus>,
#[cfg(feature = "sitemap")]
pub map_use_case: Arc<crate::application::use_cases::map_use_case::MapUseCase>,
}
impl CrawlRsState {
pub fn from_kit(kit: &AsyncKit<AsyncReady>) -> Result<Self, ModuleBuildError> {
let infra = kit.require::<InfrastructureModule>()?;
let engines = kit.require::<EngineModule>()?;
let services = kit.require::<ServiceModule>()?;
let settings = kit.require::<SettingsModule>()?;
let id_service = kit.require::<IdModule>()?;
let search_client = Arc::new(SearchClient::new(engines.engine_client.clone()));
let i18n_bundle = load_i18n_bundle(&settings)?;
Ok(CrawlRsState {
db_pool: infra.db.inner().clone(),
id_service,
task_repo: infra.repositories.task_repo.clone(),
credits_repo: infra.repositories.credits_repo.clone(),
crawl_repo: infra.repositories.crawl_repo.clone(),
result_repo: infra.repositories.result_repo.clone(),
#[cfg(feature = "webhook")]
webhook_repo: infra.repositories.webhook_repo.clone(),
#[cfg(feature = "webhook")]
webhook_event_repo: infra.repositories.webhook_event_repo.clone(),
tasks_backlog_repo: infra.repositories.tasks_backlog_repo.clone(),
task_queue: services.queue.clone(),
rate_limiting_service: services.rate_limiting_service.clone(),
#[cfg(feature = "teams")]
team_service: services.team_service.clone(),
webhook_service: services.webhook_service.clone(),
robots_checker: services.robots_checker.clone(),
team_semaphore: services.team_semaphore.clone(),
request_coalescer: services.request_coalescer.clone(),
engine_router: engines.router.clone(),
engine_client: engines.engine_client.clone(),
create_scrape_use_case: services.create_scrape_use_case.clone(),
search_client,
search_service: services.search_service.clone(),
searxng_instances: services.searxng_instances.clone(),
llm_service: services.llm_service.clone(),
extraction_service: services.extraction_service.clone(),
embedding_provider: services.embedding_provider.clone(),
rerank_provider: services.rerank_provider.clone(),
fluxweir_gateway: services.fluxweir_gateway.clone(),
content_extractor: services.content_extractor.clone(),
cache_service: infra.cache_service.clone(),
audit_service: services.audit_service.clone(),
#[cfg(feature = "webhook")]
webhook_worker: services.webhook_worker.clone(),
backlog_worker: services.backlog_worker.clone(),
expiration_worker: services.expiration_worker.clone(),
#[cfg(feature = "teams")]
geo_location_service: services.geo_location_service.clone(),
#[cfg(feature = "teams")]
geo_restriction_repo: infra.repositories.geo_restriction_repo.clone(),
i18n_bundle,
event_bus: Arc::new(BroadcastEventBus::new(1024)),
#[cfg(feature = "sitemap")]
map_use_case: services.map_use_case.clone(),
})
}
}
fn load_i18n_bundle(
settings: &crate::config::settings::Settings,
) -> Result<Arc<I18nBundle>, ModuleBuildError> {
let supported: Vec<&str> = settings
.i18n
.supported_locales
.iter()
.map(|s| s.as_str())
.collect();
let default_locale =
crate::i18n::resolve_startup_default_locale(&settings.i18n.default_locale, &supported);
if default_locale.to_string() != settings.i18n.default_locale {
log::info!(
"i18n default_locale resolved to '{}' (configured '{}')",
default_locale,
settings.i18n.default_locale
);
}
let i18n_bundle = Arc::new(
I18nBundle::load(&default_locale.to_string(), &supported).map_err(|e| {
ModuleBuildError::SettingsNotConfigured(format!("i18n load failed: {e}"))
})?,
);
let warnings = i18n_bundle.validate_key_consistency();
for w in &warnings {
log::warn!("i18n key consistency: {w}");
}
Ok(i18n_bundle)
}
pub trait CrawlRsStateExt {
fn task_repo(&self) -> Arc<dyn TaskRepository>;
fn credits_repo(&self) -> Arc<dyn CreditsRepository>;
fn crawl_repo(&self) -> Arc<dyn CrawlRepository>;
fn result_repo(&self) -> Arc<dyn ScrapeResultRepository>;
#[cfg(feature = "webhook")]
fn webhook_repo(&self) -> Arc<dyn WebhookRepository>;
#[cfg(feature = "webhook")]
fn webhook_event_repo(&self) -> Arc<dyn WebhookEventRepository>;
fn rate_limiting_service(&self) -> Arc<dyn RateLimitingService>;
#[cfg(feature = "teams")]
fn team_service(&self) -> Arc<TeamService>;
fn webhook_service(&self) -> Arc<dyn WebhookService>;
fn engine_router(&self) -> Arc<EngineRouter>;
fn engine_client(&self) -> Arc<EngineClient>;
fn create_scrape_use_case(&self) -> Arc<dyn CreateScrapeUseCaseTrait>;
fn search_client(&self) -> Arc<SearchClient>;
fn search_service(&self) -> Arc<dyn SearchServiceTrait>;
fn searxng_instances(&self) -> Option<Arc<dyn SearxngInstanceService>>;
fn llm_service(&self) -> Arc<dyn LLMServiceTrait>;
fn cache_service(&self) -> Arc<dyn CacheService>;
fn db_pool(&self) -> Arc<DbPool>;
fn id_service(&self) -> Arc<IdService>;
fn tasks_backlog_repo(&self) -> Arc<dyn TasksBacklogRepository>;
fn task_queue(&self) -> Arc<dyn TaskQueue>;
fn robots_checker(&self) -> Arc<dyn RobotsCheckerTrait>;
fn team_semaphore(&self) -> Arc<TeamSemaphore>;
fn request_coalescer(&self) -> Arc<RequestCoalescer>;
fn audit_service(&self) -> Arc<dyn AuditServiceTrait>;
fn extraction_service(&self) -> Arc<dyn ExtractionServiceTrait>;
fn embedding_provider(&self) -> Option<Arc<dyn EmbeddingProvider>>;
fn rerank_provider(&self) -> Option<Arc<dyn RerankProvider>>;
fn fluxweir_gateway(&self) -> crate::bootstrap::fluxweir_gateway::FluxweirGatewayHandle;
fn content_extractor(&self) -> Arc<ContentExtractionFacade>;
#[cfg(feature = "webhook")]
fn webhook_worker(&self) -> Arc<crate::workers::webhook_worker::WebhookWorker>;
fn backlog_worker(&self) -> Arc<crate::workers::backlog_worker::BacklogWorker>;
fn expiration_worker(&self) -> Arc<crate::workers::expiration_worker::ExpirationWorker>;
#[cfg(feature = "teams")]
fn geo_location_service(&self) -> Arc<dyn GeoLocationService>;
#[cfg(feature = "teams")]
fn geo_restriction_repo(&self) -> Arc<dyn GeoRestrictionRepository>;
fn i18n_bundle(&self) -> Arc<I18nBundle>;
fn event_bus(&self) -> Arc<dyn EventBus>;
}
impl CrawlRsStateExt for CrawlRsState {
fn task_repo(&self) -> Arc<dyn TaskRepository> {
self.task_repo.clone()
}
fn credits_repo(&self) -> Arc<dyn CreditsRepository> {
self.credits_repo.clone()
}
fn crawl_repo(&self) -> Arc<dyn CrawlRepository> {
self.crawl_repo.clone()
}
fn result_repo(&self) -> Arc<dyn ScrapeResultRepository> {
self.result_repo.clone()
}
#[cfg(feature = "webhook")]
fn webhook_repo(&self) -> Arc<dyn WebhookRepository> {
self.webhook_repo.clone()
}
#[cfg(feature = "webhook")]
fn webhook_event_repo(&self) -> Arc<dyn WebhookEventRepository> {
self.webhook_event_repo.clone()
}
fn rate_limiting_service(&self) -> Arc<dyn RateLimitingService> {
self.rate_limiting_service.clone()
}
#[cfg(feature = "teams")]
fn team_service(&self) -> Arc<TeamService> {
self.team_service.clone()
}
fn webhook_service(&self) -> Arc<dyn WebhookService> {
self.webhook_service.clone()
}
fn engine_router(&self) -> Arc<EngineRouter> {
self.engine_router.clone()
}
fn engine_client(&self) -> Arc<EngineClient> {
self.engine_client.clone()
}
fn create_scrape_use_case(&self) -> Arc<dyn CreateScrapeUseCaseTrait> {
self.create_scrape_use_case.clone()
}
fn search_client(&self) -> Arc<SearchClient> {
self.search_client.clone()
}
fn search_service(&self) -> Arc<dyn SearchServiceTrait> {
self.search_service.clone()
}
fn searxng_instances(&self) -> Option<Arc<dyn SearxngInstanceService>> {
self.searxng_instances.clone()
}
fn llm_service(&self) -> Arc<dyn LLMServiceTrait> {
self.llm_service.clone()
}
fn cache_service(&self) -> Arc<dyn CacheService> {
self.cache_service.clone()
}
fn db_pool(&self) -> Arc<DbPool> {
self.db_pool.clone()
}
fn id_service(&self) -> Arc<IdService> {
self.id_service.clone()
}
fn tasks_backlog_repo(&self) -> Arc<dyn TasksBacklogRepository> {
self.tasks_backlog_repo.clone()
}
fn task_queue(&self) -> Arc<dyn TaskQueue> {
self.task_queue.clone()
}
fn robots_checker(&self) -> Arc<dyn RobotsCheckerTrait> {
self.robots_checker.clone()
}
fn team_semaphore(&self) -> Arc<TeamSemaphore> {
self.team_semaphore.clone()
}
fn request_coalescer(&self) -> Arc<RequestCoalescer> {
self.request_coalescer.clone()
}
fn audit_service(&self) -> Arc<dyn AuditServiceTrait> {
self.audit_service.clone()
}
fn extraction_service(&self) -> Arc<dyn ExtractionServiceTrait> {
self.extraction_service.clone()
}
fn embedding_provider(&self) -> Option<Arc<dyn EmbeddingProvider>> {
self.embedding_provider.clone()
}
fn rerank_provider(&self) -> Option<Arc<dyn RerankProvider>> {
self.rerank_provider.clone()
}
fn fluxweir_gateway(&self) -> crate::bootstrap::fluxweir_gateway::FluxweirGatewayHandle {
self.fluxweir_gateway.clone()
}
fn content_extractor(&self) -> Arc<ContentExtractionFacade> {
self.content_extractor.clone()
}
#[cfg(feature = "webhook")]
fn webhook_worker(&self) -> Arc<crate::workers::webhook_worker::WebhookWorker> {
self.webhook_worker.clone()
}
fn backlog_worker(&self) -> Arc<crate::workers::backlog_worker::BacklogWorker> {
self.backlog_worker.clone()
}
fn expiration_worker(&self) -> Arc<crate::workers::expiration_worker::ExpirationWorker> {
self.expiration_worker.clone()
}
#[cfg(feature = "teams")]
fn geo_location_service(&self) -> Arc<dyn GeoLocationService> {
self.geo_location_service.clone()
}
#[cfg(feature = "teams")]
fn geo_restriction_repo(&self) -> Arc<dyn GeoRestrictionRepository> {
self.geo_restriction_repo.clone()
}
fn i18n_bundle(&self) -> Arc<I18nBundle> {
self.i18n_bundle.clone()
}
fn event_bus(&self) -> Arc<dyn EventBus> {
self.event_bus.clone()
}
}
impl CrawlRsStateExt for Arc<CrawlRsState> {
fn task_repo(&self) -> Arc<dyn TaskRepository> {
self.as_ref().task_repo()
}
fn credits_repo(&self) -> Arc<dyn CreditsRepository> {
self.as_ref().credits_repo()
}
fn crawl_repo(&self) -> Arc<dyn CrawlRepository> {
self.as_ref().crawl_repo()
}
fn result_repo(&self) -> Arc<dyn ScrapeResultRepository> {
self.as_ref().result_repo()
}
#[cfg(feature = "webhook")]
fn webhook_repo(&self) -> Arc<dyn WebhookRepository> {
self.as_ref().webhook_repo()
}
#[cfg(feature = "webhook")]
fn webhook_event_repo(&self) -> Arc<dyn WebhookEventRepository> {
self.as_ref().webhook_event_repo()
}
fn rate_limiting_service(&self) -> Arc<dyn RateLimitingService> {
self.as_ref().rate_limiting_service()
}
#[cfg(feature = "teams")]
fn team_service(&self) -> Arc<TeamService> {
self.as_ref().team_service()
}
fn webhook_service(&self) -> Arc<dyn WebhookService> {
self.as_ref().webhook_service()
}
fn engine_router(&self) -> Arc<EngineRouter> {
self.as_ref().engine_router()
}
fn engine_client(&self) -> Arc<EngineClient> {
self.as_ref().engine_client()
}
fn create_scrape_use_case(&self) -> Arc<dyn CreateScrapeUseCaseTrait> {
self.as_ref().create_scrape_use_case()
}
fn search_client(&self) -> Arc<SearchClient> {
self.as_ref().search_client()
}
fn search_service(&self) -> Arc<dyn SearchServiceTrait> {
self.as_ref().search_service()
}
fn searxng_instances(&self) -> Option<Arc<dyn SearxngInstanceService>> {
self.as_ref().searxng_instances.clone()
}
fn llm_service(&self) -> Arc<dyn LLMServiceTrait> {
self.as_ref().llm_service()
}
fn cache_service(&self) -> Arc<dyn CacheService> {
self.as_ref().cache_service()
}
fn db_pool(&self) -> Arc<DbPool> {
self.as_ref().db_pool()
}
fn id_service(&self) -> Arc<IdService> {
self.as_ref().id_service()
}
fn tasks_backlog_repo(&self) -> Arc<dyn TasksBacklogRepository> {
self.as_ref().tasks_backlog_repo()
}
fn task_queue(&self) -> Arc<dyn TaskQueue> {
self.as_ref().task_queue()
}
fn robots_checker(&self) -> Arc<dyn RobotsCheckerTrait> {
self.as_ref().robots_checker()
}
fn team_semaphore(&self) -> Arc<TeamSemaphore> {
self.as_ref().team_semaphore()
}
fn request_coalescer(&self) -> Arc<RequestCoalescer> {
self.as_ref().request_coalescer()
}
fn audit_service(&self) -> Arc<dyn AuditServiceTrait> {
self.as_ref().audit_service()
}
fn extraction_service(&self) -> Arc<dyn ExtractionServiceTrait> {
self.as_ref().extraction_service()
}
fn embedding_provider(&self) -> Option<Arc<dyn EmbeddingProvider>> {
self.as_ref().embedding_provider.clone()
}
fn rerank_provider(&self) -> Option<Arc<dyn RerankProvider>> {
self.as_ref().rerank_provider.clone()
}
fn fluxweir_gateway(&self) -> crate::bootstrap::fluxweir_gateway::FluxweirGatewayHandle {
self.as_ref().fluxweir_gateway()
}
fn content_extractor(&self) -> Arc<ContentExtractionFacade> {
self.as_ref().content_extractor()
}
#[cfg(feature = "webhook")]
fn webhook_worker(&self) -> Arc<crate::workers::webhook_worker::WebhookWorker> {
self.as_ref().webhook_worker()
}
fn backlog_worker(&self) -> Arc<crate::workers::backlog_worker::BacklogWorker> {
self.as_ref().backlog_worker()
}
fn expiration_worker(&self) -> Arc<crate::workers::expiration_worker::ExpirationWorker> {
self.as_ref().expiration_worker()
}
#[cfg(feature = "teams")]
fn geo_location_service(&self) -> Arc<dyn GeoLocationService> {
self.as_ref().geo_location_service()
}
#[cfg(feature = "teams")]
fn geo_restriction_repo(&self) -> Arc<dyn GeoRestrictionRepository> {
self.as_ref().geo_restriction_repo()
}
fn i18n_bundle(&self) -> Arc<I18nBundle> {
self.as_ref().i18n_bundle()
}
fn event_bus(&self) -> Arc<dyn EventBus> {
self.as_ref().event_bus()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::common::test_support::testcontainers_fixtures as tcf;
use crate::di::modules::{
CacheModule, DatabaseModule, EngineModule, HttpModule, IdModule, InfrastructureModule,
RepositoryModule, ServiceModule, SettingsModule,
};
use std::sync::Arc;
async fn require_docker() -> bool {
tcf::docker_available().await
}
async fn build_app_state() -> anyhow::Result<CrawlRsState> {
let handle = tcf::DbHandle::start().await?;
let settings = Arc::new(tcf::settings_with_urls(&handle.pg.url)?);
let mut kit = AsyncKit::new();
kit.set_config(settings);
kit.register::<SettingsModule>()
.map_err(|e| anyhow::anyhow!("register SettingsModule: {e}"))?;
kit.register::<DatabaseModule>()
.map_err(|e| anyhow::anyhow!("register DatabaseModule: {e}"))?;
kit.register::<HttpModule>()
.map_err(|e| anyhow::anyhow!("register HttpModule: {e}"))?;
kit.register::<CacheModule>()
.map_err(|e| anyhow::anyhow!("register CacheModule: {e}"))?;
kit.register::<RepositoryModule>()
.map_err(|e| anyhow::anyhow!("register RepositoryModule: {e}"))?;
kit.register::<EngineModule>()
.map_err(|e| anyhow::anyhow!("register EngineModule: {e}"))?;
kit.register::<InfrastructureModule>()
.map_err(|e| anyhow::anyhow!("register InfrastructureModule: {e}"))?;
kit.register::<ServiceModule>()
.map_err(|e| anyhow::anyhow!("register ServiceModule: {e}"))?;
kit.register::<IdModule>().map_err(|e| {
anyhow::anyhow!(
"{}: {e}",
crate::i18n::tr_log("boot-register-id-module-failed")
)
})?;
let kit = kit
.build()
.await
.map_err(|e| anyhow::anyhow!("Failed to build kit: {e}"))?;
let state = CrawlRsState::from_kit(&kit)?;
Ok(state)
}
#[tokio::test]
async fn tc_app_state_all_accessors_return_valid_arcs() {
if !require_docker().await {
eprintln!("[skip] Docker unavailable — tc_app_state_all_accessors_return_valid_arcs");
return;
}
let _garrison_guard = crate::common::test_helpers::acquire_garrison_global_state().await;
let state = match build_app_state().await {
Ok(s) => s,
Err(e) => {
eprintln!("[skip] failed to build CrawlRsState: {e}");
return;
}
};
let task_repo: Arc<dyn TaskRepository> = state.task_repo();
assert!(Arc::strong_count(&task_repo) >= 2);
let credits_repo: Arc<dyn CreditsRepository> = state.credits_repo();
assert!(Arc::strong_count(&credits_repo) >= 2);
let crawl_repo: Arc<dyn CrawlRepository> = state.crawl_repo();
assert!(Arc::strong_count(&crawl_repo) >= 2);
let result_repo: Arc<dyn ScrapeResultRepository> = state.result_repo();
assert!(Arc::strong_count(&result_repo) >= 2);
let rate_limiting: Arc<dyn RateLimitingService> = state.rate_limiting_service();
assert!(Arc::strong_count(&rate_limiting) >= 2);
#[cfg(feature = "teams")]
{
let team_service: Arc<TeamService> = state.team_service();
assert!(Arc::strong_count(&team_service) >= 2);
}
#[cfg(feature = "webhook")]
{
let webhook_repo: Arc<dyn WebhookRepository> = state.webhook_repo();
assert!(Arc::strong_count(&webhook_repo) >= 2);
let webhook_event_repo: Arc<dyn WebhookEventRepository> = state.webhook_event_repo();
assert!(Arc::strong_count(&webhook_event_repo) >= 2);
}
let webhook_service: Arc<dyn WebhookService> = state.webhook_service();
assert!(Arc::strong_count(&webhook_service) >= 2);
let engine_router: Arc<EngineRouter> = state.engine_router();
assert!(Arc::strong_count(&engine_router) >= 2);
let engine_client: Arc<EngineClient> = state.engine_client();
assert!(Arc::strong_count(&engine_client) >= 2);
let create_scrape: Arc<dyn CreateScrapeUseCaseTrait> = state.create_scrape_use_case();
assert!(Arc::strong_count(&create_scrape) >= 2);
let search_client: Arc<SearchClient> = state.search_client();
assert!(Arc::strong_count(&search_client) >= 2);
let search_service: Arc<dyn SearchServiceTrait> = state.search_service();
assert!(Arc::strong_count(&search_service) >= 2);
let llm_service: Arc<dyn LLMServiceTrait> = state.llm_service();
assert!(Arc::strong_count(&llm_service) >= 2);
let db_pool: Arc<DbPool> = state.db_pool();
assert!(Arc::strong_count(&db_pool) >= 2);
let tasks_backlog: Arc<dyn TasksBacklogRepository> = state.tasks_backlog_repo();
assert!(Arc::strong_count(&tasks_backlog) >= 2);
let task_queue: Arc<dyn TaskQueue> = state.task_queue();
assert!(Arc::strong_count(&task_queue) >= 2);
let robots_checker: Arc<dyn RobotsCheckerTrait> = state.robots_checker();
assert!(Arc::strong_count(&robots_checker) >= 2);
let team_semaphore: Arc<TeamSemaphore> = state.team_semaphore();
assert!(Arc::strong_count(&team_semaphore) >= 2);
let audit_service: Arc<dyn AuditServiceTrait> = state.audit_service();
assert!(Arc::strong_count(&audit_service) >= 2);
let extraction_service: Arc<dyn ExtractionServiceTrait> = state.extraction_service();
assert!(Arc::strong_count(&extraction_service) >= 2);
let content_extractor = state.content_extractor();
assert!(Arc::strong_count(&content_extractor) >= 2);
#[cfg(feature = "webhook")]
{
let webhook_worker = state.webhook_worker();
assert!(Arc::strong_count(&webhook_worker) >= 2);
}
let backlog_worker = state.backlog_worker();
assert!(Arc::strong_count(&backlog_worker) >= 2);
let expiration_worker = state.expiration_worker();
assert!(Arc::strong_count(&expiration_worker) >= 2);
#[cfg(feature = "teams")]
{
let geo_location: Arc<dyn GeoLocationService> = state.geo_location_service();
assert!(Arc::strong_count(&geo_location) >= 2);
let geo_restriction: Arc<dyn GeoRestrictionRepository> = state.geo_restriction_repo();
assert!(Arc::strong_count(&geo_restriction) >= 2);
}
}
#[tokio::test]
async fn tc_app_state_arc_accessors_delegate_correctly() {
if !require_docker().await {
eprintln!("[skip] Docker unavailable — tc_app_state_arc_accessors_delegate_correctly");
return;
}
let _garrison_guard = crate::common::test_helpers::acquire_garrison_global_state().await;
let state = match build_app_state().await {
Ok(s) => s,
Err(e) => {
eprintln!("[skip] failed to build CrawlRsState: {e}");
return;
}
};
let state_arc: Arc<CrawlRsState> = Arc::new(state);
let task_repo_a = state_arc.task_repo();
let task_repo_b = state_arc.task_repo();
assert!(Arc::strong_count(&task_repo_a) >= 2);
assert!(Arc::strong_count(&task_repo_b) >= 2);
let db_a = state_arc.db_pool();
let db_b = state_arc.db_pool();
assert!(Arc::strong_count(&db_a) >= 2);
assert!(Arc::strong_count(&db_b) >= 2);
}
#[tokio::test]
async fn tc_app_state_clone_preserves_fields() {
if !require_docker().await {
eprintln!("[skip] Docker unavailable — tc_app_state_clone_preserves_fields");
return;
}
let _garrison_guard = crate::common::test_helpers::acquire_garrison_global_state().await;
let state = match build_app_state().await {
Ok(s) => s,
Err(e) => {
eprintln!("[skip] failed to build CrawlRsState: {e}");
return;
}
};
let cloned = state.clone();
let _ = state.task_repo();
let _ = cloned.task_repo();
}
async fn build_app_state_with_test_db() -> anyhow::Result<CrawlRsState> {
let db_url = crate::common::test_helpers::resolve_test_database_url().ok_or_else(|| {
anyhow::anyhow!(
"No test database available: set TEST_DATABASE_URL or ensure Docker is running"
)
})?;
let settings = Arc::new(tcf::settings_with_urls(&db_url)?);
let mut kit = AsyncKit::new();
kit.set_config(settings);
kit.register::<SettingsModule>()
.map_err(|e| anyhow::anyhow!("register SettingsModule: {e}"))?;
kit.register::<DatabaseModule>()
.map_err(|e| anyhow::anyhow!("register DatabaseModule: {e}"))?;
kit.register::<HttpModule>()
.map_err(|e| anyhow::anyhow!("register HttpModule: {e}"))?;
kit.register::<CacheModule>()
.map_err(|e| anyhow::anyhow!("register CacheModule: {e}"))?;
kit.register::<RepositoryModule>()
.map_err(|e| anyhow::anyhow!("register RepositoryModule: {e}"))?;
kit.register::<EngineModule>()
.map_err(|e| anyhow::anyhow!("register EngineModule: {e}"))?;
kit.register::<InfrastructureModule>()
.map_err(|e| anyhow::anyhow!("register InfrastructureModule: {e}"))?;
kit.register::<ServiceModule>()
.map_err(|e| anyhow::anyhow!("register ServiceModule: {e}"))?;
kit.register::<IdModule>().map_err(|e| {
anyhow::anyhow!(
"{}: {e}",
crate::i18n::tr_log("boot-register-id-module-failed")
)
})?;
let kit = kit
.build()
.await
.map_err(|e| anyhow::anyhow!("Failed to build kit: {e}"))?;
let state = CrawlRsState::from_kit(&kit)?;
Ok(state)
}
fn skip_if_no_test_db() -> bool {
crate::common::test_helpers::skip_if_no_test_db()
}
#[tokio::test]
async fn test_arc_state_all_accessors_delegate_correctly() {
if skip_if_no_test_db() {
return;
}
let _garrison_guard = crate::common::test_helpers::acquire_garrison_global_state().await;
let state = match build_app_state_with_test_db().await {
Ok(s) => s,
Err(e) => {
eprintln!("[skip] failed to build CrawlRsState with TEST_DATABASE_URL: {e}");
return;
}
};
let state_arc: Arc<CrawlRsState> = Arc::new(state);
let task_repo = state_arc.task_repo();
assert!(Arc::strong_count(&task_repo) >= 2);
let credits_repo = state_arc.credits_repo();
assert!(Arc::strong_count(&credits_repo) >= 2);
let crawl_repo = state_arc.crawl_repo();
assert!(Arc::strong_count(&crawl_repo) >= 2);
let result_repo = state_arc.result_repo();
assert!(Arc::strong_count(&result_repo) >= 2);
let rate_limiting_service = state_arc.rate_limiting_service();
assert!(Arc::strong_count(&rate_limiting_service) >= 2);
#[cfg(feature = "teams")]
{
let team_service = state_arc.team_service();
assert!(Arc::strong_count(&team_service) >= 2);
}
#[cfg(feature = "webhook")]
{
let webhook_repo = state_arc.webhook_repo();
assert!(Arc::strong_count(&webhook_repo) >= 2);
let webhook_event_repo = state_arc.webhook_event_repo();
assert!(Arc::strong_count(&webhook_event_repo) >= 2);
}
let webhook_service = state_arc.webhook_service();
assert!(Arc::strong_count(&webhook_service) >= 2);
let engine_router = state_arc.engine_router();
assert!(Arc::strong_count(&engine_router) >= 2);
let engine_client = state_arc.engine_client();
assert!(Arc::strong_count(&engine_client) >= 2);
let create_scrape_use_case = state_arc.create_scrape_use_case();
assert!(Arc::strong_count(&create_scrape_use_case) >= 2);
let search_client = state_arc.search_client();
assert!(Arc::strong_count(&search_client) >= 2);
let search_service = state_arc.search_service();
assert!(Arc::strong_count(&search_service) >= 2);
let llm_service = state_arc.llm_service();
assert!(Arc::strong_count(&llm_service) >= 2);
let db_pool = state_arc.db_pool();
assert!(Arc::strong_count(&db_pool) >= 2);
let tasks_backlog = state_arc.tasks_backlog_repo();
assert!(Arc::strong_count(&tasks_backlog) >= 2);
let task_queue = state_arc.task_queue();
assert!(Arc::strong_count(&task_queue) >= 2);
let robots_checker = state_arc.robots_checker();
assert!(Arc::strong_count(&robots_checker) >= 2);
let team_semaphore = state_arc.team_semaphore();
assert!(Arc::strong_count(&team_semaphore) >= 2);
let audit_service = state_arc.audit_service();
assert!(Arc::strong_count(&audit_service) >= 2);
let extraction_service = state_arc.extraction_service();
assert!(Arc::strong_count(&extraction_service) >= 2);
let content_extractor = state_arc.content_extractor();
assert!(Arc::strong_count(&content_extractor) >= 2);
#[cfg(feature = "webhook")]
{
let webhook_worker = state_arc.webhook_worker();
assert!(Arc::strong_count(&webhook_worker) >= 2);
}
let backlog_worker = state_arc.backlog_worker();
assert!(Arc::strong_count(&backlog_worker) >= 2);
let expiration_worker = state_arc.expiration_worker();
assert!(Arc::strong_count(&expiration_worker) >= 2);
#[cfg(feature = "teams")]
{
let geo_location = state_arc.geo_location_service();
assert!(Arc::strong_count(&geo_location) >= 2);
let geo_restriction = state_arc.geo_restriction_repo();
assert!(Arc::strong_count(&geo_restriction) >= 2);
}
}
#[tokio::test]
async fn test_arc_state_clone_preserves_accessor_results() {
if skip_if_no_test_db() {
return;
}
let _garrison_guard = crate::common::test_helpers::acquire_garrison_global_state().await;
let state = match build_app_state_with_test_db().await {
Ok(s) => s,
Err(e) => {
eprintln!("[skip] failed to build CrawlRsState with TEST_DATABASE_URL: {e}");
return;
}
};
let state_arc: Arc<CrawlRsState> = Arc::new(state);
let cloned_arc = state_arc.clone();
let task_repo_a = state_arc.task_repo();
let task_repo_b = cloned_arc.task_repo();
assert!(Arc::strong_count(&task_repo_a) >= 2);
assert!(Arc::strong_count(&task_repo_b) >= 2);
let db_a = state_arc.db_pool();
let db_b = cloned_arc.db_pool();
assert!(Arc::strong_count(&db_a) >= 2);
assert!(Arc::strong_count(&db_b) >= 2);
}
}