use std::path::PathBuf;
use axum::extract::{Query, State};
use axum::http::StatusCode;
use axum::routing::{get, post};
use axum::{Json, Router};
use serde::Deserialize;
use super::wire::{graph_tier, DataflowReply, DepEdgeItem, FlowStepItem};
use super::ResidentEngine;
use super::{Definitions, EngineStatus, FileSymbols, Impact, MeasureReply, Neighbors};
use crate::dataflow::{Dataflow, FlowDir};
use crate::graph::Dir;
pub fn router(engine: ResidentEngine) -> Router {
Router::new()
.route("/health", get(health))
.route("/status", get(status))
.route("/callers", get(callers))
.route("/callees", get(callees))
.route("/impact", get(impact))
.route("/references", get(references))
.route("/symbols", get(symbols))
.route("/dataflow", get(dataflow))
.route("/measure", post(measure))
.route("/edit", post(edit))
.with_state(engine)
}
async fn health() -> &'static str {
"ok"
}
async fn status(State(engine): State<ResidentEngine>) -> Json<EngineStatus> {
Json(engine.status())
}
#[derive(Debug, Deserialize)]
struct SymbolQuery {
symbol: String,
tenant: Option<String>,
}
#[derive(Debug, Deserialize)]
struct ImpactQuery {
symbol: String,
hops: Option<u32>,
tenant: Option<String>,
}
const NO_TENANT_LAYER: StatusCode = StatusCode::PRECONDITION_FAILED;
async fn callers(
State(engine): State<ResidentEngine>,
Query(q): Query<SymbolQuery>,
) -> Result<Json<Neighbors>, StatusCode> {
match &q.tenant {
Some(t) => engine
.neighbors_for(t, &q.symbol, Dir::Callers)
.map(Json)
.ok_or(NO_TENANT_LAYER),
None => Ok(Json(engine.neighbors(&q.symbol, Dir::Callers))),
}
}
async fn callees(
State(engine): State<ResidentEngine>,
Query(q): Query<SymbolQuery>,
) -> Result<Json<Neighbors>, StatusCode> {
match &q.tenant {
Some(t) => engine
.neighbors_for(t, &q.symbol, Dir::Callees)
.map(Json)
.ok_or(NO_TENANT_LAYER),
None => Ok(Json(engine.neighbors(&q.symbol, Dir::Callees))),
}
}
async fn impact(
State(engine): State<ResidentEngine>,
Query(q): Query<ImpactQuery>,
) -> Result<Json<Impact>, StatusCode> {
let hops = q.hops.unwrap_or(5);
match &q.tenant {
Some(t) => engine
.impact_for(t, &q.symbol, hops)
.map(Json)
.ok_or(NO_TENANT_LAYER),
None => Ok(Json(engine.impact(&q.symbol, hops))),
}
}
async fn references(
State(engine): State<ResidentEngine>,
Query(q): Query<SymbolQuery>,
) -> Result<Json<Definitions>, StatusCode> {
match &q.tenant {
Some(t) => engine
.references_for(t, &q.symbol)
.map(Json)
.ok_or(NO_TENANT_LAYER),
None => Ok(Json(engine.references(&q.symbol))),
}
}
#[derive(Debug, Deserialize)]
struct FileQuery {
file: String,
tenant: Option<String>,
}
async fn symbols(
State(engine): State<ResidentEngine>,
Query(q): Query<FileQuery>,
) -> Result<Json<FileSymbols>, StatusCode> {
match &q.tenant {
Some(t) => engine
.symbols_for(t, &q.file)
.map(Json)
.ok_or(NO_TENANT_LAYER),
None => Ok(Json(engine.symbols(&q.file))),
}
}
#[derive(Debug, Deserialize)]
struct EditRequest {
tenant: String,
rel: String,
#[serde(default)]
content: Option<String>,
}
async fn edit(
State(engine): State<ResidentEngine>,
Json(req): Json<EditRequest>,
) -> Result<Json<super::EditReply>, StatusCode> {
let content = match req.content {
Some(content) => content,
None => {
let root = engine.root();
let joined = root.join(&req.rel);
let (Ok(canon), Ok(canon_root)) = (joined.canonicalize(), root.canonicalize()) else {
return Err(StatusCode::BAD_REQUEST);
};
if !canon.starts_with(&canon_root) {
return Err(StatusCode::BAD_REQUEST);
}
std::fs::read_to_string(&canon).map_err(|_| StatusCode::BAD_REQUEST)?
}
};
engine
.edit(&req.tenant, &req.rel, &content)
.map(Json)
.ok_or(NO_TENANT_LAYER)
}
#[derive(Debug, Deserialize)]
struct DataflowQuery {
function: String,
path: Option<String>,
var: Option<String>,
forward: Option<bool>,
hops: Option<u32>,
}
async fn dataflow(
State(engine): State<ResidentEngine>,
Query(q): Query<DataflowQuery>,
) -> Result<Json<DataflowReply>, StatusCode> {
let root = engine.root();
let base = match &q.path {
Some(p) => {
let joined = root.join(p);
let (Ok(canon), Ok(canon_root)) = (joined.canonicalize(), root.canonicalize()) else {
return Err(StatusCode::BAD_REQUEST);
};
if !canon.starts_with(&canon_root) {
return Err(StatusCode::BAD_REQUEST);
}
canon
}
None => root.to_path_buf(),
};
let flow = Dataflow::build(&base).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
let found = flow.has_function(&q.function);
let (direction, steps, edges) = match &q.var {
Some(var) => {
let dir = if q.forward.unwrap_or(false) {
FlowDir::FlowsInto
} else {
FlowDir::DependsOn
};
let steps = flow
.flow(&q.function, var, dir, q.hops.unwrap_or(5))
.into_iter()
.map(|s| FlowStepItem {
name: s.name,
distance: s.distance,
})
.collect();
(Some(dir.as_str().to_string()), steps, Vec::new())
}
None => {
let edges = flow
.edges(&q.function)
.iter()
.map(|e| DepEdgeItem {
dependent: e.dependent.clone(),
depends_on: e.depends_on.clone(),
line: e.line,
})
.collect();
(None, Vec::new(), edges)
}
};
Ok(Json(DataflowReply {
function: q.function,
found,
direction,
var: q.var,
flow: steps,
edges,
tier: graph_tier(),
}))
}
#[derive(Debug, Deserialize)]
struct MeasureRequest {
file: String,
rel: String,
#[serde(default)]
anchors: Vec<String>,
#[serde(default)]
max_hops: Option<u32>,
}
async fn measure(
State(engine): State<ResidentEngine>,
Json(req): Json<MeasureRequest>,
) -> Result<Json<MeasureReply>, StatusCode> {
let root = engine.root();
let raw = PathBuf::from(&req.file);
let file = if raw.is_absolute() {
raw
} else {
root.join(raw)
};
let (Ok(canon_file), Ok(canon_root)) = (file.canonicalize(), root.canonicalize()) else {
return Err(StatusCode::BAD_REQUEST);
};
if !canon_file.starts_with(&canon_root) {
return Err(StatusCode::BAD_REQUEST);
}
let hops = req.max_hops.unwrap_or(engine.policy().max_hops);
let sizing = engine.measure_edit(&canon_file, &req.rel, &req.anchors, hops);
Ok(Json(MeasureReply::from_sizing(&sizing)))
}
pub async fn serve(engine: ResidentEngine, host: &str, port: u16) -> anyhow::Result<()> {
let addr = format!("{host}:{port}");
let listener = tokio::net::TcpListener::bind(&addr).await?;
eprintln!("hank daemon: liveness surface on http://{addr}/health");
axum::serve(listener, router(engine))
.with_graceful_shutdown(shutdown_signal())
.await?;
eprintln!("hank daemon: shut down cleanly");
Ok(())
}
async fn shutdown_signal() {
let ctrl_c = async {
let _ = tokio::signal::ctrl_c().await;
};
#[cfg(unix)]
let terminate = async {
tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
.expect("install SIGTERM handler")
.recv()
.await;
};
#[cfg(not(unix))]
let terminate = std::future::pending::<()>();
tokio::select! {
() = ctrl_c => {},
() = terminate => {},
}
eprintln!("hank daemon: shutdown signal received — draining");
}
#[cfg(test)]
#[path = "http_test.rs"]
mod http_test;