Uptime checks

use uptime_check.qweruse uptime_tcp, uptime_http from uptime_check      // Quillo 0.6: only these

ureq = "2"

// A status page: this server's own health route, its port, and a port nothing listens on.////   quillo run uptime_check.qwe      then open http://localhost:8080/statususe "uptime_check.qwer"route GET /health = { ok: true }route GET /broken = respond(503, "down for maintenance")route GET /status {    let me = request.headers.host                       // this server, e.g. localhost:8080    let port = int(split(me, ":")[1] ?? "80")    let checks = uptime_check_all([`http://${me}/health`, `http://${me}/broken`, `127.0.0.1:${port}`, "127.0.0.1:9"], 2000)?    {        all_up: all(checks, (c) => c.up),        checks: checks | map((c) => { target: replace(c.target, me, "self"), up: c.up, status: c.status ?? null, fast: c.ms < 1000 }),    }}route GET /ping ? { host: str = "127.0.0.1", port: int = 9 } = uptime_tcp(host, port, 1000)

//! Uptime checks for a status page or a monitor: is a host's port open and how fast it answers, and a URL's status code and response time, many checked at once.//! version: 1.0.0//!//! [dependencies]//! ureq = "2"use serde_json::{json, Value};use std::net::{TcpStream, ToSocketAddrs};use std::time::{Duration, Instant};fn ms(t: Instant) -> f64 {    (t.elapsed().as_secs_f64() * 10_000.0).round() / 10.0}fn timeout(ms: i64) -> Duration {    Duration::from_millis(ms.clamp(50, 60_000) as u64)}/// Can a TCP connection be opened to `host`:`port` within `timeout_ms` (50 to 60,000)? `{ up, ms, address, error }`, `ms` the time to connect (or to fail).pub fn uptime_tcp(host: &str, port: i64, timeout_ms: i64) -> Value {    let t = Instant::now();    if !(1..=65535).contains(&port) {        return json!({ "up": false, "ms": 0.0, "address": null, "error": format!("{} is not a port", port) });    }    let addrs: Vec<_> = match (host, port as u16).to_socket_addrs() {        Ok(a) => a.collect(),        Err(e) => return json!({ "up": false, "ms": ms(t), "address": null, "error": format!("cannot resolve {}: {}", host, e) }),    };    let mut last = String::from("no address");    for a in &addrs {        match TcpStream::connect_timeout(a, timeout(timeout_ms)) {            Ok(_) => return json!({ "up": true, "ms": ms(t), "address": a.to_string(), "error": null }),            Err(e) => last = e.to_string(),        }    }    json!({ "up": false, "ms": ms(t), "address": addrs.first().map(|a| a.to_string()), "error": last })}/// Makes a GET to `url` (redirects followed, up to 5) and times it: `{ up, status, ms, error }`. `up` is true for a 2xx or 3xx status;/// a 4xx or 5xx is down with its status, and a timeout or refused connection is down with status 0.pub fn uptime_http(url: &str, timeout_ms: i64) -> Value {    let t = Instant::now();    let agent = ureq::AgentBuilder::new().timeout(timeout(timeout_ms)).user_agent("quillo-uptime/1.0").build();    match agent.get(url).call() {        Ok(r) => json!({ "up": r.status() < 400, "status": r.status(), "ms": ms(t), "error": null }),        Err(ureq::Error::Status(code, _)) => json!({ "up": false, "status": code, "ms": ms(t), "error": format!("status {}", code) }),        Err(e) => json!({ "up": false, "status": 0, "ms": ms(t), "error": e.to_string() }),    }}/// Checks many targets at once, each on its own thread: URLs (`https://...`) with `uptime_http`, `host:port` with `uptime_tcp`./// Gives one result per target, in the order given, each with its `target`. At most 100 targets.pub fn uptime_check_all(targets: Vec<String>, timeout_ms: i64) -> Result<Vec<Value>, String> {    if targets.len() > 100 {        return Err("at most 100 targets at once".into());    }    let handles: Vec<_> = targets        .into_iter()        .map(|target| {            std::thread::spawn(move || {                let mut r = if target.contains("://") {                    uptime_http(&target, timeout_ms)                } else {                    match target.rsplit_once(':').and_then(|(h, p)| p.parse::<i64>().ok().map(|p| (h.trim_matches(|c| c == '[' || c == ']').to_string(), p))) {                        Some((h, p)) => uptime_tcp(&h, p, timeout_ms),                        None => json!({ "up": false, "ms": 0.0, "error": "a target is a URL or host:port" }),                    }                };                r["target"] = json!(target);                r            })        })        .collect();    Ok(handles.into_iter().map(|h| h.join().unwrap_or_else(|_| json!({ "up": false, "error": "the check failed" }))).collect())}