Added CPU usage and Memory usage endpoints, started updating documentation for the HTTP API

Author: Tobias de Bruijn

Makefile

@@ -37,11 +37,11 @@ web/node_modules:
 	cd web; \
 		npm i
 
-web/dist/dist.js: $(wildcard web/node_modules) ${TS_SOURCE_FILES} ${SCSS_SOURCE_FILES}
+web/dist/dist.js: web/node_modules ${TS_SOURCE_FILES} ${SCSS_SOURCE_FILES}
 	cd web; \
 		npx webpack
 
-web/dist/ansi_up.js: $(wildcard web/node_modules/ansi_up/ansi_up.js)
+web/dist/ansi_up.js: web/node_modules
 	cp web/node_modules/ansi_up/ansi_up.js web/dist/ansi_up.js
 
 web/dist.zip: web/dist/dist.js web/dist/ansi_up.js ${STATIC_WEB_CONTENT}

docs/http/stats/cpu.md

@@ -0,0 +1,23 @@
+# CPU
+Get information about the CPU and CPU usage
+
+## CPU Usage (load)
+Endpoint: `/stats/cpu/load`
+Method: `POST`
+
+Request payload: (x-www-form-urlencoded)
+```
+session_id: The user's session ID
+```
+
+Request response;
+```jsonc
+{
+    "status": 200, //200 if okay, 401 if session_id is invalid
+    "load": {              //For linux, see alsso: https://man7.org/linux/man-pages/man3/getloadavg.3.html
+        "one": 1.0,        //On *nix: Average over 1 minute. On Windows: CPU utilization with a 500ms sampling period, or -1.0 if an error occurred
+        "five": 1.0,       //On *nix: Average over 5 minutes. -1.0 on Windows (Not supported)
+        "fifteen": 1.0     //On *nix: Average over 15 minutes. -1.0 on Windows (Not supported)
+    }
+}
+```

docs/http/stats/jvm_mem_explained.png

@@ -0,0 +1,22 @@
+# Memory
+Get information about Memory (RAM) usage and availability
+
+## Memory usage
+Endpoint: `/stats/mem`
+Method: `POST`
+
+Request payload: (x-www-form-urlencoded)
+```
+session_id: The user's session ID
+```
+
+Response:
+```jsonc
+{
+    "status": 200,      //200 if okay, 401 if session_id is invalid
+    "total_mem": 1.0,   //Total memory available for new Objects
+    "free_mem": 1.0,    //Memory currently used by instantiated Objects
+    "max_mem": 1.0,     //Unalocated memory, but designated for future objects
+}
+```
+![Java memory guide](jvm_mem_explained.png)

docs/http/stats/mem.md

@@ -25,3 +25,9 @@ bcrypt = "0.9.0"
 sha2 = "0.9.3"
 base64 = "0.13.0"
 chrono = "0.4.19"
+
+[target.'cfg(unix)'.dependencies]
+libc = "0.2.93"
+
+[target.'cfg(windows)'.dependencies]
+winapi = { version = "0.3.9", features = ["std", "processthreadsapi", "minwindef"]}

librconsole/Cargo.toml

@@ -1,2 +1,28 @@
+use crate::jni::JvmCommand;
+use crate::webserver::AppData;
+use crate::database::Database;
+use crate::jni::logging::{ConsoleLogItem, LogLevel};
+use rusqlite::named_params;
+use std::io;
+use std::path::PathBuf;
+
 pub mod console;
-pub mod auth;
+pub mod auth;
+pub mod stats;
+
+pub fn check_session_id(data: &AppData, session_id: &str) -> io::Result<bool> {
+    let db = Database::new(PathBuf::from(data.db_path.clone())).unwrap();
+    let sql_check_session: rusqlite::Result<bool> =  db.connection.query_row("SELECT EXISTS(SELECT 1 FROM sessions WHERE session_id = :session_id)", named_params! {
+        ":session_id": session_id
+    }, |row| row.get(0));
+
+    if sql_check_session.is_err() {
+        let tx = data.jvm_command_tx.lock().unwrap();
+        let jvm_command = JvmCommand::log(ConsoleLogItem::new(LogLevel::Warn,format!("An error occurred while verifying a session_id: {:?}", sql_check_session.err().unwrap()) ));
+        tx.send(jvm_command).expect("An issue occurred while sending a JvmCommand");
+
+        return Err(io::Error::new(io::ErrorKind::Other, "An issue occurred while executing the database query"));
+    }
+
+    Ok(sql_check_session.unwrap())
+}

