mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-21 19:25:56 +00:00
Merge pull request #231 from Corfirean/feat/weekly-restart-log-cleanup-on-master
Settings: weekly world restart and server log auto-cleanup
This commit is contained in:
16 files changed
+795
-41
No files matched your search
@@ -5,7 +5,7 @@
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::Duration;
|
||||
|
||||
use chrono::{Local, NaiveDateTime, NaiveTime, Timelike};
|
||||
use chrono::{Datelike, Local, NaiveDateTime, NaiveTime, Timelike};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::error::{Error, Result};
|
||||
@@ -20,14 +20,53 @@ const LATE: Duration = Duration::from_secs(15 * 60);
|
||||
/// A world that has not come back within this time no longer counts as restarting.
|
||||
const UNDER_WAY_LIMIT: Duration = Duration::from_secs(45 * 60);
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
pub enum Weekday {
|
||||
Monday,
|
||||
Tuesday,
|
||||
Wednesday,
|
||||
Thursday,
|
||||
Friday,
|
||||
Saturday,
|
||||
#[default]
|
||||
Sunday,
|
||||
}
|
||||
|
||||
impl Weekday {
|
||||
fn to_chrono(self) -> chrono::Weekday {
|
||||
match self {
|
||||
Self::Monday => chrono::Weekday::Mon,
|
||||
Self::Tuesday => chrono::Weekday::Tue,
|
||||
Self::Wednesday => chrono::Weekday::Wed,
|
||||
Self::Thursday => chrono::Weekday::Thu,
|
||||
Self::Friday => chrono::Weekday::Fri,
|
||||
Self::Saturday => chrono::Weekday::Sat,
|
||||
Self::Sunday => chrono::Weekday::Sun,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct DueRestart {
|
||||
pub moment: NaiveDateTime,
|
||||
pub warning_minutes: u32,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
#[serde(rename_all = "camelCase", default)]
|
||||
pub struct RestartSchedule {
|
||||
pub enabled: bool,
|
||||
/// Local time, `HH:MM`.
|
||||
pub time: String,
|
||||
/// The in-game countdown before the restart, in minutes (1-60).
|
||||
pub warning_minutes: u32,
|
||||
pub weekly_enabled: bool,
|
||||
pub weekly_day: Weekday,
|
||||
/// Local time for weekly restart, `HH:MM`.
|
||||
pub weekly_time: String,
|
||||
/// The in-game countdown before the weekly restart, in minutes (1-60).
|
||||
pub weekly_warning_minutes: u32,
|
||||
}
|
||||
|
||||
impl Default for RestartSchedule {
|
||||
@@ -36,35 +75,72 @@ impl Default for RestartSchedule {
|
||||
enabled: false,
|
||||
time: "05:00".into(),
|
||||
warning_minutes: 5,
|
||||
weekly_enabled: false,
|
||||
weekly_day: Weekday::Sunday,
|
||||
weekly_time: "05:00".into(),
|
||||
weekly_warning_minutes: 5,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl RestartSchedule {
|
||||
fn at(&self) -> Option<NaiveTime> {
|
||||
NaiveTime::parse_from_str(self.time.trim(), "%H:%M").ok()
|
||||
fn parse_time(text: &str) -> Option<NaiveTime> {
|
||||
NaiveTime::parse_from_str(text.trim(), "%H:%M").ok()
|
||||
}
|
||||
|
||||
fn validate(&self) -> Result<()> {
|
||||
if self.at().is_none() {
|
||||
fn validate_entry(time: &str, warning_minutes: u32) -> Result<()> {
|
||||
if Self::parse_time(time).is_none() {
|
||||
return Err(Error::Invalid("The restart time must be HH:MM, for example 05:00.".into()));
|
||||
}
|
||||
if !(1..=60).contains(&self.warning_minutes) {
|
||||
if !(1..=60).contains(&warning_minutes) {
|
||||
return Err(Error::Invalid("The restart warning must be 1 to 60 minutes.".into()));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The scheduled moment of `now`'s day, when a restart is due at `now` for a world started at `started`:
|
||||
/// the moment has passed by less than [`LATE`] and the world was already running before it.
|
||||
pub fn due(&self, now: NaiveDateTime, started: NaiveDateTime) -> Option<NaiveDateTime> {
|
||||
if !self.enabled {
|
||||
return None;
|
||||
fn validate(&self) -> Result<()> {
|
||||
if self.enabled {
|
||||
Self::validate_entry(&self.time, self.warning_minutes)?;
|
||||
}
|
||||
let moment = now.date().and_time(self.at()?);
|
||||
if self.weekly_enabled {
|
||||
Self::validate_entry(&self.weekly_time, self.weekly_warning_minutes)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn due_at(time_str: &str, now: NaiveDateTime, started: NaiveDateTime) -> Option<NaiveDateTime> {
|
||||
let at = Self::parse_time(time_str)?;
|
||||
let moment = now.date().and_time(at);
|
||||
let late = now.signed_duration_since(moment).to_std().ok()?;
|
||||
(late <= LATE && started < moment).then_some(moment)
|
||||
}
|
||||
|
||||
/// The scheduled moment of `now`'s day, when a daily or weekly restart is due at `now` for a world started at `started`:
|
||||
/// the moment has passed by less than [`LATE`] and the world was already running before it.
|
||||
pub fn due_restart(&self, now: NaiveDateTime, started: NaiveDateTime) -> Option<DueRestart> {
|
||||
if self.weekly_enabled && now.weekday() == self.weekly_day.to_chrono() {
|
||||
if let Some(moment) = Self::due_at(&self.weekly_time, now, started) {
|
||||
return Some(DueRestart {
|
||||
moment,
|
||||
warning_minutes: self.weekly_warning_minutes,
|
||||
});
|
||||
}
|
||||
}
|
||||
if self.enabled {
|
||||
if let Some(moment) = Self::due_at(&self.time, now, started) {
|
||||
return Some(DueRestart {
|
||||
moment,
|
||||
warning_minutes: self.warning_minutes,
|
||||
});
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// The scheduled moment of `now`'s day, when a restart is due at `now` for a world started at `started`.
|
||||
pub fn due(&self, now: NaiveDateTime, started: NaiveDateTime) -> Option<NaiveDateTime> {
|
||||
self.due_restart(now, started).map(|d| d.moment)
|
||||
}
|
||||
}
|
||||
|
||||
/// The folder whose schedule a world follows: an extra world (`<server>/.realms/<name>`) follows its server's.
|
||||
@@ -84,11 +160,14 @@ pub fn load(root: &Path) -> RestartSchedule {
|
||||
pub fn save(root: &Path, schedule: &RestartSchedule) -> Result<RestartSchedule> {
|
||||
let mut schedule = schedule.clone();
|
||||
schedule.time = schedule.time.trim().to_string();
|
||||
if schedule.enabled {
|
||||
schedule.validate()?;
|
||||
} else if schedule.at().is_none() {
|
||||
schedule.weekly_time = schedule.weekly_time.trim().to_string();
|
||||
schedule.validate()?;
|
||||
if !schedule.enabled && RestartSchedule::parse_time(&schedule.time).is_none() {
|
||||
schedule.time = RestartSchedule::default().time;
|
||||
}
|
||||
if !schedule.weekly_enabled && RestartSchedule::parse_time(&schedule.weekly_time).is_none() {
|
||||
schedule.weekly_time = RestartSchedule::default().weekly_time;
|
||||
}
|
||||
crate::fsx::atomic_write_json(&owner(root).join(FILE), &schedule)?;
|
||||
Ok(schedule)
|
||||
}
|
||||
@@ -127,7 +206,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn a_restart_is_due_once_after_its_time_for_a_world_that_ran_before_it() {
|
||||
let s = RestartSchedule { enabled: true, time: "05:00".into(), warning_minutes: 5 };
|
||||
let s = RestartSchedule { enabled: true, time: "05:00".into(), warning_minutes: 5, ..RestartSchedule::default() };
|
||||
let started = at("2026-11-14 20:00");
|
||||
assert_eq!(s.due(at("2026-11-15 04:59"), started), None);
|
||||
assert_eq!(s.due(at("2026-11-15 05:00"), started), Some(at("2026-11-15 05:00")));
|
||||
@@ -140,19 +219,88 @@ mod tests {
|
||||
assert_eq!(off.due(at("2026-11-15 05:00"), started), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn weekly_restart_triggers_only_on_configured_weekday_and_independently_of_daily() {
|
||||
// 2026-11-15 is Sunday; 2026-11-16 is Monday.
|
||||
let s = RestartSchedule {
|
||||
enabled: false,
|
||||
weekly_enabled: true,
|
||||
weekly_day: Weekday::Sunday,
|
||||
weekly_time: "04:00".into(),
|
||||
weekly_warning_minutes: 15,
|
||||
..RestartSchedule::default()
|
||||
};
|
||||
let started = at("2026-11-14 20:00");
|
||||
assert_eq!(s.due_restart(at("2026-11-15 03:59"), started), None);
|
||||
assert_eq!(
|
||||
s.due_restart(at("2026-11-15 04:05"), started),
|
||||
Some(DueRestart { moment: at("2026-11-15 04:00"), warning_minutes: 15 })
|
||||
);
|
||||
// Monday does not trigger Sunday's weekly restart.
|
||||
assert_eq!(s.due_restart(at("2026-11-16 04:05"), started), None);
|
||||
|
||||
// Both daily and weekly enabled: each triggers on its own schedule.
|
||||
let both = RestartSchedule { enabled: true, time: "05:00".into(), warning_minutes: 5, ..s };
|
||||
assert_eq!(
|
||||
both.due_restart(at("2026-11-15 04:05"), started),
|
||||
Some(DueRestart { moment: at("2026-11-15 04:00"), warning_minutes: 15 })
|
||||
);
|
||||
assert_eq!(
|
||||
both.due_restart(at("2026-11-15 05:02"), at("2026-11-15 04:16")),
|
||||
Some(DueRestart { moment: at("2026-11-15 05:00"), warning_minutes: 5 })
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn schedules_are_validated_and_extra_worlds_follow_their_server() {
|
||||
let d = tempfile::tempdir().unwrap();
|
||||
assert_eq!(load(d.path()), RestartSchedule::default());
|
||||
let bad = RestartSchedule { enabled: true, time: "25:00".into(), warning_minutes: 5 };
|
||||
let bad = RestartSchedule { enabled: true, time: "25:00".into(), warning_minutes: 5, ..RestartSchedule::default() };
|
||||
assert!(save(d.path(), &bad).is_err());
|
||||
let quiet = RestartSchedule { enabled: true, time: "05:00".into(), warning_minutes: 0 };
|
||||
let quiet = RestartSchedule { enabled: true, time: "05:00".into(), warning_minutes: 0, ..RestartSchedule::default() };
|
||||
assert!(save(d.path(), &quiet).is_err());
|
||||
let good = RestartSchedule { enabled: true, time: " 04:30 ".into(), warning_minutes: 10 };
|
||||
assert_eq!(save(d.path(), &good).unwrap().time, "04:30");
|
||||
let bad_weekly = RestartSchedule {
|
||||
weekly_enabled: true,
|
||||
weekly_time: "99:00".into(),
|
||||
..RestartSchedule::default()
|
||||
};
|
||||
assert!(save(d.path(), &bad_weekly).is_err());
|
||||
let quiet_weekly = RestartSchedule {
|
||||
weekly_enabled: true,
|
||||
weekly_warning_minutes: 61,
|
||||
..RestartSchedule::default()
|
||||
};
|
||||
assert!(save(d.path(), &quiet_weekly).is_err());
|
||||
let good = RestartSchedule {
|
||||
enabled: true,
|
||||
time: " 04:30 ".into(),
|
||||
warning_minutes: 10,
|
||||
weekly_enabled: true,
|
||||
weekly_day: Weekday::Wednesday,
|
||||
weekly_time: " 03:15 ".into(),
|
||||
weekly_warning_minutes: 20,
|
||||
};
|
||||
let saved = save(d.path(), &good).unwrap();
|
||||
assert_eq!(saved.time, "04:30");
|
||||
assert_eq!(saved.weekly_time, "03:15");
|
||||
assert_eq!(saved.weekly_day, Weekday::Wednesday);
|
||||
let extra = d.path().join(".realms/secondary");
|
||||
std::fs::create_dir_all(&extra).unwrap();
|
||||
assert!(load(&extra).enabled);
|
||||
assert!(load(&extra).weekly_enabled);
|
||||
|
||||
// Legacy schedule JSON without weekly fields loads cleanly with defaults.
|
||||
std::fs::write(
|
||||
d.path().join(FILE),
|
||||
r#"{"enabled":true,"time":"06:00","warningMinutes":10}"#,
|
||||
)
|
||||
.unwrap();
|
||||
let legacy = load(d.path());
|
||||
assert!(legacy.enabled);
|
||||
assert_eq!(legacy.time, "06:00");
|
||||
assert!(!legacy.weekly_enabled);
|
||||
assert_eq!(legacy.weekly_day, Weekday::Sunday);
|
||||
|
||||
assert!(!under_way(d.path()));
|
||||
mark_under_way(d.path()).unwrap();
|
||||
assert!(under_way(d.path()));
|
||||
|
||||
@@ -174,7 +174,13 @@ fn spawn_relay(root: &Path, launcher: Option<&Path>) -> Result<Proc> {
|
||||
pub fn watch_world(root: &Path, launcher: Option<&Path>, offset: i32, log: Progress) -> Result<()> {
|
||||
squid::validate_bots(root)?;
|
||||
let mut relay: Option<Proc> = None;
|
||||
let mut last_log_clean = Instant::now();
|
||||
loop {
|
||||
if let Some(report) = crate::server_logging::auto_clean_if_needed(root) {
|
||||
if report.freed_bytes > 0 {
|
||||
log(&format!("Auto-cleaned server logs ({} MB freed).", report.freed_bytes / (1024 * 1024)));
|
||||
}
|
||||
}
|
||||
let world = spawn_child(root, "world", &root.join("Core/worldserver.exe"), &["-c", "configs/worldserver.conf"], &root.join("Core"), &root.join("Core/Logs/world-console.log"))?;
|
||||
let started = schedule::now();
|
||||
let mut requested = false;
|
||||
@@ -204,8 +210,8 @@ pub fn watch_world(root: &Path, launcher: Option<&Path>, offset: i32, log: Progr
|
||||
}
|
||||
if !requested {
|
||||
let plan = schedule::load(root);
|
||||
if plan.due(schedule::now(), started).is_some() {
|
||||
let seconds = plan.warning_minutes * 60;
|
||||
if let Some(due) = plan.due_restart(schedule::now(), started) {
|
||||
let seconds = due.warning_minutes * 60;
|
||||
let asked = Settings::load(root, offset).and_then(|cfg| {
|
||||
crate::ra::Ra::connect_to(cfg.ra_port, &cfg.ra_username, &cfg.ra_password)
|
||||
.and_then(|mut ra| ra.run(&format!("server restart {seconds}")))
|
||||
@@ -214,12 +220,20 @@ pub fn watch_world(root: &Path, launcher: Option<&Path>, offset: i32, log: Progr
|
||||
Ok(_) => {
|
||||
schedule::mark_under_way(root)?;
|
||||
requested = true;
|
||||
log(&format!("Scheduled restart: the world restarts in {} minutes.", plan.warning_minutes));
|
||||
log(&format!("Scheduled restart: the world restarts in {} minutes.", due.warning_minutes));
|
||||
}
|
||||
Err(e) => log(&format!("Scheduled restart could not be requested ({e}); retrying.")),
|
||||
}
|
||||
}
|
||||
}
|
||||
if last_log_clean.elapsed() >= Duration::from_secs(300) {
|
||||
last_log_clean = Instant::now();
|
||||
if let Some(report) = crate::server_logging::auto_clean_if_needed(root) {
|
||||
if report.freed_bytes > 0 {
|
||||
log(&format!("Auto-cleaned server logs ({} MB freed).", report.freed_bytes / (1024 * 1024)));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
std::thread::sleep(Duration::from_secs(2));
|
||||
};
|
||||
|
||||
@@ -1,4 +1,9 @@
|
||||
use std::{fs, path::Path};
|
||||
use std::{
|
||||
fs,
|
||||
path::{Path, PathBuf},
|
||||
};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::{
|
||||
config::{parser::ConfFile, Scope},
|
||||
@@ -6,6 +11,213 @@ use crate::{
|
||||
fsx,
|
||||
};
|
||||
|
||||
const SETTINGS_FILE: &str = "Settings/log-settings.json";
|
||||
const DEFAULT_MAX_SIZE_MB: u64 = 500;
|
||||
const MIN_MAX_SIZE_MB: u64 = 10;
|
||||
const MAX_MAX_SIZE_MB: u64 = 100_000;
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase", default)]
|
||||
pub struct LogSettings {
|
||||
pub auto_cleanup: bool,
|
||||
pub max_size_mb: u64,
|
||||
}
|
||||
|
||||
impl Default for LogSettings {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
auto_cleanup: false,
|
||||
max_size_mb: DEFAULT_MAX_SIZE_MB,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct CleanLogsReport {
|
||||
pub freed_bytes: u64,
|
||||
pub remaining_bytes: u64,
|
||||
pub deleted_files: u64,
|
||||
pub skipped_files: u64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ServerLoggingView {
|
||||
pub preset: Option<String>,
|
||||
pub log_bytes: u64,
|
||||
pub settings: LogSettings,
|
||||
}
|
||||
|
||||
fn owner(root: &Path) -> PathBuf {
|
||||
if crate::launcher::settings::is_extra_world(root) {
|
||||
if let Some(main) = root.parent().and_then(Path::parent) {
|
||||
return main.to_path_buf();
|
||||
}
|
||||
}
|
||||
root.to_path_buf()
|
||||
}
|
||||
|
||||
pub fn load_settings(root: &Path) -> LogSettings {
|
||||
let mut settings: LogSettings =
|
||||
fsx::read_json(&owner(root).join(SETTINGS_FILE)).unwrap_or_default();
|
||||
if settings.max_size_mb < MIN_MAX_SIZE_MB || settings.max_size_mb > MAX_MAX_SIZE_MB {
|
||||
settings.max_size_mb = DEFAULT_MAX_SIZE_MB;
|
||||
}
|
||||
settings
|
||||
}
|
||||
|
||||
pub fn save_settings(root: &Path, settings: &LogSettings) -> Result<LogSettings> {
|
||||
let mut settings = settings.clone();
|
||||
if settings.auto_cleanup {
|
||||
if !(MIN_MAX_SIZE_MB..=MAX_MAX_SIZE_MB).contains(&settings.max_size_mb) {
|
||||
return Err(Error::Invalid(format!(
|
||||
"Log auto-cleanup threshold must be between {MIN_MAX_SIZE_MB} and {MAX_MAX_SIZE_MB} MB."
|
||||
)));
|
||||
}
|
||||
} else if !(MIN_MAX_SIZE_MB..=MAX_MAX_SIZE_MB).contains(&settings.max_size_mb) {
|
||||
settings.max_size_mb = DEFAULT_MAX_SIZE_MB;
|
||||
}
|
||||
fsx::atomic_write_json(&owner(root).join(SETTINGS_FILE), &settings)?;
|
||||
Ok(settings)
|
||||
}
|
||||
|
||||
pub fn detect_preset(root: &Path) -> Option<String> {
|
||||
let candidates = [
|
||||
root.join("Core/configs/worldserver.conf"),
|
||||
root.join("Settings/worldserver.conf.template"),
|
||||
];
|
||||
for path in candidates {
|
||||
let Ok(bytes) = fs::read(&path) else {
|
||||
continue;
|
||||
};
|
||||
let Ok(conf) = ConfFile::parse_bytes(&bytes) else {
|
||||
continue;
|
||||
};
|
||||
let found = conf
|
||||
.entries()
|
||||
.find(|(k, _)| *k == "Logger.root")
|
||||
.and_then(|(_, value)| {
|
||||
value
|
||||
.split(',')
|
||||
.next()
|
||||
.map(str::trim)
|
||||
.and_then(|s| s.parse::<u32>().ok())
|
||||
});
|
||||
if let Some(level) = found {
|
||||
return match level {
|
||||
0 => Some("off".into()),
|
||||
2 => Some("errors".into()),
|
||||
4 => Some("normal".into()),
|
||||
_ => None,
|
||||
};
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn log_dirs(root: &Path) -> Vec<PathBuf> {
|
||||
let base = owner(root);
|
||||
let mut dirs = Vec::new();
|
||||
for prefix in ["", ".realms/secondary/", ".realms/reborn/"] {
|
||||
let candidate = base.join(format!("{prefix}Core/Logs"));
|
||||
if let Ok(checked) = fsx::ensure_within(&base, &candidate) {
|
||||
if checked.is_dir() {
|
||||
dirs.push(checked);
|
||||
}
|
||||
}
|
||||
}
|
||||
dirs
|
||||
}
|
||||
|
||||
fn measure_dir(dir: &Path) -> u64 {
|
||||
let Ok(entries) = fs::read_dir(dir) else {
|
||||
return 0;
|
||||
};
|
||||
let mut total = 0u64;
|
||||
for entry in entries.flatten() {
|
||||
let path = entry.path();
|
||||
let Ok(meta) = entry.metadata() else {
|
||||
continue;
|
||||
};
|
||||
if meta.is_dir() {
|
||||
total = total.saturating_add(measure_dir(&path));
|
||||
} else if meta.is_file() {
|
||||
total = total.saturating_add(meta.len());
|
||||
}
|
||||
}
|
||||
total
|
||||
}
|
||||
|
||||
pub fn measure_logs(root: &Path) -> u64 {
|
||||
log_dirs(root)
|
||||
.into_iter()
|
||||
.fold(0u64, |acc, dir| acc.saturating_add(measure_dir(&dir)))
|
||||
}
|
||||
|
||||
fn clean_dir(dir: &Path, report: &mut CleanLogsReport, remove_empty_dir: bool) {
|
||||
let Ok(entries) = fs::read_dir(dir) else {
|
||||
return;
|
||||
};
|
||||
for entry in entries.flatten() {
|
||||
let path = entry.path();
|
||||
let Ok(meta) = entry.metadata() else {
|
||||
continue;
|
||||
};
|
||||
if meta.is_dir() {
|
||||
clean_dir(&path, report, true);
|
||||
} else if meta.is_file() {
|
||||
let size = meta.len();
|
||||
match fs::remove_file(&path) {
|
||||
Ok(()) => {
|
||||
report.freed_bytes = report.freed_bytes.saturating_add(size);
|
||||
report.deleted_files = report.deleted_files.saturating_add(1);
|
||||
}
|
||||
Err(_) => {
|
||||
report.remaining_bytes = report.remaining_bytes.saturating_add(size);
|
||||
report.skipped_files = report.skipped_files.saturating_add(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if remove_empty_dir {
|
||||
let _ = fs::remove_dir(dir);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn clean_logs(root: &Path) -> Result<CleanLogsReport> {
|
||||
let mut report = CleanLogsReport {
|
||||
freed_bytes: 0,
|
||||
remaining_bytes: 0,
|
||||
deleted_files: 0,
|
||||
skipped_files: 0,
|
||||
};
|
||||
for dir in log_dirs(root) {
|
||||
clean_dir(&dir, &mut report, false);
|
||||
}
|
||||
Ok(report)
|
||||
}
|
||||
|
||||
pub fn auto_clean_if_needed(root: &Path) -> Option<CleanLogsReport> {
|
||||
let settings = load_settings(root);
|
||||
if !settings.auto_cleanup {
|
||||
return None;
|
||||
}
|
||||
let limit = settings.max_size_mb.saturating_mul(1024 * 1024);
|
||||
if measure_logs(root) <= limit {
|
||||
return None;
|
||||
}
|
||||
clean_logs(root).ok()
|
||||
}
|
||||
|
||||
pub fn state(root: &Path) -> ServerLoggingView {
|
||||
ServerLoggingView {
|
||||
preset: detect_preset(root),
|
||||
log_bytes: measure_logs(root),
|
||||
settings: load_settings(root),
|
||||
}
|
||||
}
|
||||
|
||||
fn transform(bytes: &[u8], preset: &str) -> Result<String> {
|
||||
let level = match preset {
|
||||
"normal" => 4,
|
||||
@@ -162,4 +374,56 @@ mod tests {
|
||||
assert_eq!(transform(normal.as_bytes(), "normal").unwrap(), normal);
|
||||
assert!(transform(original, "unsupported").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn detects_preset_measures_and_cleans_logs_across_realms() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let root = temp.path();
|
||||
fs::create_dir_all(root.join("Core/configs")).unwrap();
|
||||
fs::write(root.join("Core/configs/worldserver.conf"), "Logger.root=4,Console Server\n").unwrap();
|
||||
assert_eq!(detect_preset(root).as_deref(), Some("normal"));
|
||||
fs::write(root.join("Core/configs/worldserver.conf"), "Logger.root=0,Console Server\n").unwrap();
|
||||
assert_eq!(detect_preset(root).as_deref(), Some("off"));
|
||||
fs::write(root.join("Core/configs/worldserver.conf"), "Logger.root=2,Console Server\n").unwrap();
|
||||
assert_eq!(detect_preset(root).as_deref(), Some("errors"));
|
||||
|
||||
fs::create_dir_all(root.join("Core/Logs/archive")).unwrap();
|
||||
fs::create_dir_all(root.join(".realms/secondary/Core/Logs")).unwrap();
|
||||
fs::write(root.join("Core/Logs/Server.log"), vec![b'a'; 1000]).unwrap();
|
||||
fs::write(root.join("Core/Logs/archive/old.log"), vec![b'b'; 500]).unwrap();
|
||||
fs::write(root.join(".realms/secondary/Core/Logs/Server.log"), vec![b'c'; 250]).unwrap();
|
||||
assert_eq!(measure_logs(root), 1750);
|
||||
|
||||
let report = clean_logs(root).unwrap();
|
||||
assert_eq!(report.freed_bytes, 1750);
|
||||
assert_eq!(report.remaining_bytes, 0);
|
||||
assert_eq!(report.deleted_files, 3);
|
||||
assert_eq!(report.skipped_files, 0);
|
||||
assert_eq!(measure_logs(root), 0);
|
||||
assert!(!root.join("Core/Logs/archive").exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn log_settings_validate_and_auto_clean_only_above_threshold() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let root = temp.path();
|
||||
assert_eq!(load_settings(root), LogSettings::default());
|
||||
assert!(save_settings(root, &LogSettings { auto_cleanup: true, max_size_mb: 5 }).is_err());
|
||||
let saved = save_settings(root, &LogSettings { auto_cleanup: true, max_size_mb: 10 }).unwrap();
|
||||
assert!(saved.auto_cleanup);
|
||||
assert_eq!(saved.max_size_mb, 10);
|
||||
|
||||
fs::create_dir_all(root.join("Core/Logs")).unwrap();
|
||||
fs::write(root.join("Core/Logs/Server.log"), vec![b'x'; 1024]).unwrap();
|
||||
// 1 KB < 10 MB: does not clean.
|
||||
assert!(auto_clean_if_needed(root).is_none());
|
||||
assert_eq!(measure_logs(root), 1024);
|
||||
|
||||
// Threshold check helper: writing > 10 MB triggers cleanup.
|
||||
let over = vec![b'y'; 10 * 1024 * 1024 + 1];
|
||||
fs::write(root.join("Core/Logs/Big.log"), over).unwrap();
|
||||
let cleaned = auto_clean_if_needed(root).unwrap();
|
||||
assert!(cleaned.freed_bytes > 10 * 1024 * 1024);
|
||||
assert_eq!(measure_logs(root), 0);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user