mod cli;
mod constants;
mod head_hash;
mod meta;
mod utils;
use std::fs::{self, File, OpenOptions};
use std::io::{self, Write};
use std::path::{Path, PathBuf};
use std::time::{Instant, SystemTime, UNIX_EPOCH};
use anyhow::{anyhow, Context, Result};
use clap::Parser;
use meta::{
calc_xxh128_from_file_with_callback, open_regular_file_nofollow, scan_dir_xxh128, DirSnapshot,
FileMeta, ProgressTracker,
};
fn main() -> Result<()> {
let started = Instant::now();
let cli = cli::Cli::parse();
let target = cli.resolve_path()?;
println!("目标: {}", target.display());
let target_info = fs::symlink_metadata(&target)
.with_context(|| format!("无法读取路径信息: {}", target.display()))?;
if target_info.is_dir() {
process_dir(&target)?;
} else if target_info.is_file() {
process_file(&target)?;
} else {
return Err(anyhow!("{} 不是文件或目录", target.display()));
}
println!("耗时: {:?}", started.elapsed());
Ok(())
}
fn process_file(path: &Path) -> Result<()> {
let meta_dir = path
.parent()
.map(Path::to_path_buf)
.unwrap_or_else(|| PathBuf::from("."))
.join("meta");
match symlink_metadata_optional(&meta_dir)? {
Some(info) if info.file_type().is_symlink() => {
return Err(anyhow!("不支持符号链接目录: {}", meta_dir.display()));
}
Some(info) if !info.is_dir() => {
return Err(anyhow!("{} 不是目录", meta_dir.display()));
}
Some(_) => {}
None => {
fs::create_dir_all(&meta_dir)
.with_context(|| format!("无法创建目录: {}", meta_dir.display()))?;
}
}
let basename = path
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_else(|| "unknown".to_string());
let save_path = meta_dir.join(format!("{basename}.json"));
let existing_save = symlink_metadata_optional(&save_path)?;
if existing_save.is_none() {
let file = open_regular_file_nofollow(path)?;
let file_size = file
.metadata()
.with_context(|| format!("无法读取文件信息: {}", path.display()))?
.len();
let tracker = ProgressTracker::new_single_file(file_size, &basename);
let on_bytes = tracker.bytes_callback();
let on_iop = tracker.iop_callback();
let meta = FileMeta::from_open_file_with_callback(path, file, on_bytes, on_iop)?;
tracker.finish("处理完成");
let json = meta.to_pretty_json()?;
println!("{}", json);
write_atomic(&save_path, &json)?;
return Ok(());
}
let save_info = existing_save.expect("checked as Some");
if save_info.file_type().is_symlink() {
return Err(anyhow!("不支持符号链接元数据文件: {}", save_path.display()));
}
if !save_info.is_file() {
return Err(anyhow!("{} 不是文件", save_path.display()));
}
let existing = open_regular_file_nofollow(&save_path)
.with_context(|| format!("无法读取历史元数据: {}", save_path.display()))?;
let old_meta = FileMeta::from_reader(existing)?;
let file = open_regular_file_nofollow(path)?;
let file_size = file
.metadata()
.with_context(|| format!("无法读取文件信息: {}", path.display()))?
.len();
let tracker = ProgressTracker::new_single_file(file_size, &basename);
let on_bytes = tracker.bytes_callback();
let on_iop = tracker.iop_callback();
let fast_hash = calc_xxh128_from_file_with_callback(path, file, on_bytes, on_iop)?;
tracker.finish("校验完成");
if fast_hash == old_meta.xxh128 {
println!("校验通过.");
return Ok(());
}
println!("校验失败!");
println!("现校验文件:");
let file = open_regular_file_nofollow(path)?;
let file_size = file
.metadata()
.with_context(|| format!("无法读取文件信息: {}", path.display()))?
.len();
let tracker = ProgressTracker::new_single_file(file_size, &basename);
let on_bytes = tracker.bytes_callback();
let on_iop = tracker.iop_callback();
let meta = FileMeta::from_open_file_with_callback(path, file, on_bytes, on_iop)?;
tracker.finish("处理完成");
println!("{}", meta.to_pretty_json()?);
println!("原校验文件:");
println!("{}", old_meta.to_pretty_json()?);
Ok(())
}
fn process_dir(path: &Path) -> Result<()> {
let meta_path = path.join("meta.json");
let backup_path = path.join("meta-old.json");
let Some(meta_info) = symlink_metadata_optional(&meta_path)? else {
let snapshot = DirSnapshot::build_root(path)?;
let json = serde_json::to_string_pretty(&snapshot)?;
write_atomic(&meta_path, &json)?;
return Ok(());
};
if meta_info.file_type().is_symlink() {
return Err(anyhow!("不支持符号链接元数据文件: {}", meta_path.display()));
}
if !meta_info.is_file() {
return Err(anyhow!("{} 不是文件", meta_path.display()));
}
if symlink_metadata_optional(&backup_path)?.is_some() {
fs::remove_file(&backup_path)?;
}
fs::rename(&meta_path, &backup_path)
.with_context(|| format!("无法重命名旧meta: {}", meta_path.display()))?;
sync_parent_dir(&backup_path)?;
println!("发现旧元数据，已暂存为 meta-old.json，开始校验...");
let meta_file = open_regular_file_nofollow(&backup_path)
.with_context(|| format!("无法读取: {}", backup_path.display()))?;
let snapshot = DirSnapshot::from_reader(meta_file)?;
let mut stored = snapshot.collect_file_map(path);
let current = scan_dir_xxh128(path)?;
let mut issues = false;
for (file_path, hash) in current {
if let Some(meta) = stored.remove(&file_path) {
if hash != meta.xxh128 {
println!(
"校验失败: {}\n 期望: {}\n 当前: {}",
file_path.display(),
meta.xxh128,
hash
);
issues = true;
}
} else {
println!("文件新增: {}", file_path.display());
issues = true;
}
}
for (missing_path, _) in stored {
println!("文件缺失: {}", missing_path.display());
issues = true;
}
if issues {
println!("校验存在异常，已保留 meta-old.json 供排查。");
} else {
println!("校验通过.");
fs::rename(&backup_path, &meta_path)
.with_context(|| format!("无法恢复meta: {}", meta_path.display()))?;
sync_parent_dir(&meta_path)?;
}
Ok(())
}
fn write_atomic(path: &Path, contents: &str) -> Result<()> {
let parent = path
.parent()
.map(Path::to_path_buf)
.unwrap_or_else(|| PathBuf::from("."));
let nanos = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|duration| duration.as_nanos())
.unwrap_or(0);
let tmp_path = parent.join(format!(".l-s-tmp-{}-{nanos}", std::process::id()));
let result = (|| -> Result<()> {
let mut temp = OpenOptions::new()
.write(true)
.create_new(true)
.open(&tmp_path)
.with_context(|| format!("无法创建临时文件: {}", tmp_path.display()))?;
temp.write_all(contents.as_bytes())
.with_context(|| format!("无法写入临时文件: {}", tmp_path.display()))?;
temp.sync_all()
.with_context(|| format!("无法同步临时文件: {}", tmp_path.display()))?;
drop(temp);
fs::rename(&tmp_path, path).with_context(|| {
format!(
"无法将临时文件重命名为目标文件: {} -> {}",
tmp_path.display(),
path.display()
)
})?;
sync_parent_dir(path)?;
Ok(())
})();
if result.is_err() {
let _ = fs::remove_file(&tmp_path);
}
result
}
fn symlink_metadata_optional(path: &Path) -> Result<Option<fs::Metadata>> {
match fs::symlink_metadata(path) {
Ok(info) => Ok(Some(info)),
Err(err) if err.kind() == io::ErrorKind::NotFound => Ok(None),
Err(err) => Err(err).with_context(|| format!("无法读取路径信息: {}", path.display())),
}
}
fn sync_parent_dir(path: &Path) -> Result<()> {
let parent = path.parent().unwrap_or_else(|| Path::new("."));
let dir = File::open(parent)
.with_context(|| format!("无法打开父目录以同步: {}", parent.display()))?;
dir.sync_all()
.with_context(|| format!("无法同步父目录: {}", parent.display()))
}