librconsole/src/endpoints/mod.rs

@@ -0,0 +1,146 @@
+use crate::webserver::AppData;
+use crate::endpoints::check_session_id;
+use actix_web::{web, post, HttpResponse};
+use serde::{Serialize, Deserialize};
+use std::io;
+
+#[cfg(windows)]
+use winapi::um::processthreadsapi::GetSystemTimes;
+#[cfg(windows)]
+use winapi::shared::minwindef::FILETIME;
+#[cfg(windows)]
+use std::time::Duration;
+
+#[cfg(unix)]
+use libc::c_int;
+
+#[cfg(windows)]
+const WINDOWS_SAMPLE_TIME_MILIS: u64 = 500;
+
+#[derive(Serialize)]
+pub struct LoadAverage {
+    one:        f64,
+    five:       f64,
+    fifteen:    f64
+}
+
+#[derive(Deserialize)]
+pub struct LoadAverageRequest {
+    session_id: String
+}
+
+#[derive(Serialize)]
+pub struct LoadAverageResponse {
+    status: i16,
+    load:   Option<LoadAverage>
+}
+
+#[cfg(unix)]
+#[link(name = "c")]
+#[allow(dead_code)] //Even though it's used, we still get a warning
+extern "C" {
+    fn getloadavg(loadavg: *mut f64, nelem: c_int) -> c_int;
+}
+
+#[cfg(windows)]
+#[inline(always)]
+#[allow(dead_code)] //Even though it's used, we still get a warning
+fn empty() -> FILETIME {
+    FILETIME {
+        dwLowDateTime: 0,
+        dwHighDateTime: 0,
+    }
+}
+
+#[cfg(windows)]
+#[inline(always)]
+#[allow(dead_code)] //Even though it's used, we still get a warning
+fn filetime_to_u64(f: FILETIME) -> u64 {
+    (f.dwHighDateTime as u64) << 32 | (f.dwLowDateTime as u64)
+
+}
+
+#[cfg(windows)]
+#[allow(dead_code)] //Even though it's used, we still get a warning
+fn win_poll_load_avg() -> io::Result<f64> {
+    let get_system_times = || -> io::Result<(u64, u64)> {
+        let mut idle_ticks = empty();
+        let mut user_ticks = empty();
+        let mut kernel_ticks = empty();
+
+        if unsafe { GetSystemTimes(&mut idle_ticks, &mut kernel_ticks, &mut user_ticks) }== 0 {
+            return Err(io::Error::new(io::ErrorKind::Other, "GetSystemTimes() failed"));
+        }
+
+        let idle_ticks = filetime_to_u64(idle_ticks);
+        let total_ticks = filetime_to_u64(kernel_ticks) + filetime_to_u64(user_ticks);
+
+        Ok((idle_ticks, total_ticks))
+    };
+
+    let (idle_ticks_before, total_ticks_before) = get_system_times()?;
+    std::thread::sleep(Duration::from_millis(WINDOWS_SAMPLE_TIME_MILIS));
+
+    let (idle_ticks_after, total_ticks_after) = get_system_times()?;
+    let delta_idle_ticks = idle_ticks_after - idle_ticks_before;
+    let delta_total_ticks = total_ticks_after - total_ticks_before;
+
+    let div_ticks = if delta_total_ticks > 0u64 {
+        //We need to cast these to f64, otherwise we get integer division and not floating point division
+        (delta_idle_ticks as f64) / (delta_total_ticks as f64)
+    } else {
+        0f64
+    };
+
+    let result = 1f64 - div_ticks;
+    Ok(result)
+}
+
+fn load_avg() -> io::Result<LoadAverage> {
+    #[cfg(windows)]
+    {
+        let cpu_usage = win_poll_load_avg()?;
+
+        return Ok(LoadAverage {
+            one: cpu_usage,
+            five: -1f64,    //Unsupported on Windows
+            fifteen: -1f64  //Unsupported on Windows
+        });
+    }
+
+    # [cfg(unix)]
+    {
+        let mut loads: [f64; 3] = [0.0, 0.0, 0.0];
+        if unsafe{ getloadavg(&mut loads[0], 3) } != 3 {
+            return Err(io::Error::new(io::ErrorKind::Other, "getloadavg() failed"));
+        }
+
+        return Ok(LoadAverage {
+            one: loads[0],
+            five: loads[1],
+            fifteen: loads[2]
+        });
+    }
+}
+
+#[post("/stats/cpu/load")]
+pub fn post_get_load_avg(data: web::Data<AppData>, form: web::Form<LoadAverageRequest>) -> HttpResponse {
+    let session_valid = check_session_id(&data, &form.session_id);
+    if session_valid.is_err() {
+        return HttpResponse::InternalServerError().finish();
+    }
+
+    if !session_valid.unwrap() {
+        return HttpResponse::Ok().json(LoadAverageResponse { status: 401, load: None });
+    }
+
+    let load = load_avg();
+    if load.is_err() {
+        return HttpResponse::InternalServerError().finish();
+    }
+
+    HttpResponse::Ok().json(LoadAverageResponse {
+        status: 200,
+        load: Some(load.unwrap())
+    })
+}

