#[cfg(feature = "auth")]
mod bootstrap_admin_key;
#[cfg(all(test, feature = "auth"))]
mod auth_tests;
use std::sync::Arc;
use crate::bootstrap::infrastructure::InfrastructureComponents;
use crate::config::settings::Settings;
use crate::domain::services::audit_service::{AuditService, AuditServiceTrait};
use crate::infrastructure::database::repositories::audit_log_repo_impl::AuditLogRepositoryImpl;
use crate::queue::task_queue::{PostgresTaskQueue, TaskQueue};
#[cfg(feature = "auth")]
use bootstrap_admin_key::{
announce_bootstrap_admin_key, bootstrap_admin_key_config, ensure_bootstrap_team,
issue_bootstrap_admin_key, persist_bootstrap_api_key, resolve_bootstrap_team_id,
};
#[cfg(feature = "auth")]
use crate::bootstrap::error::BootstrapError;
#[cfg(feature = "auth")]
use crate::infrastructure::auth::{
build_garrison_config, init_garrison_dao, set_audit_service, set_garrison_dao,
CrawlrsGarrisonInterface,
};
#[cfg(feature = "auth")]
use dbnexus::DbPool;
#[cfg(feature = "auth")]
use garrison::prelude::{GarrisonDao, GarrisonInterface, GarrisonManager};
#[cfg(feature = "auth")]
use log::info;
pub(super) async fn init_auth_and_audit(
#[cfg_attr(not(feature = "auth"), allow(unused_variables))] settings: &Settings,
infrastructure: &InfrastructureComponents,
) -> (Arc<dyn TaskQueue>, Arc<dyn AuditServiceTrait>) {
let repositories = &infrastructure.repositories;
#[cfg(feature = "auth")]
init_garrison_auth(settings, infrastructure.db.inner().clone())
.await
.expect(
"garrison auth initialization failed (BootstrapError::GarrisonConfig/GarrisonDao/GarrisonManager) — \
check CRAWLRS__AUTH__JWT_SECRET env var (HS256 requires >=32 bytes)",
);
let queue: Arc<dyn TaskQueue> =
Arc::new(PostgresTaskQueue::new(repositories.task_repo.clone()));
let audit_repo = Arc::new(AuditLogRepositoryImpl::new(
infrastructure.db.inner().clone(),
));
let audit_service: Arc<dyn AuditServiceTrait> = Arc::new(AuditService::new(audit_repo));
#[cfg(feature = "auth")]
if set_audit_service(Arc::clone(&audit_service)).is_err() {
panic!(
"set_audit_service failed: audit_service already injected \
(check for duplicate init_services calls)"
);
}
(queue, audit_service)
}
#[cfg(feature = "auth")]
pub async fn init_garrison_auth(
settings: &Settings,
pool: Arc<DbPool>,
) -> Result<(), BootstrapError> {
install_garrison(settings, &pool).await?;
assert_bruteforce_firewall_compiled();
inject_bootstrap_admin_api_key(&pool).await?;
info!("Garrison authentication manager initialized (token_style=jwt, HS256, firewall=enabled)");
Ok(())
}
#[cfg(feature = "auth")]
async fn install_garrison(settings: &Settings, pool: &Arc<DbPool>) -> Result<(), BootstrapError> {
let config = build_garrison_config(settings.auth.jwt_secret())?;
let config = Arc::new(config);
let dao: Arc<dyn GarrisonDao> = init_garrison_dao()
.await
.map_err(|e| BootstrapError::GarrisonDao(format!("{e}")))?;
set_garrison_dao(Arc::clone(&dao)).map_err(|_| {
BootstrapError::GarrisonDao(
"set_garrison_dao failed: global DAO already injected \
(check for duplicate init_garrison_auth calls)"
.to_string(),
)
})?;
let interface: Arc<dyn GarrisonInterface> =
Arc::new(CrawlrsGarrisonInterface::new((**pool).clone()));
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.map_err(|e| BootstrapError::GarrisonManager(format!("{e}")))?;
Ok(())
}
#[cfg(feature = "auth")]
fn assert_bruteforce_firewall_compiled() {
use garrison::BruteForceStrategy as _FwAssert;
let _ = std::marker::PhantomData::<_FwAssert>;
}
#[cfg(feature = "auth")]
async fn inject_bootstrap_admin_api_key(pool: &Arc<DbPool>) -> Result<(), BootstrapError> {
let Some(cfg_val) = bootstrap_admin_key_config() else {
return Ok(());
};
let team_id =
resolve_bootstrap_team_id(&cfg_val).unwrap_or_else(crate::domain::id::Id::generate);
let api_key_id = crate::domain::id::Id::generate();
let now = crate::common::time_utils::to_db_datetime(chrono::Utc::now());
let session = pool.get_session("admin").await.map_err(|e| {
BootstrapError::GarrisonManager(format!("bootstrap_admin_key: db session: {e}"))
})?;
let conn = session.connection().map_err(|e| {
BootstrapError::GarrisonManager(format!("bootstrap_admin_key: db conn: {e}"))
})?;
ensure_bootstrap_team(conn, team_id, now).await?;
let key = issue_bootstrap_admin_key(api_key_id).await?;
persist_bootstrap_api_key(conn, api_key_id, team_id, &key.key_id, now).await?;
announce_bootstrap_admin_key(&key.plaintext, team_id, api_key_id);
Ok(())
}