generated from PlexSheep/baserepo
336 lines
12 KiB
Rust
336 lines
12 KiB
Rust
//! # monitor your network uptime
|
|
//!
|
|
//! This method offers a way to monitor your networks/hosts uptime. This is achieved by making
|
|
//! HTTPS requests to a given list of
|
|
//!
|
|
//! Warning: This module is not unit tested.
|
|
|
|
//// ATTRIBUTES ////////////////////////////////////////////////////////////////////////////////////
|
|
// we want docs
|
|
#![warn(missing_docs)]
|
|
#![warn(rustdoc::missing_crate_level_docs)]
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// we want Debug everywhere.
|
|
#![warn(missing_debug_implementations)]
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// enable clippy's extra lints, the pedantic version
|
|
#![warn(clippy::pedantic)]
|
|
|
|
use std::{fmt, time::Duration};
|
|
|
|
//// IMPORTS ///////////////////////////////////////////////////////////////////////////////////////
|
|
use crate::logger::*;
|
|
|
|
use reqwest;
|
|
|
|
use humantime::{format_duration, format_rfc3339};
|
|
use std::time::SystemTime;
|
|
|
|
use pyo3::prelude::*;
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json;
|
|
|
|
use crate::divider;
|
|
|
|
//// TYPES /////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//// CONSTANTS /////////////////////////////////////////////////////////////////////////////////////
|
|
/// urls used for checking by default
|
|
pub const DEFAULT_CHECK_URLS: &'static [&'static str] =
|
|
&["https://www.cscherr.de", "https://www.cloudflare.com"];
|
|
|
|
//// STATICS ///////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//// MACROS ////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//// ENUMS /////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//// STRUCTS ///////////////////////////////////////////////////////////////////////////////////////
|
|
/// ## Describes an uptime status
|
|
///
|
|
/// [`UptimeStatus`] describes the result of an uptime check.
|
|
#[pyclass]
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct UptimeStatus {
|
|
/// true if the [`UptimeStatus`] is considered successful
|
|
#[pyo3(get, set)]
|
|
pub success: bool,
|
|
/// the percentage of reachable urls out of the total urls
|
|
#[pyo3(get, set)]
|
|
pub success_ratio: u8,
|
|
/// the percentage of reachable urls out of the total urls that need to be reachable in order
|
|
/// for this [`UptimeStatus`] to be considered a success.
|
|
#[pyo3(get, set)]
|
|
pub success_ratio_target: u8,
|
|
/// the number of reachable [`urls`](UptimeStatus::urls)
|
|
#[pyo3(get, set)]
|
|
pub reachable: usize,
|
|
/// which urls to check in [`check()`](UptimeStatus::check)
|
|
#[pyo3(get, set)]
|
|
pub urls: Vec<String>,
|
|
/// timeout length for requests (in ms)
|
|
#[pyo3(get, set)]
|
|
pub timeout: u64,
|
|
}
|
|
|
|
//// IMPLEMENTATION ////////////////////////////////////////////////////////////////////////////////
|
|
/// Main implementation
|
|
impl UptimeStatus {
|
|
/// ## create a new `UptimeStatus` and perform it's check
|
|
pub fn new(success_ratio_target: u8, urls: Vec<String>, timeout: u64) -> Self {
|
|
assert!(success_ratio_target <= 100);
|
|
let mut status = UptimeStatus {
|
|
success: false,
|
|
success_ratio: 0,
|
|
success_ratio_target,
|
|
reachable: 0,
|
|
urls,
|
|
timeout,
|
|
};
|
|
status.urls.dedup();
|
|
|
|
status.check();
|
|
|
|
return status;
|
|
}
|
|
|
|
/// ## check for success with the given urls
|
|
///
|
|
/// Makes the actual https requests and updates fields accordingly.
|
|
///
|
|
/// Note: Blocking execution for all requests, timeout is set to
|
|
/// [REQUEST_TIMEOUT](crate::networking::REQUEST_TIMEOUT).
|
|
pub fn check(&mut self) {
|
|
self.reachable = 0;
|
|
self.urls.iter().for_each(|url| {
|
|
let client = reqwest::blocking::Client::builder()
|
|
.timeout(Duration::from_millis(self.timeout))
|
|
.build()
|
|
.expect("could not build a client for https requests");
|
|
let response = client.get(url.clone()).send();
|
|
if response.is_ok() {
|
|
self.reachable += 1
|
|
}
|
|
});
|
|
self.calc_success();
|
|
}
|
|
|
|
/// ## calculate the success based on the `reachable` and `total`
|
|
///
|
|
/// Calculates the ratio of [`reachable`](UptimeStatus::reachable) /
|
|
/// (length of [urls](UptimeStatus::urls)).
|
|
///
|
|
/// Calculates a [`success_ratio`](UptimeStatus::success_ratio) (as [u8]) from that,
|
|
/// by multiplying with 100, then flooring.
|
|
///
|
|
/// If the [`success_ratio`](UptimeStatus::success_ratio) is greater than or equal to the
|
|
/// [`success_ratio_target`](UptimeStatus::success_ratio_target), the [`UptimeStatus`] will be
|
|
/// considered a success.
|
|
///
|
|
/// In the special case that no URLs to check for have been provided, the check will be
|
|
/// considered a success, but the [`success_ratio`](UptimeStatus::success_ratio) will be `0`.
|
|
///
|
|
/// Note: does not check for networking, use [`check()`](UptimeStatus::check) for that.
|
|
pub fn calc_success(&mut self) {
|
|
// if no urls need to be checked, success without checking
|
|
if self.urls.len() == 0 {
|
|
self.success = true;
|
|
self.success_ratio = 0;
|
|
return;
|
|
}
|
|
let ratio: f32 = (self.reachable as f32) / (self.urls.len() as f32) * 100f32;
|
|
trace!("calculated success_ratio: {}", ratio);
|
|
self.success_ratio = ratio.floor() as u8;
|
|
self.success = self.success_ratio >= self.success_ratio_target;
|
|
trace!("calculated success as: {}", self.success)
|
|
}
|
|
}
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/// Implementation of the Python interface
|
|
#[pymethods]
|
|
impl UptimeStatus {
|
|
/// calls [`new()`](UptimeStatus::new) with python compatible arguments
|
|
#[new]
|
|
pub fn py_new(success_ratio_target: u8, urls: Vec<String>, timeout: u64) -> Self {
|
|
Self::new(success_ratio_target, urls, timeout)
|
|
}
|
|
|
|
/// Same as [`check()`](UptimeStatus::check)
|
|
#[pyo3(name = "check")]
|
|
pub fn py_check(&mut self) {
|
|
self.check();
|
|
}
|
|
|
|
/// Same as [`calc_success()`](UptimeStatus::calc_success)
|
|
#[pyo3(name = "calc_success")]
|
|
pub fn py_calc_success(&mut self) {
|
|
self.calc_success();
|
|
}
|
|
|
|
/// we want to display the [`UptimeStatus`] in python too, so we need `__str__`
|
|
pub fn __str__(&self) -> String {
|
|
format!("{}", self)
|
|
}
|
|
|
|
/// we want to debug display the [`UptimeStatus`] in python too, so we need `__str__`
|
|
pub fn __repr__(&self) -> String {
|
|
format!("{:?}", self)
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
impl fmt::Debug for UptimeStatus {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let mut urls: Vec<&str> = Vec::new();
|
|
for url in &self.urls {
|
|
urls.push(url.as_str());
|
|
}
|
|
write!(f, "{}", serde_json::to_string(self).unwrap())
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
impl fmt::Display for UptimeStatus {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let mut urls: Vec<&str> = Vec::new();
|
|
for url in &self.urls {
|
|
urls.push(url.as_str());
|
|
}
|
|
write!(f, "{}", serde_json::to_string_pretty(self).unwrap())
|
|
}
|
|
}
|
|
|
|
//// PUBLIC FUNCTIONS //////////////////////////////////////////////////////////////////////////////
|
|
/// ## Uptime monitor
|
|
///
|
|
/// This function continuously monitors the uptime of your host/network.
|
|
///
|
|
/// On change of status, an update will be logged at [INFO Level](log::Level::Info), containing
|
|
/// information on your current status, including timestamps of the last up/down time and durations
|
|
/// since.
|
|
pub fn continuous_uptime_monitor(
|
|
success_ratio_target: u8,
|
|
urls: Vec<String>,
|
|
interval: u64,
|
|
timeout: u64,
|
|
) {
|
|
if urls.len() == 0 {
|
|
error!("No URLs provided. There is nothing to monitor.");
|
|
return;
|
|
}
|
|
|
|
let interval = std::time::Duration::from_millis(interval);
|
|
let mut last_downtime: Option<SystemTime> = None;
|
|
let mut last_uptime: Option<SystemTime> = None;
|
|
let mut status = UptimeStatus::new(success_ratio_target, urls, timeout);
|
|
// we assume that the last status was up, so the binary shows the first status if its a
|
|
// failure.
|
|
let mut last_was_up: bool = true;
|
|
let mut last_ratio: u8 = status.success_ratio;
|
|
loop {
|
|
trace!(?status, ?last_was_up, "loop iteration for continuous uptime monitor");
|
|
if !status.success {
|
|
if last_was_up {
|
|
trace!("displaying status");
|
|
display_uptime_status("fail", last_uptime, last_downtime, &status)
|
|
}
|
|
last_downtime = Some(SystemTime::now());
|
|
last_was_up = false;
|
|
} else if status.success_ratio < 100 {
|
|
if status.success_ratio != last_ratio {
|
|
let msg = format!(
|
|
"uptime check: not all urls are reachable ({}%)",
|
|
status.success_ratio
|
|
);
|
|
display_uptime_status(&msg, last_uptime, last_downtime, &status)
|
|
}
|
|
last_uptime = Some(SystemTime::now());
|
|
last_was_up = true;
|
|
} else {
|
|
if !last_was_up {
|
|
display_uptime_status("success", last_uptime, last_downtime, &status)
|
|
}
|
|
last_uptime = Some(SystemTime::now());
|
|
last_was_up = true;
|
|
}
|
|
|
|
last_ratio = status.success_ratio;
|
|
std::thread::sleep(interval);
|
|
status.check();
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/// Python interface for [`continuous_uptime_monitor`]
|
|
///
|
|
/// Runs the function in a different thread and checks from time to time for things like Pythons
|
|
/// `KeyboardInterrupt` exception.
|
|
#[pyfunction]
|
|
#[pyo3(name = "continuous_uptime_monitor")]
|
|
pub fn py_continuous_uptime_monitor(
|
|
py: Python,
|
|
success_ratio_target: u8,
|
|
urls: Vec<String>,
|
|
interval: u64,
|
|
timeout: u64,
|
|
) -> PyResult<()> {
|
|
// execute the function in a different thread
|
|
let _th = std::thread::spawn(move || {
|
|
continuous_uptime_monitor(success_ratio_target, urls, interval, timeout);
|
|
});
|
|
loop {
|
|
Python::check_signals(py)?;
|
|
std::thread::sleep(std::time::Duration::from_millis(100))
|
|
}
|
|
}
|
|
|
|
//// PRIVATE FUNCTIONS /////////////////////////////////////////////////////////////////////////////
|
|
/// Displays the current status for the [continuous uptime monitor](continuous_uptime_monitor)
|
|
fn display_uptime_status(
|
|
msg: &str,
|
|
last_uptime: Option<SystemTime>,
|
|
last_downtime: Option<SystemTime>,
|
|
status: &UptimeStatus,
|
|
) {
|
|
// I know it's weird that this has two spaces too much, but somehow just the tabs is missing
|
|
// two spaces.
|
|
info!("uptime check: {}", msg);
|
|
info!("last uptime: {}", match_format_time(last_uptime));
|
|
info!("last downtime: {}", match_format_time(last_downtime));
|
|
info!(
|
|
"since downtime: {}",
|
|
match_format_duration_since(last_downtime)
|
|
);
|
|
info!(
|
|
"since uptime: {}",
|
|
match_format_duration_since(last_uptime)
|
|
);
|
|
debug!("\n{}", status);
|
|
info!("{}", divider!());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/// Returns "None" if the given [Option] is [None](Option::None). Otherwise, returns the time stamp
|
|
/// formatted according to rfc3999.
|
|
fn match_format_time(time: Option<SystemTime>) -> String {
|
|
match time {
|
|
Some(time) => format_rfc3339(time).to_string(),
|
|
None => String::from("None"),
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/// Returns "None" if the given [Option] is [None](Option::None). Otherwise, returns duration since
|
|
/// that time in a human readable format.
|
|
fn match_format_duration_since(time: Option<SystemTime>) -> String {
|
|
match time {
|
|
Some(time) => format_duration(
|
|
SystemTime::now()
|
|
.duration_since(time)
|
|
.expect("could not calculate elapsed time"),
|
|
)
|
|
.to_string(),
|
|
None => String::from("None"),
|
|
}
|
|
}
|