librconsole/src/endpoints/stats/cpu.rs

@@ -0,0 +1,77 @@
+use actix_web::{post, web, HttpResponse};
+use serde::{Serialize, Deserialize};
+use crate::webserver::AppData;
+use crate::endpoints::check_session_id;
+use crate::jni::{JvmCommand, Method};
+use jni::sys::jlong;
+
+#[derive(Deserialize)]
+pub struct GetMemRequest {
+    session_id: String
+}
+
+#[derive(Serialize)]
+pub struct GetMemResponse {
+    status:     i16,
+    total_mem:  Option<f64>,
+    free_mem:   Option<f64>,
+    max_mem:    Option<f64>
+}
+
+#[post("/stats/mem")]
+pub fn post_get_mem(data: web::Data<AppData>, form: web::Form<GetMemRequest>) -> HttpResponse {
+    let session_id_valid = check_session_id(&data, &form.session_id);
+    if session_id_valid.is_err() {
+        return HttpResponse::InternalServerError().finish();
+    }
+
+    if !session_id_valid.unwrap() {
+        return HttpResponse::Ok().json(GetMemResponse { status: 401, free_mem: None, total_mem: None, max_mem: None });
+    }
+
+    let tx = data.jvm_command_tx.lock().unwrap();
+
+    let runtime_class_command = JvmCommand::get_class("java/lang/Runtime");
+    tx.send(runtime_class_command.0).expect("An error occurred while sending the JvmCommand 'runtime_class_command'");
+    let runtime_class = runtime_class_command.1.recv().unwrap();
+
+    let get_runtime_method = Method::static_method(runtime_class, "getRuntime", "()Ljava/lang/Runtime;", Vec::new());
+    let get_runtime_command = JvmCommand::exec_method(get_runtime_method);
+    tx.send(get_runtime_command.0).expect("An error occurred while sending the JvmCommand 'get_runtime_command'");
+    let runtime_object = get_runtime_command.1.recv().unwrap();
+
+    let total_mem_method = Method::method(runtime_object, "totalMemory", "()J", Vec::new());
+    let total_mem_command = JvmCommand::exec_method(total_mem_method);
+    tx.send(total_mem_command.0).expect("An error occurred while sending the JvmCommand 'total_mem_command'");
+    let total_mem_jobject = total_mem_command.1.recv().unwrap();
+
+    let free_mem_method = Method::method(runtime_object, "freeMemory", "()J", Vec::new());
+    let free_mem_command = JvmCommand::exec_method(free_mem_method);
+    tx.send(free_mem_command.0).expect("An error occurred while sending the JvmCommand 'free_mem_command'");
+    let free_mem_jobject = free_mem_command.1.recv().unwrap();
+
+    let max_mem_method = Method::method(runtime_object, "maxMemory", "()J", Vec::new());
+    let max_mem_command = JvmCommand::exec_method(max_mem_method);
+    tx.send(max_mem_command.0).expect("An error occurred while sending the JvmCommand 'max_mem_command'");
+    let max_mem_jobject = max_mem_command.1.recv().unwrap();
+
+    //the objects are of type *mut _jobject, so is jlong, so we can cast them directly
+    //since we know the methods we called return a java long, i.e i64.
+    //We then cast them to f64, so we can floating point division when we convert the
+    //values from Bytes to Megabytes
+    let total_mem = total_mem_jobject as jlong as f64;
+    let free_mem = free_mem_jobject as jlong as f64;
+    let max_mem = max_mem_jobject as jlong as f64;
+
+    const BYTE_TO_MB_FACTOR: f64 = 1_000_000f64;
+
+    //Some more information about the memory metrics, see: https://stackoverflow.com/a/18375641/10765090
+    let response = GetMemResponse {
+        status: 200,
+        total_mem: Some(total_mem / BYTE_TO_MB_FACTOR),
+        free_mem: Some(free_mem / BYTE_TO_MB_FACTOR),
+        max_mem: Some(max_mem / BYTE_TO_MB_FACTOR)
+    };
+
+    HttpResponse::Ok().json(response)
+}

