use iridium::features::ops;
use iridium::features::query;
use iridium::features::runtime;
use super::ir_cli::{help_text, parse_args, Command};
#[path = "app/bench_cmd.rs"]
mod bench_cmd;
#[path = "app/common.rs"]
mod common;
#[path = "app/ingest_file.rs"]
mod ingest_file;
#[path = "app/query_cmd.rs"]
mod query_cmd;
#[path = "app/service_cmd.rs"]
mod service_cmd;
#[path = "app/storage_cmd.rs"]
mod storage_cmd;
pub(crate) fn run() {
let args: Vec<String> = std::env::args().collect();
let parsed = match parse_args(&args) {
Ok(parsed) => parsed,
Err(err) => {
eprintln!("{}", err);
std::process::exit(1);
}
};
let command = parsed.command;
let data_root = parsed.data_dir.as_deref();
if let Some(policy) = parsed.wal_sync_policy.as_ref() {
std::env::set_var("IR_WAL_SYNC_POLICY", policy);
}
if let Some(interval_ms) = parsed.wal_sync_interval_ms {
std::env::set_var("IR_WAL_SYNC_INTERVAL_MS", interval_ms.to_string());
}
match command {
Command::Help => {
print!("{}", help_text());
}
Command::Parse { query } => match query::parse(&query) {
Ok(ast) => print!("{}", ast.to_json_pretty()),
Err(err) => {
eprintln!("parse failed: {:?}", err);
std::process::exit(1);
}
},
Command::Explain { query } => {
let ast = match query::parse(&query) {
Ok(ast) => ast,
Err(err) => {
eprintln!("explain parse failed: {:?}", err);
std::process::exit(1);
}
};
let typed = match query::validate(&ast, &query::Catalog) {
Ok(typed) => typed,
Err(err) => {
eprintln!("explain validation failed: {:?}", err);
std::process::exit(1);
}
};
match runtime::explain(&typed) {
Ok(plan) => print!("{}", plan.to_json_pretty()),
Err(err) => {
eprintln!("explain planning failed: {:?}", err);
std::process::exit(1);
}
}
}
Command::Query { query } => query_cmd::run_query_command(&query, data_root),
Command::ContractReport { scenario } => {
let parsed = match ops::ContractScenario::parse(&scenario) {
Some(scenario) => scenario,
None => {
eprintln!(
"unsupported contract-report scenario '{}'; expected acceptance or retrieval-quality",
scenario
);
std::process::exit(1);
}
};
let checked_at = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("clock after unix epoch")
.as_secs();
let commit = option_env!("GIT_HASH").unwrap_or(env!("CARGO_PKG_VERSION"));
let report = ops::contract_report(parsed, commit, checked_at);
print!("{}", report.to_json_pretty());
}
Command::EvidenceReport { surface } => {
let checked_at = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("clock after unix epoch")
.as_secs();
let commit = option_env!("GIT_HASH").unwrap_or(env!("CARGO_PKG_VERSION"));
match surface.as_str() {
"restart-requery" => {
let report = ops::restart_requery_evidence_v1(commit, checked_at);
print!("{}", report.to_json_pretty());
}
_ => {
eprintln!(
"unsupported evidence-report surface '{}'; expected restart-requery",
surface
);
std::process::exit(1);
}
}
}
Command::ServiceReport { listen } => {
let checked_at = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("clock after unix epoch")
.as_secs();
let report = ops::service_report(listen.as_deref(), checked_at);
print!("{}", report.to_json_pretty());
}
Command::ServiceValidate {
listen,
telemetry_endpoint,
tls,
admin_token,
max_requests,
} => service_cmd::run_service_validate(
data_root,
listen,
telemetry_endpoint,
tls,
admin_token,
max_requests,
),
Command::ServiceServe {
listen,
telemetry_endpoint,
tls,
admin_token,
max_requests,
} => service_cmd::run_service_serve(
data_root,
listen,
telemetry_endpoint,
tls,
admin_token,
max_requests,
),
Command::Health => {
let report = ops::health();
println!("status: {:?}", report.status);
println!("reason: {}", report.reason);
println!("error_rate: {:.6}", report.error_rate);
}
Command::Metrics => {
let m = ops::metrics_snapshot();
println!("query_total: {}", m.query_total);
println!("query_errors: {}", m.query_errors);
println!("query_avg_latency_micros: {}", m.query_avg_latency_micros);
println!("query_p95_latency_micros: {}", m.query_p95_latency_micros);
println!("query_p99_latency_micros: {}", m.query_p99_latency_micros);
println!("ingest_accepted: {}", m.ingest_accepted);
println!("ingest_rejected: {}", m.ingest_rejected);
}
Command::MetricsProm => {
print!("{}", ops::metrics_prometheus_text());
}
Command::Bench {
iterations,
seed,
json_out,
} => bench_cmd::run_bench_command(iterations, seed, json_out),
_ => storage_cmd::run_storage_command(command, data_root),
}
}