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.strftime("%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}"))
}
#[derive(Debug, Clone)]
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 = jiff::Timestamp::from_second(seconds).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(),
}
}
#[test]
fn save_operation_log_filename_timestamp_prefix_is_stable() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = paths_in(&tmp);
let log = log_at(1_709_528_767);
save_operation_log(&log, &paths).expect("save must succeed");
let names: Vec<String> = std::fs::read_dir(&paths.history_dir)
.expect("history dir must exist")
.filter_map(|e| e.ok())
.map(|e| e.file_name().to_string_lossy().into_owned())
.collect();
assert_eq!(names.len(), 1, "{names:?}");
assert!(
names[0].starts_with("20240304T050607Z_"),
"expected the filename to start with \"20240304T050607Z_\"; got {:?}",
names[0]
);
}
fn write_corrupt_file(paths: &AppPaths, seconds: i64) {
std::fs::create_dir_all(&paths.history_dir).expect("create history dir");
let ts = jiff::Timestamp::from_second(seconds)
.unwrap()
.strftime("%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 = jiff::Timestamp::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(),
project_name: None,
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"
);
}
fn fixture(name: &str) -> &'static str {
match name {
"with-nanoseconds" => {
include_str!("../tests/fixtures/chrono-log-fixtures/with-nanoseconds.json")
}
"without-nanoseconds" => {
include_str!("../tests/fixtures/chrono-log-fixtures/without-nanoseconds.json")
}
"v0.27.0-prose-skip-reason" => {
include_str!("../tests/fixtures/chrono-log-fixtures/v0.27.0-prose-skip-reason.json")
}
other => panic!("unknown fixture {other}"),
}
}
#[test]
fn a_chrono_written_log_with_nanoseconds_still_loads() {
let log: OperationLog = serde_json::from_str(fixture("with-nanoseconds")).unwrap();
assert_eq!(log.result.started_at.as_second(), 1_709_528_767);
assert_eq!(log.result.started_at.subsec_nanosecond(), 123_456_789);
}
#[test]
fn a_chrono_written_log_without_nanoseconds_still_loads() {
let log: OperationLog = serde_json::from_str(fixture("without-nanoseconds")).unwrap();
assert_eq!(log.result.started_at.as_second(), 1_709_528_767);
assert_eq!(log.result.started_at.subsec_nanosecond(), 0);
}
#[test]
fn a_chrono_written_v027_prose_skip_reason_log_still_loads() {
let log: OperationLog = serde_json::from_str(fixture("v0.27.0-prose-skip-reason")).unwrap();
assert_eq!(log.result.started_at.as_second(), 1_709_528_767);
assert_eq!(
log.result.per_project[0].skip_reason.as_deref(),
Some("このプロジェクトは今は確認できません。")
);
assert_eq!(log.result.per_project[0].project_name, None);
}
#[test]
fn a_freshly_saved_log_round_trips_through_the_real_save_path() {
let tmp = tempfile::TempDir::new().expect("tempdir");
let paths = paths_in(&tmp);
let log = log_at(1_709_528_767);
save_operation_log(&log, &paths).expect("save must succeed");
let entry = std::fs::read_dir(&paths.history_dir)
.expect("history dir")
.next()
.expect("one entry")
.expect("readable entry");
let text = std::fs::read_to_string(entry.path()).expect("read back");
let loaded: OperationLog = serde_json::from_str(&text).expect("must parse");
assert_eq!(loaded.result.started_at, log.result.started_at);
}
}