nimbus_vault/origin/
fs.rs1use 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
13pub struct OriginFileSystem {
51 root: PathBuf,
52}
53impl OriginFileSystem {
54 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 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;