use knotra_vcs::model::{operation::OperationLog, workspace::Workspace};
use serde::{Deserialize, Serialize};
use crate::config::AppPaths;
pub(crate) fn treat_missing_directory_as_absent(dir: &std::path::Path) -> bool {
match std::fs::metadata(dir) {
Ok(meta) => meta.is_dir(),
Err(e) => e.kind() == std::io::ErrorKind::NotFound,
}
}
#[derive(Debug, Serialize, Deserialize)]
struct WorkspaceFile {
workspace: Workspace,
}
pub fn load_workspaces(paths: &AppPaths) -> (Vec<Workspace>, Vec<String>) {
let dir = &paths.workspaces_dir;
let mut workspaces = Vec::new();
let mut errors = Vec::new();
let entries = match std::fs::read_dir(dir) {
Ok(e) => e,
Err(e)
if e.kind() == std::io::ErrorKind::NotFound
&& treat_missing_directory_as_absent(dir) =>
{
return (workspaces, errors);
}
Err(e) => {
errors.push(format!("cannot read workspaces dir: {e}"));
return (workspaces, errors);
}
};
for entry in entries.flatten() {
let path = entry.path();
if path.extension().and_then(|e| e.to_str()) != Some("toml") {
continue;
}
match std::fs::read_to_string(&path) {
Ok(text) => match toml::from_str::<WorkspaceFile>(&text) {
Ok(wf) => workspaces.push(wf.workspace),
Err(e) => errors.push(format!("{}: parse error: {e}", path.display())),
},
Err(e) => errors.push(format!("{}: read error: {e}", path.display())),
}
}
(workspaces, errors)
}
pub fn save_workspace(workspace: &Workspace, paths: &AppPaths) -> Result<(), String> {
std::fs::create_dir_all(&paths.workspaces_dir)
.map_err(|e| format!("cannot create workspaces dir: {e}"))?;
let file_name = format!("{}.toml", workspace.id);
let path = paths.workspaces_dir.join(file_name);
let wf = WorkspaceFile {
workspace: workspace.clone(),
};
let text = toml::to_string_pretty(&wf).map_err(|e| format!("serialization error: {e}"))?;
crate::atomic_write::write(&path, text).map_err(|e| format!("write error: {e}"))
}
pub fn delete_workspace_file(workspace: &Workspace, paths: &AppPaths) -> Result<(), String> {
let file_name = format!("{}.toml", workspace.id);
let path = paths.workspaces_dir.join(file_name);
match std::fs::remove_file(&path) {
Ok(()) => Ok(()),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
match std::fs::metadata(&paths.workspaces_dir) {
Ok(meta) if meta.is_dir() => Ok(()),
Ok(_) => Err(format!(
"delete error: {} is not a directory",
paths.workspaces_dir.display()
)),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
Err(e) => Err(format!("delete error: {e}")),
}
}
Err(e) => Err(format!("delete error: {e}")),
}
}
pub fn save_operation_log(log: &OperationLog, paths: &AppPaths) -> Result<(), String> {
std::fs::create_dir_all(&paths.history_dir)
.map_err(|e| format!("cannot create history dir: {e}"))?;
let ts = log.result.started_at.format("%Y%m%dT%H%M%SZ");
let file_name = format!("{}_{}.json", ts, log.result.operation_id);
let path = paths.history_dir.join(file_name);
let text =
serde_json::to_string_pretty(log).map_err(|e| format!("serialization error: {e}"))?;
crate::atomic_write::write(&path, text).map_err(|e| format!("write error: {e}"))
}
pub struct LoadedLogs {
pub logs: Vec<OperationLog>,
pub unreadable: usize,
pub directory_unreadable: bool,
}
pub fn load_recent_logs(paths: &AppPaths, limit: usize) -> LoadedLogs {
let dir = &paths.history_dir;
let mut entries: Vec<_> = match std::fs::read_dir(dir) {
Ok(e) => e.flatten().collect(),
Err(e)
if e.kind() == std::io::ErrorKind::NotFound
&& treat_missing_directory_as_absent(dir) =>
{
return LoadedLogs {
logs: Vec::new(),
unreadable: 0,
directory_unreadable: false,
};
}
Err(_) => {
return LoadedLogs {
logs: Vec::new(),
unreadable: 0,
directory_unreadable: true,
};
}
};
entries.sort_by_key(|b| std::cmp::Reverse(b.file_name()));
let mut logs = Vec::new();
let mut unreadable = 0;
for entry in entries {
if logs.len() >= limit {
break;
}
let parsed = std::fs::read_to_string(entry.path())
.ok()
.and_then(|text| serde_json::from_str::<OperationLog>(&text).ok());
match parsed {
Some(log) => logs.push(log),
None => unreadable += 1,
}
}
LoadedLogs {
logs,
unreadable,
directory_unreadable: false,
}
}
#[cfg(test)]
mod tests {
use super::*;
use knotra_vcs::model::operation::{
OperationId, OperationKind, OperationResult, ProjectOperationOutcome,
ProjectOperationResult,
};
fn paths_in(tmp: &tempfile::TempDir) -> AppPaths {
AppPaths {
config_file: tmp.path().join("config.toml"),
workspaces_dir: tmp.path().join("workspaces"),
history_dir: tmp.path().join("history"),
}
}
fn log_at(seconds: i64) -> OperationLog {
let ts = chrono::DateTime::from_timestamp(seconds, 0).unwrap();
OperationLog {
result: OperationResult {
operation_id: OperationId::new(),
kind: OperationKind::Fetch,
started_at: ts,
finished_at: ts,
per_project: Vec::new(),
rollback_attempted: false,
rollback_succeeded: None,
},
recovery_hints: Vec::new(),
}
}
fn write_corrupt_file(paths: &AppPaths, seconds: i64) {
std::fs::create_dir_all(&paths.history_dir).expect("create history dir");
let ts = chrono::DateTime::from_timestamp(seconds, 0)
.unwrap()
.format("%Y%m%dT%H%M%SZ");
let path = paths.history_dir.join(format!("{ts}_corrupt.json"));
std::fs::write(path, "not valid json").expect("write corrupt file");
}
#[test]
fn a_pre_fix_prose_skip_reason_round_trips_and_still_renders() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = paths_in(&tmp);
let now = chrono::Utc::now();
let prose = "このプロジェクトは今は確認できません。";
let log = OperationLog {
result: OperationResult {
operation_id: OperationId::new(),
kind: OperationKind::Fetch,
started_at: now,
finished_at: now,
per_project: vec![ProjectOperationResult {
project_id: knotra_vcs::ProjectId::new(),
outcome: ProjectOperationOutcome::Skipped,
success: true,
skip_reason: Some(prose.to_owned()),
commands_executed: Vec::new(),
stdout: String::new(),
stderr: String::new(),
exit_code: None,
error_message: None,
}],
rollback_attempted: false,
rollback_succeeded: None,
},
recovery_hints: Vec::new(),
};
save_operation_log(&log, &paths).expect("save a pre-fix record");
let loaded = load_recent_logs(&paths, 10).logs;
assert_eq!(loaded.len(), 1, "a pre-fix record must not be dropped");
assert_eq!(
loaded[0].result.per_project[0].skip_reason.as_deref(),
Some(prose),
"a pre-fix prose value must round-trip byte-for-byte"
);
let state = crate::state::AppState::new(crate::config::AppConfig::default());
let rendered = crate::view::skip_reason_display(
&state,
loaded[0].result.per_project[0]
.skip_reason
.as_deref()
.unwrap(),
);
assert_eq!(
rendered, prose,
"an unrecognised value must render verbatim -- no panic, no blank"
);
}
#[test]
fn load_recent_logs_fills_the_limit_with_valid_logs_despite_a_newer_corrupt_file() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = paths_in(&tmp);
for s in [100, 101, 102, 103, 104] {
save_operation_log(&log_at(s), &paths).expect("save a valid log");
}
write_corrupt_file(&paths, 105);
let loaded = load_recent_logs(&paths, 3);
assert_eq!(
loaded.logs.len(),
3,
"expected the 3 most recent VALID logs, not limit - 1"
);
assert_eq!(loaded.unreadable, 1);
assert!(!loaded.directory_unreadable);
}
#[test]
fn load_recent_logs_reports_the_unreadable_count() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = paths_in(&tmp);
for s in [100, 101, 102] {
save_operation_log(&log_at(s), &paths).expect("save a valid log");
}
write_corrupt_file(&paths, 103);
let loaded = load_recent_logs(&paths, 10);
assert_eq!(loaded.logs.len(), 3, "all three valid logs must load");
assert_eq!(loaded.unreadable, 1);
assert!(!loaded.directory_unreadable);
}
#[test]
#[cfg(unix)]
fn load_recent_logs_reports_an_unreadable_directory_distinctly() {
use std::os::unix::fs::PermissionsExt;
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = paths_in(&tmp);
std::fs::create_dir_all(&paths.history_dir).expect("create history dir");
std::fs::set_permissions(&paths.history_dir, std::fs::Permissions::from_mode(0o000))
.expect("remove read permission");
let loaded = load_recent_logs(&paths, 10);
std::fs::set_permissions(&paths.history_dir, std::fs::Permissions::from_mode(0o755))
.expect("restore permission for cleanup");
assert!(loaded.logs.is_empty());
assert_eq!(loaded.unreadable, 0);
assert!(
loaded.directory_unreadable,
"a permissions failure must be reported, not read as an empty directory"
);
}
#[test]
fn load_recent_logs_treats_a_missing_directory_as_no_history_not_an_error() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = paths_in(&tmp);
let loaded = load_recent_logs(&paths, 10);
assert!(loaded.logs.is_empty());
assert_eq!(loaded.unreadable, 0);
assert!(!loaded.directory_unreadable);
}
#[test]
fn load_recent_logs_reports_a_directory_blocked_by_a_plain_file() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let mut paths = paths_in(&tmp);
paths.history_dir = tmp.path().join("not-a-directory");
std::fs::write(&paths.history_dir, "file").expect("create blocking file");
let loaded = load_recent_logs(&paths, 10);
assert!(loaded.logs.is_empty());
assert_eq!(loaded.unreadable, 0);
assert!(
loaded.directory_unreadable,
"a blocked directory must be reported, not read as no history yet"
);
}
}