diff --git a/changelog.d/20261120-server-log-auto-cleanup.md b/changelog.d/20261120-server-log-auto-cleanup.md new file mode 100644 index 0000000..7d60a84 --- /dev/null +++ b/changelog.d/20261120-server-log-auto-cleanup.md @@ -0,0 +1,7 @@ +--- +area: manager +type: added +audience: admins +title: Clean server logs by hand or automatically when they grow too big +--- +Server logging settings show how much the logs take and clean them with one button. Optionally the Manager cleans them above a size you choose; logs the running server uses are kept. diff --git a/changelog.d/20261120-weekly-world-restart.md b/changelog.d/20261120-weekly-world-restart.md new file mode 100644 index 0000000..3a3a82d --- /dev/null +++ b/changelog.d/20261120-weekly-world-restart.md @@ -0,0 +1,7 @@ +--- +area: manager +type: added +audience: admins +title: Restart the world every week on a chosen day and time +--- +Next to the daily restart, pick a weekday, a time and the in-game countdown in the scheduled restart settings. Existing daily schedules keep working. diff --git a/crates/coa-core/src/launcher/schedule.rs b/crates/coa-core/src/launcher/schedule.rs index 97eb9d6..ebb115c 100644 --- a/crates/coa-core/src/launcher/schedule.rs +++ b/crates/coa-core/src/launcher/schedule.rs @@ -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::parse_from_str(self.time.trim(), "%H:%M").ok() + fn parse_time(text: &str) -> Option { + 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 { - 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 { + 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 { + 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 { + self.due_restart(now, started).map(|d| d.moment) + } } /// The folder whose schedule a world follows: an extra world (`/.realms/`) follows its server's. @@ -84,11 +160,14 @@ pub fn load(root: &Path) -> RestartSchedule { pub fn save(root: &Path, schedule: &RestartSchedule) -> Result { 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())); diff --git a/crates/coa-core/src/launcher/world.rs b/crates/coa-core/src/launcher/world.rs index 12206d5..74286a4 100644 --- a/crates/coa-core/src/launcher/world.rs +++ b/crates/coa-core/src/launcher/world.rs @@ -174,7 +174,13 @@ fn spawn_relay(root: &Path, launcher: Option<&Path>) -> Result { pub fn watch_world(root: &Path, launcher: Option<&Path>, offset: i32, log: Progress) -> Result<()> { squid::validate_bots(root)?; let mut relay: Option = 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)); }; diff --git a/crates/coa-core/src/server_logging.rs b/crates/coa-core/src/server_logging.rs index b7e8ddc..6801e02 100644 --- a/crates/coa-core/src/server_logging.rs +++ b/crates/coa-core/src/server_logging.rs @@ -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, + 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 { + 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 { + 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::().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 { + 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 { + 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 { + 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 { 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); + } } diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index 542977b..b5ec4ff 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -814,6 +814,15 @@ async fn get_settings( blocking(move || config::load(&root, scope)).await } +#[tauri::command] +async fn server_logging_state( + state: State<'_, AppState>, + id: String, +) -> std::result::Result { + let root = path_of(&state, &id)?; + blocking(move || Ok(coa_core::server_logging::state(&root))).await +} + #[tauri::command] async fn server_logging_preset( state: State<'_, AppState>, @@ -828,6 +837,30 @@ async fn server_logging_preset( }).await } +#[tauri::command] +async fn server_logging_settings_save( + state: State<'_, AppState>, + id: String, + settings: coa_core::server_logging::LogSettings, +) -> std::result::Result { + let root = path_of(&state, &id)?; + let _guard = BusyGuard::acquire(&state, &id)?; + blocking(move || { + coa_core::server_logging::save_settings(&root, &settings)?; + Ok(coa_core::server_logging::state(&root)) + }).await +} + +#[tauri::command] +async fn server_logs_clean( + state: State<'_, AppState>, + id: String, +) -> std::result::Result { + let root = path_of(&state, &id)?; + let _guard = BusyGuard::acquire(&state, &id)?; + blocking(move || coa_core::server_logging::clean_logs(&root)).await +} + #[tauri::command] async fn save_settings( state: State<'_, AppState>, @@ -3118,7 +3151,10 @@ pub fn run() { .plugin(tauri_plugin_updater::Builder::new().build()) .plugin(tauri_plugin_process::init()) .invoke_handler(tauri::generate_handler![ + server_logging_state, server_logging_preset, + server_logging_settings_save, + server_logs_clean, release_history, default_install_dir, game_data_folder, diff --git a/src/dev/mock.ts b/src/dev/mock.ts index e5ffbd1..a336916 100644 --- a/src/dev/mock.ts +++ b/src/dev/mock.ts @@ -45,7 +45,8 @@ export {}; if(cmd==="addons_list"||cmd==="addons_install"||cmd==="addons_remove"){const w=window as any;w.__addons=w.__addons??{dragonui:"old"};if(cmd==="addons_install"){await new Promise(r=>setTimeout(r,700));w.__addons[args.addon]="new";}if(cmd==="addons_remove")delete w.__addons[args.addon];return addonCatalog.addons.map((a:any)=>({id:a.id,name:a.name,description:a.description,author:a.author,license:a.license,needs:a.needs??null,repo:a.repo,size:a.files.reduce((s:number,f:any)=>s+f.size,0),installed:a.id in w.__addons,updateAvailable:w.__addons[a.id]==="old",foreignFolders:a.id==="coacombat"&&!(a.id in w.__addons)?["CoACombat"]:[],bundled:null as string|null})).concat([{id:"coa-dev-menu",name:"CoA Dev Menu",description:{en:"The in-game /dev editor for game masters.",ru:"Внутриигровой редактор /dev для гейм-мастеров. Ставится вместе с клиентским патчем Custom Races V2 и включается вместе с ним."},author:"ilusixn",license:"see repository",needs:null,repo:"https://github.com/ilusixn/ilusixn-dev-menu",size:0,installed:true,updateAvailable:false,foreignFolders:[],bundled:"custom-races"}]);} if(cmd==="custom_race_characters") return {players:2,companionBots:14,squidBots:0}; if(cmd==="purge_custom_race_bots"){await new Promise(r=>setTimeout(r,500));return 14;} - if(cmd==="restart_schedule"||cmd==="restart_schedule_save"){const w=window as any;w.__sched=w.__sched??{enabled:false,time:"05:00",warningMinutes:5};if(cmd==="restart_schedule_save"){const s=args.schedule;if(s.enabled&&!/^([01]\d|2[0-3]):[0-5]\d$/.test(s.time))throw new Error("The restart time must be HH:MM, for example 05:00.");w.__sched={...s};}return {schedule:w.__sched,supported:true};} + if(cmd==="restart_schedule"||cmd==="restart_schedule_save"){const w=window as any;w.__sched=w.__sched??{enabled:false,time:"05:00",warningMinutes:5,weeklyEnabled:false,weeklyDay:"sunday",weeklyTime:"05:00",weeklyWarningMinutes:5};if(cmd==="restart_schedule_save"){const s=args.schedule;if(s.enabled&&!/^([01]\d|2[0-3]):[0-5]\d$/.test(s.time))throw new Error("The restart time must be HH:MM, for example 05:00.");if(s.weeklyEnabled&&!/^([01]\d|2[0-3]):[0-5]\d$/.test(s.weeklyTime))throw new Error("The restart time must be HH:MM, for example 05:00.");w.__sched={...s};}return {schedule:w.__sched,supported:true};} + if(cmd==="server_logging_state"||cmd==="server_logging_preset"||cmd==="server_logging_settings_save"||cmd==="server_logs_clean"){const w=window as any;w.__logs=w.__logs??{preset:"normal",logBytes:148*1024*1024,settings:{autoCleanup:false,maxSizeMb:500}};if(cmd==="server_logging_preset"){w.__logs.preset=args.preset;return;}if(cmd==="server_logging_settings_save"){w.__logs.settings={...args.settings};}if(cmd==="server_logs_clean"){const freed=w.__logs.logBytes;w.__logs.logBytes=0;return {freedBytes:freed,remainingBytes:0,deletedFiles:freed>0?3:0,skippedFiles:0};}return w.__logs;} if(cmd==="mysql_custom"||cmd==="mysql_custom_save"){const w=window as any;if(cmd==="mysql_custom_save")w.__my=args.text;const text:string=w.__my??"";const applied=text.split("\n").map((l:string)=>l.trim()).filter((l:string)=>l&&!l.startsWith("#")&&!/^(port|datadir|basedir|bind[-_]address)\b/i.test(l)).map((l:string)=>l+"\n").join("");return {text,applied};} if(cmd==="realm_names"||cmd==="realm_rename"){const w=window as any;w.__rn=w.__rn??{};const defs:[number,string][]=[[1,"Conquest of Azeroth"],[2,"Wildcard"]];if(cmd==="realm_rename"){await new Promise(r=>setTimeout(r,300));const n=(args.name??"").trim();if(n.length>32||n.includes('"'))throw new Error("The realm name can have at most 32 characters.");if(n)w.__rn[args.realmId]=n;else delete w.__rn[args.realmId];}return defs.map(([id,d])=>({id,name:w.__rn[id]??d,defaultName:d,custom:id in w.__rn}));} if(cmd==="realm_profiles") return {active:realm,wildcard_created:wildcardCreated,reborn_created:rebornCreated,reborn_supported:true,supported:true,recovery_pending:false,simultaneous,secondary_world_port:simultaneous?8086:null,secondary_running:simultaneous&&running,with_reborn:withReborn,reborn_world_port:withReborn?8087:null,reborn_running:withReborn&&running}; diff --git a/src/i18n/locales/de.ts b/src/i18n/locales/de.ts index 095a55e..68fdddf 100644 --- a/src/i18n/locales/de.ts +++ b/src/i18n/locales/de.ts @@ -757,6 +757,15 @@ const de: Partial> = { "mysql.applied": "Angewandte Optionen: {count}", "sched.title": "Geplanter Neustart", "sched.enable": "Die Welt jeden Tag neu starten", + "sched.weeklyEnable": "Die Welt jede Woche neu starten", + "sched.day": "Tag", + "sched.days.monday": "Montag", + "sched.days.tuesday": "Dienstag", + "sched.days.wednesday": "Mittwoch", + "sched.days.thursday": "Donnerstag", + "sched.days.friday": "Freitag", + "sched.days.saturday": "Samstag", + "sched.days.sunday": "Sonntag", "sched.time": "Uhrzeit", "sched.warning": "Vorwarnung (Minuten)", "sched.hint": "Die Welt startet zu dieser Uhrzeit dieses Computers neu, mit einem Countdown im Spielchat; die Datenbank läuft weiter, Spieler melden sich danach wieder an. Ein laufender Server übernimmt die neue Zeit innerhalb einer Minute.", @@ -1101,6 +1110,13 @@ const de: Partial> = { "serverLogs.errors": "Nur Fehler", "serverLogs.off": "Aus", "serverLogs.saved": "Gespeichert. Zum Anwenden den Server neu starten.", + "serverLogs.autoClean": "Serverlogs nach Größe automatisch bereinigen", + "serverLogs.maxSize": "Max. Größe", + "serverLogs.autoCleanHint": "Löscht alte Logdateien, wenn Core/Logs diese Größe überschreitet (geprüft beim Start der Welt und regelmäßig während des Betriebs).", + "serverLogs.currentSize": "Aktuelle Loggröße: {size}", + "serverLogs.cleanNow": "Logs bereinigen ({size})", + "serverLogs.cleaned": "{freed} an Logs bereinigt.", + "serverLogs.skippedInUse": "{remaining} werden vom laufenden Server verwendet und konnten nicht entfernt werden.", "mod.requiresSquid": "Aktivieren Sie SQUID-Bots, um Dungeon Clear zu verwenden.", }; diff --git a/src/i18n/locales/en.ts b/src/i18n/locales/en.ts index 926bb00..24ec37b 100644 --- a/src/i18n/locales/en.ts +++ b/src/i18n/locales/en.ts @@ -64,6 +64,15 @@ const en = { "mysql.applied": "Options applied: {count}", "sched.title": "Scheduled restart", "sched.enable": "Restart the world every day", + "sched.weeklyEnable": "Restart the world every week", + "sched.day": "Day", + "sched.days.monday": "Monday", + "sched.days.tuesday": "Tuesday", + "sched.days.wednesday": "Wednesday", + "sched.days.thursday": "Thursday", + "sched.days.friday": "Friday", + "sched.days.saturday": "Saturday", + "sched.days.sunday": "Sunday", "sched.time": "Time", "sched.warning": "Warning (minutes)", "sched.hint": "The world restarts at this time of this computer with a countdown in the game chat; the database keeps running and players log in again after it. A minute after saving, the running server follows the new time.", @@ -1311,6 +1320,13 @@ const en = { "serverLogs.errors": "Errors only", "serverLogs.off": "Off", "serverLogs.saved": "Saved. Restart the server to apply.", + "serverLogs.autoClean": "Auto-clean server logs by size", + "serverLogs.maxSize": "Max size", + "serverLogs.autoCleanHint": "Clears old log files when Core/Logs exceeds this size (checked on world start and periodically while running).", + "serverLogs.currentSize": "Current log size: {size}", + "serverLogs.cleanNow": "Clean logs ({size})", + "serverLogs.cleaned": "Cleaned {freed} of logs.", + "serverLogs.skippedInUse": "{remaining} in use by the running server could not be removed.", "mod.requiresSquid": "Enable SQUID bots to use Dungeon Clear.", } as const; diff --git a/src/i18n/locales/es.ts b/src/i18n/locales/es.ts index af948ff..5dbecf9 100644 --- a/src/i18n/locales/es.ts +++ b/src/i18n/locales/es.ts @@ -757,6 +757,15 @@ const es: Partial> = { "mysql.applied": "Opciones aplicadas: {count}", "sched.title": "Reinicio programado", "sched.enable": "Reiniciar el mundo cada día", + "sched.weeklyEnable": "Reiniciar el mundo cada semana", + "sched.day": "Día", + "sched.days.monday": "Lunes", + "sched.days.tuesday": "Martes", + "sched.days.wednesday": "Miércoles", + "sched.days.thursday": "Jueves", + "sched.days.friday": "Viernes", + "sched.days.saturday": "Sábado", + "sched.days.sunday": "Domingo", "sched.time": "Hora", "sched.warning": "Aviso (minutos)", "sched.hint": "El mundo se reinicia a esta hora de este ordenador con una cuenta atrás en el chat del juego; la base de datos sigue en marcha y los jugadores vuelven a entrar después. Un servidor en marcha sigue la nueva hora en menos de un minuto.", @@ -1101,6 +1110,13 @@ const es: Partial> = { "serverLogs.errors": "Solo errores", "serverLogs.off": "Desactivados", "serverLogs.saved": "Guardado. Reinicia el servidor para aplicar los cambios.", + "serverLogs.autoClean": "Limpiar automáticamente los registros del servidor por tamaño", + "serverLogs.maxSize": "Tamaño máx.", + "serverLogs.autoCleanHint": "Borra los archivos de registro antiguos cuando Core/Logs supera este tamaño (se comprueba al iniciar el mundo y periódicamente mientras funciona).", + "serverLogs.currentSize": "Tamaño actual de los registros: {size}", + "serverLogs.cleanNow": "Limpiar registros ({size})", + "serverLogs.cleaned": "Se limpiaron {freed} de registros.", + "serverLogs.skippedInUse": "{remaining} están en uso por el servidor en marcha y no se pudieron eliminar.", "mod.requiresSquid": "Activa los bots SQUID para usar Dungeon Clear.", }; diff --git a/src/i18n/locales/fr.ts b/src/i18n/locales/fr.ts index 0c694d2..078b1a8 100644 --- a/src/i18n/locales/fr.ts +++ b/src/i18n/locales/fr.ts @@ -757,6 +757,15 @@ const fr: Partial> = { "mysql.applied": "Options appliquées : {count}", "sched.title": "Redémarrage planifié", "sched.enable": "Redémarrer le monde chaque jour", + "sched.weeklyEnable": "Redémarrer le monde chaque semaine", + "sched.day": "Jour", + "sched.days.monday": "Lundi", + "sched.days.tuesday": "Mardi", + "sched.days.wednesday": "Mercredi", + "sched.days.thursday": "Jeudi", + "sched.days.friday": "Vendredi", + "sched.days.saturday": "Samedi", + "sched.days.sunday": "Dimanche", "sched.time": "Heure", "sched.warning": "Avertissement (minutes)", "sched.hint": "Le monde redémarre à cette heure de cet ordinateur avec un compte à rebours dans le chat du jeu ; la base de données continue de tourner et les joueurs se reconnectent ensuite. Un serveur en marche suit la nouvelle heure en moins d'une minute.", @@ -1101,6 +1110,13 @@ const fr: Partial> = { "serverLogs.errors": "Erreurs uniquement", "serverLogs.off": "Désactivés", "serverLogs.saved": "Enregistré. Redémarrez le serveur pour appliquer.", + "serverLogs.autoClean": "Nettoyer automatiquement les journaux du serveur selon leur taille", + "serverLogs.maxSize": "Taille max.", + "serverLogs.autoCleanHint": "Supprime les anciens fichiers journaux quand Core/Logs dépasse cette taille (vérifié au démarrage du monde et périodiquement pendant son fonctionnement).", + "serverLogs.currentSize": "Taille actuelle des journaux : {size}", + "serverLogs.cleanNow": "Nettoyer les journaux ({size})", + "serverLogs.cleaned": "{freed} de journaux nettoyés.", + "serverLogs.skippedInUse": "{remaining} sont utilisés par le serveur en cours et n’ont pas pu être supprimés.", "mod.requiresSquid": "Activez les bots SQUID pour utiliser Dungeon Clear.", }; diff --git a/src/i18n/locales/ru.ts b/src/i18n/locales/ru.ts index 226e323..a30787f 100644 --- a/src/i18n/locales/ru.ts +++ b/src/i18n/locales/ru.ts @@ -67,6 +67,15 @@ const ru: Partial> = { "mysql.applied": "Применяется параметров: {count}", "sched.title": "Перезапуск по расписанию", "sched.enable": "Перезапускать мир каждый день", + "sched.weeklyEnable": "Перезапускать мир каждую неделю", + "sched.day": "День", + "sched.days.monday": "Понедельник", + "sched.days.tuesday": "Вторник", + "sched.days.wednesday": "Среда", + "sched.days.thursday": "Четверг", + "sched.days.friday": "Пятница", + "sched.days.saturday": "Суббота", + "sched.days.sunday": "Воскресенье", "sched.time": "Время", "sched.warning": "Предупреждение (минуты)", "sched.hint": "Мир перезапускается в это время этого компьютера, с обратным отсчётом в игровом чате; база данных продолжает работать, игроки заходят снова после перезапуска. Работающий сервер подхватывает новое время в течение минуты.", @@ -1294,6 +1303,13 @@ const ru: Partial> = { "serverLogs.errors": "Только ошибки", "serverLogs.off": "Выключены", "serverLogs.saved": "Сохранено. Перезапустите сервер для применения.", + "serverLogs.autoClean": "Автоочистка логов сервера по размеру", + "serverLogs.maxSize": "Макс. размер", + "serverLogs.autoCleanHint": "Очищает старые файлы логов при превышении порога в Core/Logs (проверяется при запуске мира и периодически во время работы).", + "serverLogs.currentSize": "Текущий размер логов: {size}", + "serverLogs.cleanNow": "Очистить логи ({size})", + "serverLogs.cleaned": "Очищено логов: {freed}.", + "serverLogs.skippedInUse": "{remaining} заняты работающим сервером и не были удалены.", "mod.requiresSquid": "Для Dungeon Clear сначала включите SQUID bots.", }; diff --git a/src/i18n/locales/zh.ts b/src/i18n/locales/zh.ts index a88e36b..f8eb409 100644 --- a/src/i18n/locales/zh.ts +++ b/src/i18n/locales/zh.ts @@ -65,6 +65,15 @@ const zh = { "mysql.applied": "生效的选项:{count}", "sched.title": "定时重启", "sched.enable": "每天重启世界", + "sched.weeklyEnable": "每周重启世界", + "sched.day": "星期", + "sched.days.monday": "星期一", + "sched.days.tuesday": "星期二", + "sched.days.wednesday": "星期三", + "sched.days.thursday": "星期四", + "sched.days.friday": "星期五", + "sched.days.saturday": "星期六", + "sched.days.sunday": "星期日", "sched.time": "时间", "sched.warning": "提前警告(分钟)", "sched.hint": "世界会在本机的这个时间重启,并在游戏聊天中倒计时;数据库保持运行,玩家在重启后重新登录。正在运行的服务器会在一分钟内采用新时间。", @@ -1103,6 +1112,13 @@ const zh = { "serverLogs.errors": "仅错误", "serverLogs.off": "关闭", "serverLogs.saved": "已保存。重启服务器后生效。", + "serverLogs.autoClean": "按大小自动清理服务器日志", + "serverLogs.maxSize": "最大大小", + "serverLogs.autoCleanHint": "当 Core/Logs 超过此大小时清理旧日志文件(在世界启动时和运行期间定期检查)。", + "serverLogs.currentSize": "当前日志大小:{size}", + "serverLogs.cleanNow": "清理日志({size})", + "serverLogs.cleaned": "已清理 {freed} 日志。", + "serverLogs.skippedInUse": "{remaining} 正被运行中的服务器占用,无法删除。", "mod.requiresSquid": "请先启用 SQUID 机器人,再使用 Dungeon Clear。", } as const; diff --git a/src/lib/api.ts b/src/lib/api.ts index 9ffd28c..00b7725 100644 --- a/src/lib/api.ts +++ b/src/lib/api.ts @@ -60,8 +60,20 @@ export interface StatusView { export type RealmMode = "coa" | "wildcard" | "reborn"; export interface CustomRaceCharacters { players: number; companionBots: number; squidBots: number } export interface AddonView { id: string; name: string; description: Record; author: string; license: string; needs: string | null; repo: string; size: number; installed: boolean; updateAvailable: boolean; foreignFolders: string[]; bundled?: string | null } -export interface RestartSchedule { enabled: boolean; time: string; warningMinutes: number } +export type Weekday = "monday" | "tuesday" | "wednesday" | "thursday" | "friday" | "saturday" | "sunday"; +export interface RestartSchedule { + enabled: boolean; + time: string; + warningMinutes: number; + weeklyEnabled: boolean; + weeklyDay: Weekday; + weeklyTime: string; + weeklyWarningMinutes: number; +} export interface RestartScheduleView { schedule: RestartSchedule; supported: boolean } +export interface LogSettings { autoCleanup: boolean; maxSizeMb: number } +export interface CleanLogsReport { freedBytes: number; remainingBytes: number; deletedFiles: number; skippedFiles: number } +export interface ServerLoggingView { preset: "normal" | "errors" | "off" | null; logBytes: number; settings: LogSettings } export interface CustomMysql { text: string; applied: string } export interface RealmName { id: number; name: string; defaultName: string; custom: boolean } export interface RealmProfiles { active: RealmMode; wildcard_created: boolean; reborn_created: boolean; reborn_supported: boolean; supported: boolean; recovery_pending: boolean; simultaneous: boolean; secondary_world_port: number | null; secondary_running: boolean; with_reborn: boolean; reborn_world_port: number | null; reborn_running: boolean } @@ -502,7 +514,10 @@ export const api = { forceStop: (id: string) => invoke("force_stop_server", { id }), stop: (id: string) => invoke("stop_server", { id }), settings: (id: string, scope: Scope) => invoke("get_settings", { id, scope }), + serverLoggingState: (id: string) => invoke("server_logging_state", { id }), serverLoggingPreset: (id: string, preset: "normal" | "errors" | "off") => invoke("server_logging_preset", { id, preset }), + serverLoggingSettingsSave: (id: string, settings: LogSettings) => invoke("server_logging_settings_save", { id, settings }), + serverLogsClean: (id: string) => invoke("server_logs_clean", { id }), save: (id: string, scope: Scope, changes: Record) => invoke("save_settings", { id, scope, changes }), presets: (scope: Scope) => invoke("list_presets", { scope }), backups: (id: string) => invoke("list_backups", { id }), diff --git a/src/screens/RestartScheduleSettings.tsx b/src/screens/RestartScheduleSettings.tsx index 0734ffe..a2c755c 100644 --- a/src/screens/RestartScheduleSettings.tsx +++ b/src/screens/RestartScheduleSettings.tsx @@ -1,14 +1,25 @@ import { useEffect, useState } from "react"; -import { api, asUiError, type RestartSchedule } from "@/lib/api"; +import { api, asUiError, type RestartSchedule, type Weekday } from "@/lib/api"; import { Card } from "@/components/ui/card"; import { Button } from "@/components/ui/button"; import { useT } from "@/i18n"; -/** A daily world restart at a chosen local time, with an in-game countdown (#202). */ +const WEEKDAYS: Weekday[] = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]; +const DEFAULT_SCHEDULE: RestartSchedule = { + enabled: false, + time: "05:00", + warningMinutes: 5, + weeklyEnabled: false, + weeklyDay: "sunday", + weeklyTime: "05:00", + weeklyWarningMinutes: 5, +}; + +/** Daily and weekly world restarts at chosen local times, with an in-game countdown (#202). */ export function RestartScheduleSettings({ serverId }: { serverId: string }) { const t = useT(); const [saved, setSaved] = useState(null); - const [draft, setDraft] = useState({ enabled: false, time: "05:00", warningMinutes: 5 }); + const [draft, setDraft] = useState(DEFAULT_SCHEDULE); const [supported, setSupported] = useState(true); const [busy, setBusy] = useState(false); const [done, setDone] = useState(false); @@ -29,6 +40,8 @@ export function RestartScheduleSettings({ serverId }: { serverId: string }) { const changed = !!saved && JSON.stringify(saved) !== JSON.stringify(draft); const minutesOk = Number.isInteger(draft.warningMinutes) && draft.warningMinutes >= 1 && draft.warningMinutes <= 60; + const weeklyMinutesOk = Number.isInteger(draft.weeklyWarningMinutes) && draft.weeklyWarningMinutes >= 1 && draft.weeklyWarningMinutes <= 60; + const valid = (!draft.enabled || minutesOk) && (!draft.weeklyEnabled || weeklyMinutesOk); const input = "rounded border border-line bg-bg px-2 py-1 text-sm text-ink outline-none focus:border-gold"; return

{t("sched.title")}

@@ -46,10 +59,34 @@ export function RestartScheduleSettings({ serverId }: { serverId: string }) { { setDraft(d => ({ ...d, warningMinutes: Number(e.target.value) })); setDone(false); }} /> -

{t("sched.hint")}

+ +
+ +
+ + + +
+
+ +

{t("sched.hint")}

{!supported &&

{t("sched.unsupported")}

}
- + {done && {t("sched.saved")}}
{error &&

{error}

} diff --git a/src/screens/ServerLoggingSettings.tsx b/src/screens/ServerLoggingSettings.tsx index 00bfba2..812f8d9 100644 --- a/src/screens/ServerLoggingSettings.tsx +++ b/src/screens/ServerLoggingSettings.tsx @@ -1,26 +1,155 @@ -import { useState } from "react"; +import { useEffect, useState } from "react"; import { Card } from "@/components/ui/card"; -import { api, asUiError } from "@/lib/api"; +import { Button } from "@/components/ui/button"; +import { api, asUiError, type CleanLogsReport, type LogSettings, type ServerLoggingView } from "@/lib/api"; +import { formatBytes } from "@/lib/utils"; import { useT } from "@/i18n"; +const DEFAULT_LOG_SETTINGS: LogSettings = { autoCleanup: false, maxSizeMb: 500 }; + export function ServerLoggingSettings({ serverId }: { serverId: string }) { const t = useT(); + const [view, setView] = useState(null); + const [draft, setDraft] = useState(DEFAULT_LOG_SETTINGS); const [busy, setBusy] = useState(false); const [saved, setSaved] = useState(false); + const [autoSaved, setAutoSaved] = useState(false); + const [cleanReport, setCleanReport] = useState(null); const [error, setError] = useState(""); - async function apply(preset: "normal" | "errors" | "off") { - setBusy(true); setSaved(false); setError(""); - try { await api.serverLoggingPreset(serverId, preset); setSaved(true); } - catch (error) { setError(asUiError(error).technical); } - finally { setBusy(false); } + + useEffect(() => { + let alive = true; + void api.serverLoggingState(serverId) + .then(v => { + if (!alive) return; + setView(v); + setDraft(v.settings); + }) + .catch(err => { + if (alive) setError(asUiError(err).technical); + }); + return () => { alive = false; }; + }, [serverId]); + + async function refreshState() { + const v = await api.serverLoggingState(serverId); + setView(v); + setDraft(v.settings); } - return + + async function apply(preset: "normal" | "errors" | "off") { + setBusy(true); setSaved(false); setAutoSaved(false); setCleanReport(null); setError(""); + try { + await api.serverLoggingPreset(serverId, preset); + await refreshState(); + setSaved(true); + } catch (err) { + setError(asUiError(err).technical); + } finally { + setBusy(false); + } + } + + async function saveAutoCleanup() { + setBusy(true); setSaved(false); setAutoSaved(false); setCleanReport(null); setError(""); + try { + const v = await api.serverLoggingSettingsSave(serverId, draft); + setView(v); + setDraft(v.settings); + setAutoSaved(true); + } catch (err) { + setError(asUiError(err).technical); + } finally { + setBusy(false); + } + } + + async function cleanNow() { + setBusy(true); setSaved(false); setAutoSaved(false); setCleanReport(null); setError(""); + try { + const report = await api.serverLogsClean(serverId); + setCleanReport(report); + await refreshState(); + } catch (err) { + setError(asUiError(err).technical); + } finally { + setBusy(false); + } + } + + const changed = !!view && JSON.stringify(view.settings) !== JSON.stringify(draft); + const sizeOk = Number.isInteger(draft.maxSizeMb) && draft.maxSizeMb >= 10 && draft.maxSizeMb <= 100000; + const logBytes = view?.logBytes ?? 0; + const input = "rounded border border-line bg-bg px-2 py-1 text-sm text-ink outline-none focus:border-gold"; + + return

{t("serverLogs.title")}

{t("serverLogs.description")}

- {(["normal", "errors", "off"] as const).map(preset => )} + {(["normal", "errors", "off"] as const).map(preset => { + const active = view?.preset === preset; + return ; + })}
{saved &&

{t("serverLogs.saved")}

} + +
+ +
+ + + {autoSaved && {t("sched.saved")}} +
+

{t("serverLogs.autoCleanHint")}

+
+ +
+ + {t("serverLogs.currentSize", { size: formatBytes(logBytes) })} + + +
+ + {cleanReport && ( +

+ {t("serverLogs.cleaned", { freed: formatBytes(cleanReport.freedBytes) })} + {cleanReport.skippedFiles > 0 && ` ${t("serverLogs.skippedInUse", { remaining: formatBytes(cleanReport.remainingBytes) })}`} +

+ )} {error &&

{error}

}
; }