266 lines
8.4 KiB
Rust
266 lines
8.4 KiB
Rust
use axum::{
|
|
extract::{State, Query},
|
|
http::StatusCode,
|
|
response::{IntoResponse, Response},
|
|
routing::get,
|
|
Router,
|
|
};
|
|
|
|
use std::collections::HashMap;
|
|
use std::net::SocketAddr;
|
|
use std::str::FromStr;
|
|
|
|
#[derive(Clone, PartialEq)]
|
|
enum OperationMode {
|
|
None,
|
|
Exporter,
|
|
Validator,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
struct AppState {
|
|
listen: String,
|
|
operationmode: OperationMode,
|
|
prometheus_url: String,
|
|
prometheus_query_tag_template: String,
|
|
hydra_url: String,
|
|
hydra_job_template: String,
|
|
}
|
|
|
|
impl AppState{
|
|
pub fn new() -> Self {
|
|
Self {
|
|
listen: String::from("[::]:9152"),
|
|
operationmode: OperationMode::None,
|
|
prometheus_url: String::from(""),
|
|
prometheus_query_tag_template: String::from("instance=\"{}\""),
|
|
hydra_url: String::from(""),
|
|
hydra_job_template: String::from("nixfiles/nixfiles/nixosConfigurations.{}"),
|
|
}
|
|
}
|
|
|
|
pub fn is_valid(self) -> bool {
|
|
let mut valid = true;
|
|
if self.operationmode == OperationMode::None {
|
|
println!("operationmode is not set");
|
|
valid = false;
|
|
}
|
|
if self.prometheus_url == String::from("") && self.operationmode == OperationMode::Validator {
|
|
println!("Prometheus url is not specified");
|
|
valid = false;
|
|
}
|
|
if self.hydra_url == String::from("") && self.operationmode == OperationMode::Validator {
|
|
println!("Hydra url is not specified");
|
|
valid = false;
|
|
}
|
|
|
|
return valid;
|
|
}
|
|
}
|
|
|
|
fn parse_nix_store_path(path: std::path::PathBuf) -> Result<(String, String), String> {
|
|
let (hash, name) = path.file_name()
|
|
.ok_or_else(String::default)?
|
|
.to_str()
|
|
.ok_or_else(String::default)?
|
|
.split_once("-")
|
|
.ok_or_else(String::default)?;
|
|
return Ok((hash.to_string(), name.to_string()));
|
|
}
|
|
|
|
|
|
#[tokio::main]
|
|
async fn main() {
|
|
let mut app_state = AppState::new();
|
|
|
|
let mut args = std::env::args();
|
|
let name = args.next().unwrap();
|
|
loop {
|
|
let arg = if let Some(arg) = args.next() {
|
|
arg
|
|
} else {
|
|
break;
|
|
};
|
|
|
|
match arg.as_str() {
|
|
"--help" | "-h" => {
|
|
println!("Prometheus exporter for NixOS systems");
|
|
println!("Use --listen <addr:port> bind the web service.");
|
|
println!("Output will be on /metrics endpoint. HTTP 500 if something broke while scraping.");
|
|
std::process::exit(0);
|
|
}
|
|
"--listen" => {
|
|
app_state.listen = args.next().unwrap();
|
|
}
|
|
"--prometheus-url" => {
|
|
app_state.prometheus_url = args.next().unwrap();
|
|
}
|
|
"--prometheus-query-tag-template" => {
|
|
app_state.prometheus_query_tag_template = args.next().unwrap();
|
|
}
|
|
"--hydra-url" => {
|
|
app_state.hydra_url = args.next().unwrap();
|
|
}
|
|
"--hydra-job-template" => {
|
|
app_state.hydra_job_template = args.next().unwrap();
|
|
}
|
|
"exporter" => {
|
|
app_state.operationmode = OperationMode::Exporter;
|
|
}
|
|
"validator" => {
|
|
app_state.operationmode = OperationMode::Validator;
|
|
}
|
|
unknown => {
|
|
println!("unknown option: {}", unknown);
|
|
std::process::exit(1)
|
|
}
|
|
}
|
|
}
|
|
|
|
if !app_state.clone().is_valid() {
|
|
std::process::exit(1);
|
|
}
|
|
|
|
let mut app = Router::new();
|
|
if app_state.operationmode == OperationMode::Exporter {
|
|
println!("Running NixOS Exporter in Exporter mode");
|
|
app = app.route("/metrics", get(metrics));
|
|
} else if app_state.operationmode == OperationMode::Validator {
|
|
println!("Running NixOS Exporter in Validator mode");
|
|
app = app.route("/metrics", get(check));
|
|
} else {
|
|
println!("Run mode not specified, do {} --help", name);
|
|
std::process::exit(1);
|
|
};
|
|
|
|
let app = app.with_state(app_state.clone());
|
|
|
|
let addr = SocketAddr::from_str(&app_state.listen.clone()).unwrap();
|
|
println!("listening on http://{}", addr);
|
|
axum::Server::bind(&addr)
|
|
.serve(app.into_make_service())
|
|
.await
|
|
.unwrap();
|
|
}
|
|
|
|
fn get_current_system() -> Result<(String, String), String> {
|
|
let symlink = match std::fs::read_link("/run/current-system") {
|
|
Ok(symlink) => symlink,
|
|
Err(err) => return Err(err.to_string()),
|
|
};
|
|
|
|
let (hash, name) = parse_nix_store_path(symlink)?;
|
|
|
|
Ok((String::from(hash), String::from(name)))
|
|
}
|
|
|
|
async fn metrics() -> Response {
|
|
let current_system = get_current_system();
|
|
let (hash, name) = match current_system {
|
|
Ok((hash, name)) => (hash, name),
|
|
Err(err) => {
|
|
println!("failed: {}", err);
|
|
return (StatusCode::INTERNAL_SERVER_ERROR, "").into_response();
|
|
}
|
|
};
|
|
|
|
(
|
|
StatusCode::OK,
|
|
format!("nixos_current_system_hash{{hash=\"{}\"}} 1\nnixos_current_system_name{{name=\"{}\"}} 1\n", hash, name)
|
|
).into_response()
|
|
}
|
|
|
|
async fn check(State(app_state): State<AppState>, Query(params): Query<HashMap<String, String>>) -> Response {
|
|
let target = match params.get("target") {
|
|
Some(target) => target,
|
|
None => {
|
|
return (StatusCode::NOT_FOUND, "specify target").into_response();
|
|
},
|
|
};
|
|
|
|
if target.contains("\"") {
|
|
return (StatusCode::INTERNAL_SERVER_ERROR, "Invalid target name").into_response();
|
|
}
|
|
|
|
let client = reqwest::Client::new();
|
|
|
|
let prometheus_req = match client.get(format!("{}/api/v1/query?query=nixos_nixos_current_system_hash{{{}}}", app_state.prometheus_url, app_state.prometheus_query_tag_template.clone().replace("{}", target)))
|
|
.header("Accept", "application/json")
|
|
.send().await {
|
|
Ok(req) => req,
|
|
Err(_) => {
|
|
return (StatusCode::INTERNAL_SERVER_ERROR, "Promehteus can't get reached").into_response();
|
|
},
|
|
};
|
|
|
|
|
|
match prometheus_req.status() {
|
|
reqwest::StatusCode::OK => (),
|
|
_ => {
|
|
return (StatusCode::NOT_FOUND, "Target does not exist in Hydra").into_response();
|
|
},
|
|
}
|
|
|
|
let prometheus_body = match prometheus_req.json::<serde_json::Value>().await {
|
|
Ok(body) => body,
|
|
Err(_) => {
|
|
return (StatusCode::INTERNAL_SERVER_ERROR, "Invalid response from Hydra").into_response();
|
|
},
|
|
};
|
|
|
|
let current_system_hash = match prometheus_body["data"]["result"][0]["metric"]["hash"].as_str() {
|
|
Some(nix_store_path) => nix_store_path,
|
|
_ => {
|
|
return (StatusCode::INTERNAL_SERVER_ERROR, "No buildoutput found in Hydra").into_response();
|
|
},
|
|
};
|
|
|
|
let hydra_req = match client.get(format!("{}/job/{}/latest", app_state.hydra_url, app_state.hydra_job_template.clone().replace("{}", target)))
|
|
.header("Accept", "application/json")
|
|
.send().await {
|
|
Ok(req) => req,
|
|
Err(_) => {
|
|
return (StatusCode::INTERNAL_SERVER_ERROR, "Hydra can't get reached").into_response();
|
|
},
|
|
};
|
|
|
|
match hydra_req.status() {
|
|
reqwest::StatusCode::OK => (),
|
|
_ => {
|
|
return (StatusCode::NOT_FOUND, "Target does not exist in Hydra").into_response();
|
|
},
|
|
}
|
|
|
|
let hydra_body = match hydra_req.json::<serde_json::Value>().await {
|
|
Ok(body) => body,
|
|
Err(_) => {
|
|
return (StatusCode::INTERNAL_SERVER_ERROR, "Invalid response from Hydra").into_response();
|
|
},
|
|
};
|
|
|
|
let nix_store_path = match hydra_body["buildoutputs"]["out"]["path"].as_str() {
|
|
Some(nix_store_path) => nix_store_path,
|
|
_ => {
|
|
return (StatusCode::INTERNAL_SERVER_ERROR, "No buildoutput found in Hydra").into_response();
|
|
},
|
|
};
|
|
|
|
let (hydra_system_hash, _) = match parse_nix_store_path(std::path::PathBuf::from(nix_store_path)) {
|
|
Ok((hash, name)) => (hash, name),
|
|
Err(_) => {
|
|
return (StatusCode::INTERNAL_SERVER_ERROR, "Invalid store path returned by Hydra").into_response();
|
|
},
|
|
};
|
|
|
|
let mut status = "0";
|
|
|
|
if current_system_hash == hydra_system_hash {
|
|
status = "1";
|
|
}
|
|
|
|
return (
|
|
StatusCode::OK,
|
|
format!("nixos_current_system_valid{{{}}} {}\n", app_state.prometheus_query_tag_template.clone().replace("{}", target), status)
|
|
).into_response();
|
|
}
|