Rust文件系统扩展库fs3使用指南

概述

fs3是Rust的一个文件系统扩展库，提供了跨平台的文件操作增强功能和高级存储管理能力。它扩展了标准库中的std::fs模块，添加了许多有用的功能，如获取磁盘空间信息、文件预分配、文件锁定等。

主要特性

1. 跨平台支持（Windows, Linux, macOS等）
2. 获取文件系统总空间和可用空间
3. 文件预分配（提前分配磁盘空间）
4. 文件锁定功能
5. 高级文件属性操作

安装

在Cargo.toml中添加依赖：

[dependencies]
fs3 = "2.5.0"

基本使用方法

1. 获取磁盘空间信息

use fs3::FileExt;
use std::fs::File;

fn main() -> std::io::Result<()> {
    let file = File::open(".")?;
    
    // 获取总空间
    let total_space = file.total_space()?;
    println!("Total space: {} bytes", total_space);
    
    // 获取可用空间
    let free_space = file.free_space()?;
    println!("Free space: {} bytes", free_space);
    
    // 获取可用空间（包括root保留空间）
    let available_space = file.available_space()?;
    println!("Available space: {} bytes", available_space);
    
    Ok(())
}

2. 文件预分配

use fs3::FileExt;
use std::fs::File;

fn main() -> std::io::Result<()> {
    let file = File::create("large_file.bin")?;
    
    // 预分配1GB空间
    file.pre_allocate(1024 * 1024 * 1024)?;
    println!("Pre-allocated 1GB space");
    
    Ok(())
}

3. 文件锁定

use fs3::FileExt;
use std::fs::File;

fn main() -> std::io::Result<()> {
    let file = File::create("locked_file.txt")?;
    
    // 获取独占锁
    file.lock_exclusive()?;
    println!("File locked exclusively");
    
    // 执行一些操作...
    
    // 解锁文件
    file.unlock()?;
    println!("File unlocked");
    
    Ok(())
}

4. 检查文件系统支持的功能

use fs3::FileExt;
use std::fs::File;

fn main() -> std::io::Result<()> {
    let file = File::open(".")?;
    
    // 检查是否支持文件预分配
    if file.supports_allocate() {
        println!("Filesystem supports pre-allocation");
    } else {
        println!("Filesystem does NOT support pre-allocation");
    }
    
    // 检查是否支持文件锁定
    if file.supports_lock() {
        println!("Filesystem supports file locking");
    } else {
        println!("Filesystem does NOT support file locking");
    }
    
    Ok(())
}

高级用法

并发文件访问控制

use fs3::FileExt;
use std::fs::{File, OpenOptions};
use std::io::{Write, Read};
use std::thread;

fn main() -> std::io::Result<()> {
    let path = "concurrent_file.txt";
    
    // 线程1：写入数据
    let handle1 = thread::spawn(move || {
        let mut file = OpenOptions::new()
            .write(true)
            .create(true)
            .open(path)
            .unwrap();
            
        file.lock_exclusive().unwrap();
        file.write_all(b"Hello from thread 1").unwrap();
        file.unlock().unwrap();
    });
    
    // 线程2：读取数据
    let handle2 = thread::spawn(move || {
        // 等待写入完成
        std::thread::sleep(std::time::Duration::from_millis(100));
        
        let mut file = File::open(path).unwrap();
        let mut contents = String::new();
        
        file.lock_shared().unwrap();
        file.read_to_string(&mut contents).unwrap();
        file.unlock().unwrap();
        
        println!("Read from file: {}", contents);
    });
    
    handle1.join().unwrap();
    handle2.join().unwrap();
    
    Ok(())
}

注意事项

1. 文件锁定行为在不同操作系统上可能有所不同
2. 预分配空间在某些文件系统上可能不是精确的
3. 使用前应检查文件系统是否支持所需功能
4. 错误处理很重要，特别是对于文件锁定操作

fs3库为Rust开发者提供了比标准库更强大的文件系统操作能力，特别适合需要精细控制文件存储和并发访问的应用程序。

完整示例代码

下面是一个综合使用fs3库功能的完整示例：

use fs3::FileExt;
use std::fs::{File, OpenOptions};
use std::io::{Write, Read, Seek, SeekFrom};
use std::thread;
use std::time::Duration;

fn main() -> std::io::Result<()> {
    // 1. 检查文件系统功能支持
    let test_file = File::open(".")?;
    println!("=== 文件系统功能支持检查 ===");
    println!("预分配支持: {}", test_file.supports_allocate());
    println!("文件锁定支持: {}", test_file.supports_lock());
    println!();

    // 2. 获取磁盘空间信息
    println!("=== 磁盘空间信息 ===");
    println!("总空间: {} bytes", test_file.total_space()?);
    println!("可用空间: {} bytes", test_file.free_space()?);
    println!("包括保留空间的可用空间: {} bytes", test_file.available_space()?);
    println!();

    // 3. 文件预分配和写入
    let mut file = OpenOptions::new()
        .read(true)
        .write(true)
        .create(true)
        .open("example.dat")?;
    
    // 预分配100MB空间
    file.pre_allocate(100 * 1024 * 1024)?;
    println!("=== 文件预分配 ===");
    println!("已预分配100MB空间");
    
    // 写入一些数据
    file.write_all(b"This is some sample data")?;
    file.sync_all()?;
    println!("数据已写入文件");
    println!();

    // 4. 文件锁定示例
    println!("=== 文件锁定示例 ===");
    {
        // 获取独占锁
        file.lock_exclusive()?;
        println!("文件已锁定(独占模式)");
        
        // 在锁定状态下读取文件
        let mut content = String::new();
        file.seek(SeekFrom::Start(0))?;
        file.read_to_string(&mut content)?;
        println!("读取到的内容: {}", content);
        
        // 解锁文件
        file.unlock()?;
        println!("文件已解锁");
    }
    println!();

    // 5. 并发文件访问示例
    println!("=== 并发文件访问 ===");
    let path = "concurrent_example.txt";
    
    // 写入线程
    let writer = thread::spawn(move || {
        let mut file = OpenOptions::new()
            .write(true)
            .create(true)
            .open(path)
            .unwrap();
            
        file.lock_exclusive().unwrap();
        file.write_all(b"Data from writer thread").unwrap();
        file.unlock().unwrap();
        println!("写入线程完成");
    });
    
    // 读取线程
    let reader = thread::spawn(move || {
        // 等待写入完成
        thread::sleep(Duration::from_millis(50));
        
        let mut file = File::open(path).unwrap();
        let mut contents = String::new();
        
        file.lock_shared().unwrap();
        file.read_to_string(&mut contents).unwrap();
        file.unlock().unwrap();
        
        println!("读取线程获取的内容: {}", contents);
    });
    
    writer.join().unwrap();
    reader.join().unwrap();

    Ok(())
}

这个完整示例展示了fs3库的主要功能：

1. 检查文件系统功能支持
2. 获取磁盘空间信息
3. 文件预分配和写入操作
4. 文件锁定和解锁
5. 并发文件访问控制

运行此程序将演示fs3库在实际应用中的各种用法，帮助开发者理解如何在自己的项目中使用这些功能。