use std::sync::Arc;
use std::time::Duration;
use anyhow::{anyhow, Result};
use crate::config::Settings;
pub const GATEWAY_READYZ_TIMEOUT: Duration = Duration::from_secs(30);
#[derive(Clone, Default)]
pub struct FluxweirGatewayHandle {
base_url: Option<String>,
#[cfg(feature = "gateway")]
handle: Option<Arc<fluxweir::server::ServerHandle>>,
}
impl FluxweirGatewayHandle {
pub fn base_url(&self) -> Option<&str> {
self.base_url.as_deref()
}
pub fn enabled(&self) -> bool {
self.base_url.is_some()
}
pub async fn shutdown(&self) {
#[cfg(feature = "gateway")]
if let Some(handle) = &self.handle {
log::info!("fluxweir gateway shutting down: flushing request logs and token usage");
handle.shutdown().await;
log::info!("fluxweir gateway shutdown complete (flush finished)");
}
}
}
pub async fn init_fluxweir_gateway(
settings: &Settings,
shared_pool: Option<Arc<dbnexus::DbPool>>,
db_url: &str,
) -> Result<FluxweirGatewayHandle> {
let fw = &settings.fluxweir;
if !fw.enabled {
return Ok(FluxweirGatewayHandle::default());
}
#[cfg(not(feature = "gateway"))]
{
let _ = (shared_pool, db_url);
Err(anyhow!(
"fluxweir.enabled=true requires the gateway feature; rebuild with --features gateway"
))
}
#[cfg(feature = "gateway")]
{
fw.validate()
.map_err(|e| anyhow!("fluxweir config invalid: {e}"))?;
if fw.mode == "external" {
return Ok(external_gateway_handle(fw));
}
start_embedded_gateway(fw, shared_pool, db_url).await
}
}
#[cfg(feature = "gateway")]
fn external_gateway_handle(
fw: &crate::config::settings::FluxweirSettings,
) -> FluxweirGatewayHandle {
let base_url = fw
.external_base_url
.trim()
.trim_end_matches('/')
.to_string();
log::info!("fluxweir gateway mode=external, base_url={base_url}");
FluxweirGatewayHandle {
base_url: Some(base_url),
handle: None,
}
}
#[cfg(feature = "gateway")]
async fn start_embedded_gateway(
fw: &crate::config::settings::FluxweirSettings,
shared_pool: Option<Arc<dbnexus::DbPool>>,
db_url: &str,
) -> Result<FluxweirGatewayHandle> {
let pool = shared_pool.ok_or_else(|| {
anyhow!("fluxweir.mode=embedded requires the crawlrs database pool (single-pool sharing)")
})?;
let db_url = db_url.trim().to_string();
if db_url.is_empty() {
return Err(anyhow!(
"fluxweir.mode=embedded requires a real database URL \
(fluxweir DI kit connects via it; the shared pool only covers the repository face)"
));
}
let (host, port) = parse_listen_addr(&fw.listen_addr)?;
if !host.is_loopback() {
log::warn!(
"fluxweir gateway binding non-loopback address {host}:{port} — \
the gateway is reachable beyond this host"
);
}
let config_manager = build_config_manager(fw, &db_url, host, port)?;
log::info!(
"starting embedded fluxweir gateway at {} (shared pool, db_url redacted: {})",
fw.listen_addr,
fluxweir::database::redact_db_url(&db_url)
);
let (router, handle) =
fluxweir::server::build_app_with_pool(config_manager, (*pool).clone()).await?;
let addr = std::net::SocketAddr::from((host, port));
let listener = tokio::net::TcpListener::bind(addr)
.await
.map_err(|e| anyhow!("failed to bind fluxweir gateway on {addr}: {e}"))?;
let base_url = format!("http://{addr}");
tokio::spawn(async move {
if let Err(e) = axum::serve(listener, router).await {
log::error!("fluxweir gateway serve terminated with error: {e:#}");
}
});
wait_for_ready(&base_url).await?;
log::info!("fluxweir gateway ready at {base_url}");
Ok(FluxweirGatewayHandle {
base_url: Some(base_url),
handle: Some(Arc::new(handle)),
})
}
#[cfg(feature = "gateway")]
fn parse_listen_addr(addr: &str) -> Result<(std::net::IpAddr, u16)> {
let (host, port) = addr
.rsplit_once(':')
.ok_or_else(|| anyhow!("invalid fluxweir.listen_addr \"{addr}\" (expected host:port)"))?;
let port: u16 = port
.parse()
.map_err(|e| anyhow!("invalid fluxweir.listen_addr port in \"{addr}\": {e}"))?;
let host: std::net::IpAddr = host
.parse()
.map_err(|e| anyhow!("invalid fluxweir.listen_addr host \"{host}\": {e}"))?;
Ok((host, port))
}
#[cfg(feature = "gateway")]
fn build_config_manager(
fw: &crate::config::settings::FluxweirSettings,
db_url: &str,
host: std::net::IpAddr,
port: u16,
) -> Result<Arc<fluxweir::config::ConfigManager>> {
let mut config: fluxweir::config::Config = if fw.config_path.trim().is_empty() {
serde_json::from_value(serde_json::json!({
"server": {"host": host.to_string(), "port": port},
"database": {"url": db_url},
"vendors": [{
"id": "probe-vendor",
"name": "probe-vendor",
"type_": "openai",
"api_key_env": "FLUXWEIR_PROBE_VENDOR_KEY", "api_base": "http://127.0.0.1:1",
"enabled": true,
"priority": 1,
"models": [{"model_id": "integration-probe", "abstract_id": "integration-probe"}],
"rate_limit": {"type": "interval", "hours": 1},
"concurrency": {}
}],
"global_model": null,
}))
.map_err(|e| anyhow!("failed to build inline fluxweir config: {e}"))?
} else {
fluxweir::config::loader::load_config_from_path(std::path::Path::new(&fw.config_path))
.map_err(|e| {
anyhow!(
"failed to load fluxweir config file {}: {e}",
fw.config_path
)
})?
};
config.server.host = host.to_string();
config.server.port = port;
config.database.url = db_url.to_string();
let key = fw.api_key().ok_or_else(|| {
anyhow!("fluxweir enabled but no API key resolvable (api_key_env or direct value)")
})?;
config.auth = Some(fluxweir::config::AuthSection {
enabled: true,
api_keys: vec![sha256_hex(&key)],
header: fluxweir::config::AuthHeaderSection::default(),
keys: Vec::new(),
oidc_rules: None,
trusted_proxy: fw.trusted_proxy,
});
Ok(Arc::new(fluxweir::config::ConfigManager::new(config)))
}
#[cfg(feature = "gateway")]
fn sha256_hex(input: &str) -> String {
use sha2::Digest;
let digest = sha2::Sha256::digest(input.as_bytes());
let mut out = String::with_capacity(digest.len() * 2);
for byte in digest {
use std::fmt::Write as _;
let _ = write!(out, "{byte:02x}");
}
out
}
#[cfg(feature = "gateway")]
async fn wait_for_ready(base_url: &str) -> Result<()> {
let client = reqwest::Client::new();
let url = format!("{base_url}/readyz");
let deadline = tokio::time::Instant::now() + GATEWAY_READYZ_TIMEOUT;
let mut delay = Duration::from_millis(200);
loop {
if tokio::time::Instant::now() >= deadline {
return Err(anyhow!(
"fluxweir gateway readyz timeout after {:?} at {url}",
GATEWAY_READYZ_TIMEOUT
));
}
match client
.get(&url)
.timeout(Duration::from_secs(2))
.send()
.await
{
Ok(resp) if resp.status().is_success() => return Ok(()),
Ok(resp) => log::debug!("fluxweir readyz not ready yet: {}", resp.status()),
Err(e) => log::debug!("fluxweir readyz probe failed: {e}"),
}
tokio::time::sleep(delay).await;
delay = (delay * 2).min(Duration::from_secs(2));
}
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(feature = "gateway")]
#[test]
fn parse_listen_addr_accepts_loopback() {
let (host, port) = parse_listen_addr("127.0.0.1:8900").expect("ok");
assert_eq!(host.to_string(), "127.0.0.1");
assert_eq!(port, 8900);
}
#[cfg(feature = "gateway")]
#[test]
fn parse_listen_addr_rejects_missing_port() {
assert!(parse_listen_addr("127.0.0.1").is_err());
}
#[cfg(feature = "gateway")]
#[test]
fn parse_listen_addr_rejects_bad_port() {
assert!(parse_listen_addr("127.0.0.1:notaport").is_err());
}
#[cfg(feature = "gateway")]
#[test]
fn sha256_hex_matches_known_vector() {
assert_eq!(
sha256_hex("abc"),
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" );
}
#[test]
fn disabled_handle_is_empty_and_shutdown_is_noop() {
let handle = FluxweirGatewayHandle::default();
assert!(!handle.enabled());
assert!(handle.base_url().is_none());
}
#[tokio::test]
async fn disabled_handle_shutdown_returns() {
let handle = FluxweirGatewayHandle::default();
handle.shutdown().await;
}
}