backend/src/minecraft_controller.rs

   1 use std::{ fs, time::SystemTime };
   2 use sysinfo::{ ProcessExt, SystemExt };
   3 use chrono::{ DateTime, offset::Local };
   4
   5 #[derive(Clone, Debug)]
   6 pub struct MinecraftExe {
   7     memory: u64, // [kB].
   8     load_average_5min: f64, // [%].
   9     uptime: u64, // [s].
  10     world_size: u64, // [B].
  11     active_players: Vec<String>,
  12     version: String,
  13     last_backup: Option<SystemTime>,
  14 }
  15
  16 impl MinecraftExe {
  17     pub fn format_memory(&self) -> String {
  18         format_byte_size(self.memory * 1024, 2)
  19     }
  20
  21     pub fn format_load_average(&self) -> String {
  22         format!("{:.2} %", self.load_average_5min)
  23     }
  24
  25     pub fn format_uptime(&self) -> String {
  26         let mins = self.uptime / 60;
  27         let hours = mins / 60;
  28         let days = hours / 24;
  29         format!("{}d {}h {}min", days, hours - 24 * days, mins - 60 * hours)
  30     }
  31
  32     pub fn format_world_size(&self) -> String {
  33         format_byte_size(self.world_size, 2)
  34     }
  35
  36     pub fn format_active_players(&self) -> String {
  37         if self.active_players.len() == 0 {
  38             String::from("<none>")
  39         } else {
  40             self.active_players.join(", ")
  41         }
  42     }
  43
  44     pub fn format_version(&self) -> String {
  45         self.version.clone()
  46     }
  47
  48     pub fn format_last_backup(&self) -> String {
  49         match self.last_backup {
  50             Some(t) => {
  51                 let datetime: DateTime<Local> = t.into();
  52                 datetime.format("%d/%m/%Y %T").to_string()
  53             },
  54             None => String::from("?")
  55         }
  56     }
  57 }
  58
  59 const BINARY_PREFIXES: [&str; 8] = ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB"];
  60
  61 fn format_byte_size(bytes: u64, precision: usize) -> String {
  62     for i in 0 .. 8 {
  63         let mut size: u64 = 1;
  64         size *= 1024u64.pow(i as u32);
  65
  66         if bytes < 1024 {
  67             return format!("{} {}", std::cmp::max(0u64, bytes), BINARY_PREFIXES[i]);
  68         }
  69         else if bytes < 1024 * size {
  70             return format!("{:.prec$} {}", bytes as f64 / size as f64, BINARY_PREFIXES[i], prec = precision);
  71         }
  72     }
  73
  74     String::from("")
  75 }
  76
  77 const MINECRAFT_PROCESS_NAME: &str = "java";
  78
  79 struct StatusFromRcon {
  80     players: Vec<String>,
  81     version: String,
  82 }
  83
  84 fn get_status_from_rcon(rcon_password: &str) -> StatusFromRcon {
  85     let mut client = minecraft_client_rs::Client::new("127.0.0.1:25575".to_string()).unwrap();
  86
  87     let status =
  88         match client.authenticate(rcon_password.to_string()) {
  89             Ok(_) => {
  90                 StatusFromRcon {
  91                     players:
  92                         match client.send_command("list".to_string()) {
  93                             Ok(resp) =>
  94                                 match resp.body.find(':') {
  95                                     Some(i) if i < resp.body.len() -1 =>
  96                                         resp.body[i + 1..resp.body.len()]
  97                                             .split(',')
  98                                             .map(|nick| nick.trim().to_string())
  99                                             .filter(|nick| !nick.is_empty())
 100                                             .collect(),
 101                                     _ => Vec::new()
 102                                 },
 103                             Err(_e) => {
 104                                 println!("Error from 'list' command");
 105                                 Vec::new()
 106                             },
 107                         },
 108                     version:
 109                         match client.send_command("list".to_string()) {
 110                             Ok(resp) => resp.body,
 111                             Err(_e) => {
 112                                 println!("Error from 'version' command");
 113                                 String::new()
 114                             }
 115                         }
 116                 }
 117             },
 118             Err(_e) => {
 119                 println!("Authentication error");
 120                 StatusFromRcon { players: Vec::new(), version: String::new() }
 121             },
 122         };
 123
 124     client.close().unwrap();
 125
 126     status
 127 }
 128
 129 fn get_last_backup_datetime(backup_path: &str) -> Option<SystemTime> {
 130     let mut times =
 131         fs::read_dir(backup_path).ok()?.filter_map(
 132             |e| {
 133                 let dir = e.ok()?;
 134                 if dir.path().is_file() { Some(dir.metadata().ok()?.modified().ok()?) } else { None }
 135             }
 136         )
 137         .collect::<Vec<SystemTime>>();
 138
 139     times.sort();
 140
 141     Some(times.last()?.clone())
 142 }
 143
 144 pub fn get_minecraft_executable_information(world_path: &str, backup_path: &str, rcon_password: &str) -> Option<MinecraftExe> {
 145     let mut system = sysinfo::System::new_all();
 146     system.refresh_system();
 147     let mut processes = system.processes_by_name(MINECRAFT_PROCESS_NAME);
 148
 149     // TODO: find the correct process by checking the correct jar name in parameters.
 150     if let Some(process) = processes.next() {
 151         let world_size = match fs_extra::dir::get_size(world_path) { Ok(l) => l, Err(_) => 0u64 };
 152
 153         let status_from_rcon = get_status_from_rcon(rcon_password);
 154
 155         Some(
 156             MinecraftExe {
 157                 memory: process.memory() / 3, // Because the Java garbage collector ZGC reports three times more the real memory usage: https://stackoverflow.com/a/62934057/212675
 158                 load_average_5min: system.load_average().five / system.processors().len() as f64 * 100.,
 159                 uptime: std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs() - process.start_time(),
 160                 world_size,
 161                 active_players: status_from_rcon.players,
 162                 version: status_from_rcon.version,
 163                 last_backup: get_last_backup_datetime(backup_path)
 164             }
 165         )
 166     } else {
 167         None
 168     }
 169 }