669 lines
21 KiB
Rust
669 lines
21 KiB
Rust
pub mod cache;
|
||
pub mod compression;
|
||
pub mod dedup;
|
||
pub mod local_fs;
|
||
pub mod open_flags;
|
||
pub mod raid;
|
||
pub mod s3_fs;
|
||
pub mod smb_fs;
|
||
#[cfg(feature = "smb-server")]
|
||
pub mod smb_server_backend;
|
||
pub mod util;
|
||
#[cfg(feature = "async-vfs")]
|
||
pub mod async_fs;
|
||
#[cfg(feature = "async-vfs")]
|
||
pub mod async_s3_fs;
|
||
#[cfg(feature = "async-vfs")]
|
||
pub mod async_smb_fs;
|
||
|
||
use std::path::{Path, PathBuf};
|
||
use std::time::SystemTime;
|
||
|
||
/// VFS 错误类型
|
||
#[derive(Debug, Clone)]
|
||
pub enum VfsError {
|
||
NotFound(String),
|
||
PermissionDenied(String),
|
||
AlreadyExists(String),
|
||
NotEmpty(String),
|
||
NotADirectory(String),
|
||
IsADirectory(String),
|
||
Unsupported(String),
|
||
Io(String),
|
||
UnexpectedEof,
|
||
}
|
||
|
||
impl std::fmt::Display for VfsError {
|
||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||
match self {
|
||
VfsError::NotFound(p) => write!(f, "No such file or directory: {}", p),
|
||
VfsError::PermissionDenied(p) => write!(f, "Permission denied: {}", p),
|
||
VfsError::AlreadyExists(p) => write!(f, "File already exists: {}", p),
|
||
VfsError::NotEmpty(p) => write!(f, "Directory not empty: {}", p),
|
||
VfsError::NotADirectory(p) => write!(f, "Not a directory: {}", p),
|
||
VfsError::IsADirectory(p) => write!(f, "Is a directory: {}", p),
|
||
VfsError::Unsupported(msg) => write!(f, "Unsupported: {}", msg),
|
||
VfsError::Io(msg) => write!(f, "IO error: {}", msg),
|
||
VfsError::UnexpectedEof => write!(f, "Unexpected end of file"),
|
||
}
|
||
}
|
||
}
|
||
|
||
impl std::error::Error for VfsError {}
|
||
|
||
/// 文件统计信息（类似 libc::stat）
|
||
#[derive(Debug, Clone)]
|
||
pub struct VfsStat {
|
||
pub size: u64,
|
||
pub mode: u32,
|
||
pub uid: u32,
|
||
pub gid: u32,
|
||
pub atime: SystemTime,
|
||
pub mtime: SystemTime,
|
||
pub is_dir: bool,
|
||
pub is_symlink: bool,
|
||
}
|
||
|
||
impl VfsStat {
|
||
pub fn new() -> Self {
|
||
Self {
|
||
size: 0,
|
||
mode: 0,
|
||
uid: 0,
|
||
gid: 0,
|
||
atime: SystemTime::UNIX_EPOCH,
|
||
mtime: SystemTime::UNIX_EPOCH,
|
||
is_dir: false,
|
||
is_symlink: false,
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Default for VfsStat {
|
||
fn default() -> Self {
|
||
Self::new()
|
||
}
|
||
}
|
||
|
||
/// 目录条目
|
||
#[derive(Debug, Clone)]
|
||
pub struct VfsDirEntry {
|
||
pub name: String,
|
||
pub long_name: String,
|
||
pub stat: VfsStat,
|
||
}
|
||
|
||
/// 打开文件的抽象
|
||
pub trait VfsFile: Send {
|
||
fn read(&mut self, buf: &mut [u8]) -> Result<usize, VfsError>;
|
||
fn write(&mut self, buf: &[u8]) -> Result<usize, VfsError>;
|
||
fn seek(&mut self, pos: std::io::SeekFrom) -> Result<u64, VfsError>;
|
||
fn flush(&mut self) -> Result<(), VfsError>;
|
||
fn stat(&mut self) -> Result<VfsStat, VfsError>;
|
||
fn set_len(&mut self, size: u64) -> Result<(), VfsError>;
|
||
|
||
/// Write all bytes (convenience, default loops write() until done)
|
||
fn write_all(&mut self, mut buf: &[u8]) -> Result<(), VfsError> {
|
||
while !buf.is_empty() {
|
||
let n = self.write(buf)?;
|
||
if n == 0 {
|
||
return Err(VfsError::Io("write returned 0".to_string()));
|
||
}
|
||
buf = &buf[n..];
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// Read exactly `buf.len()` bytes (convenience, loops read() until done)
|
||
fn read_exact(&mut self, mut buf: &mut [u8]) -> Result<(), VfsError> {
|
||
while !buf.is_empty() {
|
||
let n = self.read(buf)?;
|
||
if n == 0 {
|
||
return Err(VfsError::UnexpectedEof);
|
||
}
|
||
buf = &mut buf[n..];
|
||
}
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
/// VFS 后端 trait（所有文件系统操作）
|
||
pub trait VfsBackend: Send + Sync {
|
||
/// Clone boxed
|
||
fn clone_boxed(&self) -> Box<dyn VfsBackend>;
|
||
|
||
/// 读取目录内容
|
||
fn read_dir(&self, path: &Path) -> Result<Vec<VfsDirEntry>, VfsError>;
|
||
|
||
/// 打开文件（读/写）
|
||
fn open_file(
|
||
&self,
|
||
path: &Path,
|
||
flags: &open_flags::OpenFlags,
|
||
) -> Result<Box<dyn VfsFile>, VfsError>;
|
||
|
||
/// 获取文件/目录元数据
|
||
fn stat(&self, path: &Path) -> Result<VfsStat, VfsError>;
|
||
fn lstat(&self, path: &Path) -> Result<VfsStat, VfsError>;
|
||
|
||
/// 创建目录
|
||
fn create_dir(&self, path: &Path, mode: u32) -> Result<(), VfsError>;
|
||
|
||
/// 递归创建目录
|
||
fn create_dir_all(&self, path: &Path, mode: u32) -> Result<(), VfsError>;
|
||
|
||
/// 删除空目录
|
||
fn remove_dir(&self, path: &Path) -> Result<(), VfsError>;
|
||
|
||
/// 递归删除目录及其所有内容
|
||
fn remove_dir_all(&self, path: &Path) -> Result<(), VfsError> {
|
||
// Default: read entries and remove one by one
|
||
let entries = self.read_dir(path)?;
|
||
for entry in entries {
|
||
let child = path.join(&entry.name);
|
||
if entry.stat.is_dir {
|
||
self.remove_dir_all(&child)?;
|
||
} else {
|
||
self.remove_file(&child)?;
|
||
}
|
||
}
|
||
self.remove_dir(path)
|
||
}
|
||
|
||
/// 删除文件
|
||
fn remove_file(&self, path: &Path) -> Result<(), VfsError>;
|
||
|
||
/// 重命名
|
||
fn rename(&self, from: &Path, to: &Path) -> Result<(), VfsError>;
|
||
|
||
/// 设置文件属性
|
||
fn set_stat(&self, path: &Path, stat: &VfsStat) -> Result<(), VfsError>;
|
||
|
||
/// 原子性设置 atime 和 mtime（默认实现调用 stat + set_stat，有 race condition）
|
||
fn set_times(&self, path: &Path, atime: SystemTime, mtime: SystemTime) -> Result<(), VfsError> {
|
||
let mut stat = self.stat(path)?;
|
||
stat.atime = atime;
|
||
stat.mtime = mtime;
|
||
self.set_stat(path, &stat)
|
||
}
|
||
|
||
/// 原子性设置 atime（默认实现调用 stat + set_stat，有 race condition）
|
||
fn set_atime(&self, path: &Path, atime: SystemTime) -> Result<(), VfsError> {
|
||
let mut stat = self.stat(path)?;
|
||
stat.atime = atime;
|
||
self.set_stat(path, &stat)
|
||
}
|
||
|
||
/// 原子性设置 mtime（默认实现调用 stat + set_stat，有 race condition）
|
||
fn set_mtime(&self, path: &Path, mtime: SystemTime) -> Result<(), VfsError> {
|
||
let mut stat = self.stat(path)?;
|
||
stat.mtime = mtime;
|
||
self.set_stat(path, &stat)
|
||
}
|
||
|
||
/// 读取符号链接目标
|
||
fn read_link(&self, path: &Path) -> Result<PathBuf, VfsError>;
|
||
|
||
/// 创建符号链接
|
||
fn create_symlink(&self, target: &Path, link: &Path) -> Result<(), VfsError>;
|
||
|
||
/// 规范化路径
|
||
fn real_path(&self, path: &Path) -> Result<PathBuf, VfsError>;
|
||
|
||
/// 检查路径是否存在
|
||
fn exists(&self, path: &Path) -> bool;
|
||
|
||
/// 创建硬链接
|
||
fn hard_link(&self, original: &Path, link: &Path) -> Result<(), VfsError>;
|
||
|
||
/// 复制文件（高效实现，fallback 到 read+write）
|
||
fn copy(&self, from: &Path, to: &Path) -> Result<(), VfsError> {
|
||
let flags = open_flags::OpenFlags::new().read();
|
||
let mut src = self.open_file(from, &flags)?;
|
||
let write_flags = open_flags::OpenFlags::new().write().create().truncate().mode(0o644);
|
||
let mut dst = self.open_file(to, &write_flags)?;
|
||
let mut buf = vec![0u8; 65536];
|
||
loop {
|
||
match src.read(&mut buf) {
|
||
Ok(0) => break,
|
||
Ok(n) => dst.write_all(&buf[..n])?,
|
||
Err(e) => return Err(e),
|
||
}
|
||
}
|
||
dst.flush()?;
|
||
Ok(())
|
||
}
|
||
|
||
// ===== Snapshot support (ZFS-style) =====
|
||
|
||
/// 创建快照
|
||
fn create_snapshot(&self, _path: &Path, _name: &str) -> Result<(), VfsError> {
|
||
Err(VfsError::Unsupported("create_snapshot".to_string()))
|
||
}
|
||
|
||
/// 列出快照
|
||
fn list_snapshots(&self, _path: &Path) -> Result<Vec<String>, VfsError> {
|
||
Err(VfsError::Unsupported("list_snapshots".to_string()))
|
||
}
|
||
|
||
/// 删除快照
|
||
fn delete_snapshot(&self, _path: &Path, _name: &str) -> Result<(), VfsError> {
|
||
Err(VfsError::Unsupported("delete_snapshot".to_string()))
|
||
}
|
||
|
||
/// 从快照恢复
|
||
fn restore_snapshot(&self, _path: &Path, _name: &str) -> Result<(), VfsError> {
|
||
Err(VfsError::Unsupported("restore_snapshot".to_string()))
|
||
}
|
||
|
||
/// 获取快照信息
|
||
fn snapshot_info(&self, _path: &Path, _name: &str) -> Result<VfsSnapshotInfo, VfsError> {
|
||
Err(VfsError::Unsupported("snapshot_info".to_string()))
|
||
}
|
||
|
||
// ===== Quota support =====
|
||
|
||
/// 设置配额限制（字节）
|
||
fn set_quota(&self, _path: &Path, _quota: &VfsQuota) -> Result<(), VfsError> {
|
||
Err(VfsError::Unsupported("set_quota".to_string()))
|
||
}
|
||
|
||
/// 获取配额信息
|
||
fn get_quota(&self, _path: &Path) -> Result<VfsQuota, VfsError> {
|
||
Err(VfsError::Unsupported("get_quota".to_string()))
|
||
}
|
||
|
||
/// 获取配额使用情况
|
||
fn get_quota_usage(&self, _path: &Path) -> Result<VfsQuotaUsage, VfsError> {
|
||
Err(VfsError::Unsupported("get_quota_usage".to_string()))
|
||
}
|
||
|
||
/// 检查配额（写入前检查）
|
||
fn check_quota(&self, _path: &Path, _size: u64) -> Result<bool, VfsError> {
|
||
Ok(true) // Default: no quota, always allow
|
||
}
|
||
|
||
// ===== Previous versions (shadow copy) =====
|
||
|
||
/// 列出文件的所有历史版本
|
||
fn list_previous_versions(&self, _path: &Path) -> Result<Vec<VfsPreviousVersion>, VfsError> {
|
||
Err(VfsError::Unsupported("list_previous_versions".to_string()))
|
||
}
|
||
|
||
/// 打开历史版本文件（通过 @GMT- token）
|
||
fn open_previous_version(&self, _path: &Path, _gmt_token: &str) -> Result<Box<dyn VfsFile>, VfsError> {
|
||
Err(VfsError::Unsupported("open_previous_version".to_string()))
|
||
}
|
||
|
||
/// 从历史版本恢复文件
|
||
fn restore_previous_version(&self, _path: &Path, _gmt_token: &str) -> Result<(), VfsError> {
|
||
Err(VfsError::Unsupported("restore_previous_version".to_string()))
|
||
}
|
||
|
||
// ===== ACL support (NFSv4/SMB) =====
|
||
|
||
/// 获取文件ACL
|
||
fn get_acl(&self, _path: &Path) -> Result<VfsAcl, VfsError> {
|
||
Err(VfsError::Unsupported("get_acl".to_string()))
|
||
}
|
||
|
||
/// 设置文件ACL
|
||
fn set_acl(&self, _path: &Path, _acl: &VfsAcl) -> Result<(), VfsError> {
|
||
Err(VfsError::Unsupported("set_acl".to_string()))
|
||
}
|
||
|
||
/// 检查ACL权限
|
||
fn check_acl(&self, _path: &Path, _principal: &str, _mask: VfsAceMask) -> Result<bool, VfsError> {
|
||
Ok(true) // Default: no ACL, always allow
|
||
}
|
||
|
||
/// 添加ACE
|
||
fn add_ace(&self, _path: &Path, _ace: &VfsAce) -> Result<(), VfsError> {
|
||
Err(VfsError::Unsupported("add_ace".to_string()))
|
||
}
|
||
|
||
/// 移除ACE
|
||
fn remove_ace(&self, _path: &Path, _ace_index: usize) -> Result<(), VfsError> {
|
||
Err(VfsError::Unsupported("remove_ace".to_string()))
|
||
}
|
||
}
|
||
|
||
/// 快照信息
|
||
#[derive(Debug, Clone)]
|
||
pub struct VfsSnapshotInfo {
|
||
/// 快照名称
|
||
pub name: String,
|
||
/// 创建时间
|
||
pub created: SystemTime,
|
||
/// 快照大小（字节）
|
||
pub size: u64,
|
||
/// 是否只读
|
||
pub read_only: bool,
|
||
}
|
||
|
||
/// 配额设置
|
||
#[derive(Debug, Clone)]
|
||
pub struct VfsQuota {
|
||
/// 空间限制（字节），0表示无限制
|
||
pub space_limit: u64,
|
||
/// 文件数量限制，0表示无限制
|
||
pub file_limit: u64,
|
||
/// 用户ID（可选）
|
||
pub user_id: Option<String>,
|
||
/// 软限制（字节），超过时警告
|
||
pub soft_limit: u64,
|
||
/// 宽限期（秒）
|
||
pub grace_period: u64,
|
||
}
|
||
|
||
/// 配额使用情况
|
||
#[derive(Debug, Clone)]
|
||
pub struct VfsQuotaUsage {
|
||
/// 已使用空间（字节）
|
||
pub space_used: u64,
|
||
/// 文件数量
|
||
pub files_used: u64,
|
||
/// 是否超过软限制
|
||
pub over_soft_limit: bool,
|
||
/// 是否超过硬限制
|
||
pub over_hard_limit: bool,
|
||
}
|
||
|
||
/// 历史版本信息（SMB shadow copy）
|
||
#[derive(Debug, Clone)]
|
||
pub struct VfsPreviousVersion {
|
||
/// 快照名称
|
||
pub snapshot_name: String,
|
||
/// GMT token (@GMT-YYYY.MM.DD-HH.MM.SS)
|
||
pub gmt_token: String,
|
||
/// 创建时间
|
||
pub created: SystemTime,
|
||
/// 版本大小（字节）
|
||
pub size: u64,
|
||
}
|
||
|
||
/// ACL访问控制条目类型（NFSv4/SMB）
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
pub enum VfsAceType {
|
||
/// 允许访问
|
||
Allow,
|
||
/// 拒绝访问
|
||
Deny,
|
||
/// 审计（SMB）
|
||
Audit,
|
||
/// 警报（SMB）
|
||
Alarm,
|
||
}
|
||
|
||
/// ACL继承标志（NFSv4/SMB）
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
pub enum VfsAceFlag {
|
||
/// 文件继承
|
||
FileInherit,
|
||
/// 目录继承
|
||
DirectoryInherit,
|
||
/// 无继承（仅当前对象）
|
||
NoPropagateInherit,
|
||
/// 仅继承（不应用于当前对象）
|
||
InheritOnly,
|
||
/// 已继承
|
||
Inherited,
|
||
/// 成功审计（SMB）
|
||
SuccessfulAccess,
|
||
/// 失败审计（SMB）
|
||
FailedAccess,
|
||
}
|
||
|
||
/// ACL权限掩码（NFSv4）
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
pub enum VfsAceMask {
|
||
/// 读数据
|
||
ReadData,
|
||
/// 写数据
|
||
WriteData,
|
||
/// 执行
|
||
Execute,
|
||
/// 列目录（读数据+目录）
|
||
ListDirectory,
|
||
/// 添加文件（写数据+目录）
|
||
AddFile,
|
||
/// 添加子目录
|
||
AddSubdirectory,
|
||
/// 删除子项
|
||
DeleteChild,
|
||
/// 删除
|
||
Delete,
|
||
/// 读属性
|
||
ReadAttributes,
|
||
/// 写属性
|
||
WriteAttributes,
|
||
/// 读ACL
|
||
ReadNfsAcl,
|
||
/// 写ACL
|
||
WriteNfsAcl,
|
||
/// 读取所有权
|
||
ReadOwner,
|
||
/// 写入所有权
|
||
WriteOwner,
|
||
/// 同步
|
||
Synchronize,
|
||
/// 完全控制（所有权限）
|
||
FullControl,
|
||
}
|
||
|
||
/// ACL访问控制条目（ACE）
|
||
#[derive(Debug, Clone)]
|
||
pub struct VfsAce {
|
||
/// ACE类型
|
||
pub ace_type: VfsAceType,
|
||
/// ACE标志
|
||
pub flags: Vec<VfsAceFlag>,
|
||
/// 权限掩码
|
||
pub mask: Vec<VfsAceMask>,
|
||
/// 主体（用户/组SID或名称）
|
||
pub principal: String,
|
||
}
|
||
|
||
/// ACL列表（NFSv4/SMB）
|
||
#[derive(Debug, Clone, Default)]
|
||
pub struct VfsAcl {
|
||
/// ACE列表
|
||
pub aces: Vec<VfsAce>,
|
||
/// 默认ACL（仅目录）
|
||
pub default_acl: Option<Box<VfsAcl>>,
|
||
}
|
||
|
||
/// 压缩算法类型
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
pub enum VfsCompression {
|
||
/// 无压缩
|
||
None,
|
||
/// LZ4压缩（快速）
|
||
Lz4,
|
||
/// ZSTD压缩（高压缩率）
|
||
Zstd,
|
||
}
|
||
|
||
/// 压缩配置
|
||
#[derive(Debug, Clone)]
|
||
pub struct VfsCompressionConfig {
|
||
/// 压缩算法
|
||
pub algorithm: VfsCompression,
|
||
/// 压缩级别（1-22 for ZSTD, 1-12 for LZ4）
|
||
pub level: u32,
|
||
/// 最小压缩大小（字节），小于此大小不压缩
|
||
pub min_size: u64,
|
||
}
|
||
|
||
/// 去重配置
|
||
#[derive(Debug, Clone)]
|
||
pub struct VfsDedupConfig {
|
||
/// 块大小（字节），默认4KB
|
||
pub block_size: usize,
|
||
/// 最小文件大小（字节），小于此大小不去重
|
||
pub min_file_size: u64,
|
||
/// 去重存储路径
|
||
pub store_path: PathBuf,
|
||
}
|
||
|
||
impl Default for VfsDedupConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
block_size: 4096,
|
||
min_file_size: 1024,
|
||
store_path: PathBuf::from(".dedup"),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// RAID级别（ZFS RAID-Z）
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
pub enum VfsRaidLevel {
|
||
/// 单磁盘（无RAID）
|
||
Single,
|
||
/// RAID-Z1（单奇偶校验，类似RAID 5）
|
||
RaidZ1,
|
||
/// RAID-Z2（双奇偶校验，类似RAID 6）
|
||
RaidZ2,
|
||
/// RAID-Z3（三奇偶校验）
|
||
RaidZ3,
|
||
}
|
||
|
||
impl std::fmt::Display for VfsRaidLevel {
|
||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||
match self {
|
||
VfsRaidLevel::Single => write!(f, "Single"),
|
||
VfsRaidLevel::RaidZ1 => write!(f, "RAID-Z1"),
|
||
VfsRaidLevel::RaidZ2 => write!(f, "RAID-Z2"),
|
||
VfsRaidLevel::RaidZ3 => write!(f, "RAID-Z3"),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// RAID配置
|
||
#[derive(Debug, Clone)]
|
||
pub struct VfsRaidConfig {
|
||
/// RAID级别
|
||
pub level: VfsRaidLevel,
|
||
/// 条带大小（字节），默认64KB
|
||
pub stripe_size: usize,
|
||
/// 磁盘列表路径
|
||
pub disk_paths: Vec<PathBuf>,
|
||
}
|
||
|
||
impl Default for VfsRaidConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
level: VfsRaidLevel::Single,
|
||
stripe_size: 65536,
|
||
disk_paths: Vec::new(),
|
||
}
|
||
}
|
||
}
|
||
|
||
// ===== Async VfsBackend Design (Phase 1 - Framework) =====
|
||
|
||
/// Async VFS 文件 trait（用于异步操作）
|
||
///
|
||
/// 设计要点：
|
||
/// 1. 使用 `async fn` in traits (Rust 1.75+)
|
||
/// 2. 所有方法返回 `Pin<Box<dyn Future>>`
|
||
/// 3. 与 VfsFile 保持一致的接口
|
||
#[cfg(feature = "async-vfs")]
|
||
pub trait AsyncVfsFile: Send + Sync {
|
||
fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<usize, VfsError>> + Send + 'a>>;
|
||
fn write<'a>(&'a mut self, buf: &'a [u8]) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<usize, VfsError>> + Send + 'a>>;
|
||
fn seek<'a>(&'a mut self, pos: std::io::SeekFrom) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<u64, VfsError>> + Send + 'a>>;
|
||
fn flush<'a>(&'a mut self) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), VfsError>> + Send + 'a>>;
|
||
}
|
||
|
||
/// Async VFS 后端 trait（用于异步文件系统操作）
|
||
///
|
||
/// 设计要点：
|
||
/// 1. 使用 `async fn` in traits (Rust 1.75+)
|
||
/// 2. 所有方法返回 `Pin<Box<dyn Future>>`
|
||
/// 3. 与 VfsBackend 保持一致的接口
|
||
/// 4. 用于 WebDAV/SMB/SSH 异步处理
|
||
#[cfg(feature = "async-vfs")]
|
||
pub trait AsyncVfsBackend: Send + Sync {
|
||
fn clone_boxed(&self) -> Box<dyn AsyncVfsBackend>;
|
||
|
||
fn read_dir<'a>(&'a self, path: &'a Path) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Vec<VfsDirEntry>, VfsError>> + Send + 'a>>;
|
||
fn open_file<'a>(&'a self, path: &'a Path, flags: &'a open_flags::OpenFlags) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Box<dyn AsyncVfsFile>, VfsError>> + Send + 'a>>;
|
||
fn stat<'a>(&'a self, path: &'a Path) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<VfsStat, VfsError>> + Send + 'a>>;
|
||
fn create_dir<'a>(&'a self, path: &'a Path, mode: u32) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), VfsError>> + Send + 'a>>;
|
||
fn remove_dir<'a>(&'a self, path: &'a Path) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), VfsError>> + Send + 'a>>;
|
||
fn remove_file<'a>(&'a self, path: &'a Path) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), VfsError>> + Send + 'a>>;
|
||
fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), VfsError>> + Send + 'a>>;
|
||
fn exists<'a>(&'a self, path: &'a Path) -> std::pin::Pin<Box<dyn std::future::Future<Output = bool> + Send + 'a>>;
|
||
}
|
||
|
||
// ===== Async VfsBackend Implementation Notes =====
|
||
//
|
||
// Phase 2: AsyncLocalFs (tokio::fs)
|
||
// - 使用 tokio::fs::File 替代 std::fs::File
|
||
// - 使用 tokio::fs::read_dir 替代 std::fs::read_dir
|
||
// - 使用 tokio::fs::create_dir 替代 std::fs::create_dir
|
||
//
|
||
// Phase 3: AsyncS3Vfs (ureq is blocking, need async client)
|
||
// - 使用 async-s3 或 rusoto
|
||
// - 或者使用 spawn_blocking 包装现有 ureq 调用
|
||
//
|
||
// Phase 4: AsyncSmbVfs
|
||
// - smb-server crate 使用 async internally
|
||
// - 需要 async wrapper
|
||
//
|
||
// Phase 5: WebDAV Integration
|
||
// - VfsDavFs 改为 AsyncVfsBackend
|
||
// - dav-server 已经是 async
|
||
// - 直接使用 async 方法
|
||
//
|
||
// 预估工作量：
|
||
// - AsyncVfsBackend trait: 1 hour
|
||
// - AsyncLocalFs: 3 hours
|
||
// - AsyncS3Vfs: 2 hours
|
||
// - AsyncSmbVfs: 2 hours
|
||
// - WebDAV integration: 3 hours
|
||
// - Tests: 2 hours
|
||
// Total: ~13 hours (multi-day project)
|
||
//
|
||
// ===== Phase 5 WebDAV Async Integration Design =====
|
||
//
|
||
// 现状分析：
|
||
// 1. dav-server DavFileSystem trait 方法返回 Pin<Box<dyn Future>>
|
||
// 2. 当前 VfsDavFs::open() 返回 Box::pin(ready(...))
|
||
// 3. 这是 "同步包装为 Future"，不是真正的 async
|
||
// 4. DavFileSystem trait API 已变化（2026-06-21 session发现）
|
||
// - read_dir(path, ReadDirMeta) 而非 read_dir(path, depth)
|
||
// - have_props(path) 返回 Pin<Box<dyn Future>>
|
||
// - get_props/get_prop/patch_props 新方法
|
||
// - get_quota/set_accessed/set_modified 新方法
|
||
// - DavFile 需要 write_buf 方法
|
||
// - DavMetaData modified()/is_dir() 返回 Pin<Box<dyn Future>>
|
||
// - DavDirEntry name()/is_dir()/metadata() 返回 Pin<Box<dyn Future>>
|
||
//
|
||
// Phase 5 阻塞因素：
|
||
// 1. dav-server API 签名与预期不匹配（20+ 编译错误）
|
||
// 2. 需要 match 完整 DavFileSystem trait 所有方法（~30个）
|
||
// 3. AsyncVfsFile trait 方法签名需调整
|
||
// 4. 估算工作量：~8小时（而非原估计3小时）
|
||
//
|
||
// 实现方案选择：
|
||
// 方案A：spawn_blocking wrapper（推荐）
|
||
// - 创建 AsyncVfsDavFs 包装现有 VfsDavFs
|
||
// - 所有 DavFileSystem 方法使用 spawn_blocking 调用同步版本
|
||
// - 工作量：~2小时
|
||
// - 优点：快速实现，兼容现有 API
|
||
// - 缺点：仍为伪异步（阻塞线程池）
|
||
//
|
||
// 方案B：完整重写 DavFileSystem（长期）
|
||
// - 完全匹配 dav-server API
|
||
// - 使用真正的 AsyncVfsBackend async 方法
|
||
// - 工作量：~8小时
|
||
// - 优点：真正的异步
|
||
// - 缺点：需要完全理解 dav-server API
|
||
//
|
||
// 推荐方案A（spawn_blocking wrapper）
|
||
//
|
||
// 预估工作量：Phase 5 方案A ~2小时，方案B ~8小时
|