vfsi-sync 0.1.8

Synchronous scalar and vectorized filesystem interfaces for VFSI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use super::*;

pub fn stat_impl_default<F: Backend + ?Sized>(backend: &mut F, path: &Path) -> VfResult<VfAttrs> {
    let mut a = VfAttrs {
        file: VfFile::from_os_path(path),
        masks: AttrMask::stat(),
        ..VfAttrs::default()
    };
    backend.vgetattrs_impl(std::slice::from_mut(&mut a))?;
    Ok(a)
}

pub fn lstat_impl_default<F: Backend + ?Sized>(backend: &mut F, path: &Path) -> VfResult<VfAttrs> {
    let mut a = VfAttrs {
        file: VfFile::from_os_path(path),
        masks: AttrMask::stat(),
        ..VfAttrs::default()
    };
    backend.vgetattrs_nofollow_impl(std::slice::from_mut(&mut a))?;
    Ok(a)
}

pub fn fstat_impl_default<F: Backend + ?Sized>(backend: &mut F, tcf: &VfFile) -> VfResult<VfAttrs> {
    let mut a = VfAttrs {
        file: tcf.clone(),
        masks: AttrMask::stat(),
        ..VfAttrs::default()
    };
    backend.vgetattrs_impl(std::slice::from_mut(&mut a))?;
    Ok(a)
}

pub fn exists_impl_default<F: Backend + ?Sized>(backend: &mut F, path: &Path) -> VfResult<bool> {
    match backend.lstat_impl(path) {
        Ok(_) => Ok(true),
        Err(e) if e.err_no() == ERR_NOENT => Ok(false),
        Err(e) => Err(e),
    }
}

pub fn file_type_impl_default<F: Backend + ?Sized>(
    backend: &mut F,
    path: &Path,
) -> VfResult<VfType> {
    Ok(backend.lstat_impl(path)?.ftype)
}

pub fn native_metadata_impl_default<F: Backend + ?Sized>(
    backend: &mut F,
    query: MetadataQuery,
) -> VfResult<VfAttrs> {
    let path = query.file.path().map(std::path::Path::to_path_buf);
    let mut attrs = VfAttrs {
        file: query.file,
        masks: query.attributes,
        ..VfAttrs::default()
    };
    let result = if query.follow_symlinks {
        backend.vgetattrs_impl(std::slice::from_mut(&mut attrs))
    } else {
        backend.vgetattrs_nofollow_impl(std::slice::from_mut(&mut attrs))
    };
    result.map_err(|error| match path {
        Some(path) => error.with_context("metadata", path),
        None => error,
    })?;
    Ok(attrs)
}

pub fn native_metadata_path_impl_default<F: Backend + ?Sized>(
    backend: &mut F,
    path: &std::path::Path,
    follow: bool,
) -> VfResult<Attrs> {
    let mut attributes = VfAttrs {
        file: VfFile::from_os_path(path),
        masks: metadata_mask(),
        ..VfAttrs::default()
    };
    let result = if follow {
        backend.vgetattrs_impl(std::slice::from_mut(&mut attributes))
    } else {
        backend.vgetattrs_nofollow_impl(std::slice::from_mut(&mut attributes))
    };
    result
        .map_err(|error| error.with_context("metadata", path))
        .map(|()| vfsi_core::metadata_from_attrs(attributes))
}

pub fn native_set_metadata_path_impl_default<F: Backend + ?Sized>(
    backend: &mut F,
    path: &std::path::Path,
    update: MetadataUpdate,
    follow: bool,
) -> VfResult<()> {
    let mut attributes = SetAttributes::new(VfFile::from_os_path(path));
    attributes.follow_symlinks = follow;
    attributes.mode = update.permissions.map(Permissions::mode);
    attributes.size = update.len;
    attributes.uid = update.uid;
    attributes.gid = update.gid;
    attributes.atime = update.accessed.map(system_time_parts).transpose()?;
    attributes.mtime = update.modified.map(system_time_parts).transpose()?;
    backend
        .set_attributes_impl(attributes)
        .map_err(|error| error.with_context("set_metadata", path))
}

pub fn vsetattrs_typed_default<F: Backend + ?Sized>(
    backend: &mut F,
    updates: Vec<SetAttributes>,
    follow: bool,
) -> VfResult<()> {
    let attrs: Vec<VfAttrs> = updates
        .into_iter()
        .map(SetAttributes::into_legacy)
        .collect();
    if follow {
        backend.vsetattrs_raw_impl(&attrs)
    } else {
        backend.vsetattrs_raw_nofollow_impl(&attrs)
    }
}