Skip to main content

nimbus_vault/origin/
fs.rs

1use futures::StreamExt;
2use std::path::PathBuf;
3use tokio::fs::{self, OpenOptions};
4use tokio_util::io::ReaderStream;
5
6use crate::{
7    VaultResult,
8    error::VaultError,
9    object::{Metadata, Object, ObjectId},
10    origin::{ByteStream, Origin},
11};
12
13/// An [`crate::origin::Origin`] backed by a directory on disk, via `tokio::fs`. `ObjectId`s
14/// are relative paths resolved against `root`.
15///
16/// # Examples
17///
18/// ```
19/// use nimbus_vault::{
20///     object::{Metadata, Object, ObjectId},
21///     origin::{Origin, fs::OriginFileSystem},
22/// };
23///
24/// # #[tokio::main]
25/// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
26/// let dir = tempfile::tempdir()?;
27/// let origin = OriginFileSystem::new(dir.path().to_path_buf());
28///
29/// let mut file = Object::Leaf {
30///     name: "notes.txt".to_string(),
31///     id: ObjectId::from("notes.txt"),
32///     meta: Metadata::new(),
33/// };
34/// origin.put(&mut file, &ObjectId::from("")).await?; // creates the file
35/// assert!(dir.path().join("notes.txt").is_file());
36///
37/// let fetched = origin.get(&ObjectId::from("notes.txt")).await?;
38/// assert!(matches!(fetched, Object::Leaf { .. }));
39/// # Ok(())
40/// # }
41/// ```
42///
43/// Declaratively, via `[origin_config]` in a vault's TOML config:
44///
45/// ```toml
46/// [origin_config]
47/// type = "fs"
48/// root = "/srv/data"
49/// ```
50pub struct OriginFileSystem {
51    root: PathBuf,
52}
53impl OriginFileSystem {
54    /// Builds an `OriginFileSystem` rooted at `root`; every `ObjectId` is resolved relative
55    /// to it.
56    pub fn new(root: PathBuf) -> Self {
57        OriginFileSystem { root }
58    }
59    fn relative(id: &ObjectId) -> String {
60        let id_str = id.to_string();
61        id_str
62            .strip_prefix('/')
63            .unwrap_or(&id_str)
64            .trim_end_matches('/')
65            .to_string()
66    }
67
68    fn path(&self, id: &ObjectId) -> PathBuf {
69        let relative = Self::relative(id);
70        if relative.is_empty() {
71            self.root.clone()
72        } else {
73            self.root.join(relative)
74        }
75    }
76
77    fn child_id(parent: &ObjectId, name: &str) -> ObjectId {
78        let parent_relative = Self::relative(parent);
79        if parent_relative.is_empty() {
80            ObjectId::from(name)
81        } else {
82            ObjectId::from(format!("{parent_relative}/{name}"))
83        }
84    }
85}
86
87#[async_trait::async_trait]
88impl Origin for OriginFileSystem {
89    async fn get(&self, id: &ObjectId) -> VaultResult<Object> {
90        let path = self.path(id);
91        let meta = match fs::metadata(&path).await {
92            Ok(meta) => meta,
93            Err(_) => fs::symlink_metadata(&path)
94                .await
95                .map_err(|_| VaultError::NotFound(id.to_string()))?,
96        };
97        let name = path
98            .file_name()
99            .map(|s| s.to_string_lossy().to_string())
100            .unwrap_or_else(|| id.to_string());
101        let modified = meta
102            .modified()
103            .map(chrono::DateTime::<chrono::Utc>::from)
104            .map_err(|_| VaultError::OriginError("Failed to get modified time".to_string()))?;
105        let metadata = Metadata {
106            size: Some(meta.len()),
107            content_type: None,
108            modified: Some(modified),
109            extra: Default::default(),
110        };
111        let object = match meta.is_dir() {
112            true => Object::Branch {
113                id: id.clone(),
114                name,
115                meta: metadata,
116                children: None,
117            },
118            false => Object::Leaf {
119                id: id.clone(),
120                name,
121                meta: metadata,
122            },
123        };
124
125        Ok(object)
126    }
127
128    async fn list(&self, id: &ObjectId) -> VaultResult<Vec<Object>> {
129        let path = self.path(id);
130        let mut entries = fs::read_dir(&path)
131            .await
132            .map_err(|_| VaultError::NotFound(id.to_string()))?;
133
134        let mut objects: Vec<Object> = Vec::new();
135
136        while let Some(entry) = entries
137            .next_entry()
138            .await
139            .map_err(|_| VaultError::OriginError("Failed to read directory entry".to_string()))?
140        {
141            let name = entry.file_name().to_string_lossy().into_owned();
142            let child_id = Self::child_id(id, &name);
143            objects.push(self.get(&child_id).await?);
144        }
145        Ok(objects)
146    }
147
148    async fn fetch(&self, id: &ObjectId) -> VaultResult<ByteStream> {
149        let path = self.path(id);
150        let file = fs::OpenOptions::new()
151            .read(true)
152            .open(&path)
153            .await
154            .map_err(|_| VaultError::NotFound(id.to_string()))?;
155        let stream = ReaderStream::new(file).map(|chunk| {
156            chunk.map_err(|e| VaultError::OriginError(format!("Failed to read file: {}", e)))
157        });
158        Ok(Box::pin(stream))
159    }
160
161    async fn put(&self, object: &mut Object, destination: &ObjectId) -> VaultResult<Object> {
162        let parent_path = self.path(destination);
163        let path = parent_path.join(object.get_name());
164        let new_id = Self::child_id(destination, &object.get_name());
165        let _ = object.with_id(new_id);
166
167        match object {
168            Object::Branch { .. } => {
169                fs::create_dir_all(&path).await.map_err(|e| {
170                    VaultError::OriginError(format!("Failed to create directory: {}", e))
171                })?;
172            }
173            Object::Leaf { .. } => {
174                fs::File::create(&path).await.map_err(|e| {
175                    VaultError::OriginError(format!("Failed to create file: {}", e))
176                })?;
177            }
178            Object::Root { .. } => Err(VaultError::OriginError(
179                "Cannot put root object".to_string(),
180            ))?,
181        }
182        Ok(object.clone())
183    }
184
185    async fn send(&self, object: &Object, mut payload: ByteStream) -> VaultResult<()> {
186        use tokio::io::AsyncWriteExt;
187        let id = object.get_id();
188        let path = self.path(&id);
189
190        let mut file = OpenOptions::new()
191            .write(true)
192            .create(true)
193            .truncate(true)
194            .open(&path)
195            .await
196            .map_err(|e| {
197                VaultError::OriginError(format!("Failed to open file for writing: {}", e))
198            })?;
199
200        while let Some(chunk) = payload.next().await {
201            let bytes = chunk?;
202            file.write_all(&bytes)
203                .await
204                .map_err(|e| VaultError::OriginError(format!("Failed to write to file: {}", e)))?;
205        }
206
207        // `tokio::fs::File` buffers, and its `Drop` only kicks off a best-effort background
208        // flush — so without this the bytes aren't guaranteed to be on disk when `send` returns
209        // and a read straight afterwards can come back short or empty.
210        file.flush()
211            .await
212            .map_err(|e| VaultError::OriginError(format!("Failed to flush file: {}", e)))?;
213        Ok(())
214    }
215
216    async fn delete(&self, id: &ObjectId) -> VaultResult<()> {
217        let path = self.path(id);
218
219        let meta = fs::metadata(&path)
220            .await
221            .map_err(|_| VaultError::NotFound(id.to_string()))?;
222
223        match meta.is_dir() {
224            true => fs::remove_dir_all(&path)
225                .await
226                .map_err(|e| VaultError::OriginError(format!("Failed to remove directory: {}", e))),
227            false => fs::remove_file(&path)
228                .await
229                .map_err(|e| VaultError::OriginError(format!("Failed to remove file: {}", e))),
230        }
231    }
232}
233
234#[cfg(test)]
235#[path = "tests/fs.rs"]
236mod tests;