use parking_lot::RwLock;
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::Arc;
use tokio::net::TcpListener;
use tracing::info;
use super::{SidecarHandle, SidecarState, TokenStats, port_file, router};
use crate::domain::ControlStateDir;
use crate::live_index::store::SharedIndex;
pub async fn spawn_sidecar(
index: SharedIndex,
bind_host: &str,
repo_root: Option<PathBuf>,
control_state_dir: Option<ControlStateDir>,
) -> anyhow::Result<SidecarHandle> {
let resolved_host =
std::env::var("SYMFORGE_SIDECAR_BIND").unwrap_or_else(|_| bind_host.to_string());
if let Some(state_dir) = control_state_dir.as_ref() {
port_file::check_stale(state_dir, &resolved_host, repo_root.as_deref());
port_file::cleanup_session_file(state_dir);
}
let std_addr: std::net::SocketAddr = format!("{resolved_host}:0").parse()?;
let domain = if std_addr.is_ipv4() {
socket2::Domain::IPV4
} else {
socket2::Domain::IPV6
};
let socket = socket2::Socket::new(domain, socket2::Type::STREAM, Some(socket2::Protocol::TCP))?;
socket.set_reuse_address(true)?;
socket.set_nonblocking(true)?;
socket.bind(&std_addr.into())?;
socket.listen(1024)?;
let std_listener: std::net::TcpListener = socket.into();
let listener = TcpListener::from_std(std_listener)?;
let port = listener.local_addr()?.port();
if let Some(state_dir) = control_state_dir.as_ref() {
port_file::write_session_descriptor(state_dir, port, None, repo_root.as_deref())?;
}
if let Some(state_dir) = control_state_dir.as_ref() {
let sidecar_dir = crate::paths::control_state_path(state_dir, "sidecar");
let previous_hook = std::panic::take_hook();
std::panic::set_hook(Box::new(move |info| {
port_file::cleanup_own_descriptor_at(&sidecar_dir);
previous_hook(info);
}));
}
info!("sidecar listening on {resolved_host}:{port}");
let token_stats = TokenStats::new();
let state = SidecarState {
index,
token_stats: Arc::clone(&token_stats),
repo_root,
symbol_cache: Arc::new(RwLock::new(HashMap::new())),
};
let app = router::build_router(state);
let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel::<()>();
let shutdown_control_state_dir = control_state_dir.clone();
let server_join = tokio::spawn(async move {
let shutdown_signal = async move {
let _ = shutdown_rx.await;
};
if let Err(e) = axum::serve(listener, app)
.with_graceful_shutdown(shutdown_signal)
.await
{
tracing::error!("sidecar server error: {e}");
}
if let Some(state_dir) = shutdown_control_state_dir.as_ref() {
port_file::cleanup_own_descriptor(state_dir);
}
tracing::info!("sidecar shut down, session descriptor cleaned up");
});
Ok(SidecarHandle {
port,
shutdown_tx,
server_join,
token_stats,
})
}
#[cfg(test)]
mod tests {
#[test]
fn so_reuseaddr_listener_rebinds_on_recently_freed_port() {
fn bind_reuse(addr: std::net::SocketAddr) -> std::io::Result<std::net::TcpListener> {
let domain = if addr.is_ipv4() {
socket2::Domain::IPV4
} else {
socket2::Domain::IPV6
};
let socket =
socket2::Socket::new(domain, socket2::Type::STREAM, Some(socket2::Protocol::TCP))?;
socket.set_reuse_address(true)?;
socket.bind(&addr.into())?;
socket.listen(16)?;
Ok(socket.into())
}
let ephemeral: std::net::SocketAddr = "127.0.0.1:0".parse().expect("parse addr");
let first = bind_reuse(ephemeral).expect("first bind");
let bound_port = first.local_addr().expect("local_addr").port();
drop(first);
let explicit: std::net::SocketAddr = format!("127.0.0.1:{bound_port}")
.parse()
.expect("parse explicit");
let second = bind_reuse(explicit).expect("rebind on freed port");
assert_eq!(
second.local_addr().expect("local_addr").port(),
bound_port,
"rebind must hold the same port"
);
}
}