backend/src/valheim_controller.rs

   1 use sysinfo::{ ProcessExt, SystemExt };
   2
   3 use std::{ fs, time::SystemTime };
   4
   5 use chrono::{ DateTime, offset::Local };
   6
   7 #[cfg(target_os = "unix")]
   8 use systemd::journal;
   9
  10 #[derive(Clone, Debug)]
  11 pub struct ValheimExe {
  12     memory: u64, // [kB].
  13     load_average_5min: f64, // [%].
  14     uptime: u64, // [s].
  15     world_size: u64, // [B].
  16     nb_of_players: u32,
  17     last_backup: Option<SystemTime>,
  18 }
  19
  20 impl ValheimExe {
  21     pub fn format_memory(&self) -> String {
  22         format_byte_size(self.memory * 1024, 2)
  23     }
  24
  25     pub fn format_load_average(&self) -> String {
  26         format!("{:.2} %", self.load_average_5min)
  27     }
  28
  29     pub fn format_uptime(&self) -> String {
  30         let mins = self.uptime / 60;
  31         let hours = mins / 60;
  32         let days = hours / 24;
  33         format!("{}d{}h{}min", days, hours - 24 * days, mins - 60 * hours)
  34     }
  35
  36     pub fn format_world_size(&self) -> String {
  37         format_byte_size(self.world_size, 2)
  38     }
  39
  40     pub fn get_nb_of_player(&self) -> u32 {
  41         self.nb_of_players
  42     }
  43
  44     pub fn format_last_backup(&self) -> String {
  45         match self.last_backup {
  46             Some(t) => {
  47                 let datetime: DateTime<Local> = t.into();
  48                 datetime.format("%d/%m/%Y %T").to_string()
  49             },
  50             None => String::from("?")
  51         }
  52     }
  53 }
  54
  55 const BINARY_PREFIXES: [&str; 8] = ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB"];
  56
  57 fn format_byte_size(bytes: u64, precision: usize) -> String {
  58     for i in 0 .. 8 {
  59         let mut size: u64 = 1;
  60         size *= 1024u64.pow(i as u32);
  61
  62         if bytes < 1024 {
  63             return format!("{} {}", std::cmp::max(0u64, bytes), BINARY_PREFIXES[i]);
  64         }
  65         else if bytes < 1024 * size {
  66             return format!("{:.prec$} {}", bytes as f64 / size as f64, BINARY_PREFIXES[i], prec = precision);
  67         }
  68     }
  69
  70     String::from("")
  71 }
  72
  73 const VALHEIM_PROCESS_NAME: &str = "valheim_server";
  74
  75 #[cfg(target_os = "unix")]
  76 fn get_number_of_players() -> u32 {
  77     let mut journal =
  78         journal::OpenOptions::default().current_user(true).open().unwrap();
  79
  80     journal.seek_tail().unwrap();
  81
  82     loop {
  83         match journal.previous_entry() {
  84             Ok(Some(entry)) => {
  85                 if let (Some(unit), Some(mess)) = (entry.get("_SYSTEMD_UNIT"), entry.get("MESSAGE")) {
  86                     if unit == "valheim.service" {
  87                         if let Some(pos) = mess.find("Connections") {
  88                             let nb_of_connections_str = mess.get(pos+12..).unwrap();
  89                             if let Some(pos_end) = nb_of_connections_str.find(' ') {
  90                                 if let Ok(n) = nb_of_connections_str.get(0..pos_end).unwrap().parse() {
  91                                     return n;
  92                                 }
  93                             }
  94                         }
  95                     }
  96                 }
  97             },
  98             _ => return 0
  99         }
 100     }
 101 }
 102
 103 #[cfg(target_os = "windows")]
 104 fn get_number_of_players() -> u32 {
 105     0
 106 }
 107
 108 fn get_last_backup_datetime(backup_path: &str) -> Option<SystemTime> {
 109     let mut times =
 110         fs::read_dir(backup_path).ok()?.filter_map(
 111             |e| {
 112                 let dir = e.ok()?;
 113                 if dir.path().is_file() { Some(dir.metadata().ok()?.created().ok()?) } else { None }
 114             }
 115         )
 116         .collect::<Vec<SystemTime>>();
 117
 118     times.sort();
 119
 120     Some(times.last()?.clone())
 121 }
 122
 123 pub fn get_valheim_executable_information(world_path: &str, backup_path: &str) -> Option<ValheimExe> {
 124     let mut system = sysinfo::System::new_all();
 125     system.refresh_system();
 126     let processes = system.get_process_by_name(VALHEIM_PROCESS_NAME);
 127
 128     if processes.len() >= 1 {
 129         let process = processes.first().unwrap();
 130
 131         let world_size = match std::fs::metadata(world_path) { Ok(f) => f.len(), Err(_) => 0u64 };
 132
 133         Some(
 134             ValheimExe {
 135                 memory: process.memory(),
 136                 load_average_5min: system.get_load_average().five / system.get_processors().len() as f64 * 100.,
 137                 uptime: std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs() - process.start_time(),
 138                 world_size,
 139                 nb_of_players: get_number_of_players(),
 140                 last_backup: get_last_backup_datetime(backup_path)
 141             }
 142         )
 143     } else {
 144         None
 145     }
 146 }