librconsole/src/endpoints/stats/mem.rs

@@ -0,0 +1,2 @@
+pub mod cpu;
+pub mod mem;

librconsole/src/endpoints/stats/mod.rs

@@ -141,12 +141,12 @@ impl Method {
         args: The Arguments to be passed to the method. The order should be the same as provided in the method's signature. If no arguments are needed, an empty Vec should be provided
     */
     #[allow(dead_code)]
-    pub fn method(obj: jobject, name: String, sig: String, args: Vec<Argument>) -> Method {
+    pub fn method(obj: jobject, name: &str, sig: &str, args: Vec<Argument>) -> Method {
         Method {
             class: None,
             obj: Some(obj),
-            name,
-            sig,
+            name: name.to_string(),
+            sig: sig.to_string(),
             args
         }
     }
@@ -166,7 +166,13 @@ pub enum Argument {
 
 pub fn jvm_command_exec(env: JNIEnv, rx: Receiver<JvmCommand>) {
     loop {
-        let received_cmd = rx.recv().unwrap();
+        let received_cmd_wrapped = rx.recv();
+        if received_cmd_wrapped.is_err() {
+            eprintln!("An error occurred while receiving on the jvm_command_exec Receiver: {:?}", received_cmd_wrapped.err().unwrap());
+            std::process::exit(1);
+        }
+
+        let  received_cmd = received_cmd_wrapped.unwrap();
         match received_cmd.intent {
             Intent::Log(log_item) => {
                 match log_item.level {

librconsole/src/jni/mod.rs

@@ -80,7 +80,10 @@ pub extern "system" fn Java_nl_thedutchmc_rconsole_webserver_Native_startWebServ
 
     //Start the HTTP server
     std::thread::spawn(move || {
-        let _ = crate::webserver::start(config,database_file_path, static_files_path, jvm_command_tx);
+        let webserver_start = crate::webserver::start(config,database_file_path, static_files_path, jvm_command_tx);
+        if webserver_start.is_err() {
+            panic!("An error occurred while running the Actix web server: {:?}", webserver_start.err().unwrap());
+        }
     });
 
     jvm_command_exec(env, jvm_command_rx);

librconsole/src/jni/web_server_native.rs

@@ -32,13 +32,14 @@ pub async fn start(config: Config, db_path: String, static_files_path: String, j
             .service(crate::endpoints::console::logs_new::post_logs_new)
             .service(crate::endpoints::console::execute_command::post_execute_command)
             .service(crate::endpoints::auth::login::post_login)
+            .service(crate::endpoints::stats::cpu::post_get_load_avg)
+            .service(crate::endpoints::stats::mem::post_get_mem)
             .service(Files::new("/", &static_files_path)
                 .prefer_utf8(true)
                 .index_file("index.html")
                 .show_files_listing()
             )
     })
-    .bind(format!("0.0.0.0:{}", port))?
     .bind(format!("[::]:{}", port))?
     .run()
     .await