zephyrfs-node Public

Watch 0 Fork 0 Star 0
Rust · 9401 bytes Raw Blame History
1 use anyhow::{Context, Result};
2 use rocksdb::{DB, Options, WriteBatch};
3 use serde::{Deserialize, Serialize};
4 use std::collections::HashMap;
5 use std::path::Path;
6 use std::sync::Arc;
7 use tokio::sync::RwLock;
8 use tracing::{debug, info, warn};
9
10 /// File metadata with comprehensive tracking
11 ///
12 /// Privacy: Only stores operational metadata, not file contents
13 #[derive(Debug, Clone, Serialize, Deserialize)]
14 pub struct FileMetadata {
15 /// Original filename (encrypted if privacy mode enabled)
16 pub name: String,
17
18 /// File size in bytes
19 pub size: u64,
20
21 /// MIME type detection
22 pub mime_type: Option<String>,
23
24 /// SHA-256 hash of complete file
25 pub file_hash: String,
26
27 /// List of chunk IDs that comprise this file
28 pub chunk_ids: Vec<String>,
29
30 /// Creation timestamp
31 pub created_at: u64,
32
33 /// Last modified timestamp
34 pub modified_at: u64,
35
36 /// Access permissions (future use)
37 pub permissions: u32,
38
39 /// Integrity checksum for metadata verification
40 pub checksum: String,
41 }
42
43 /// Thread-safe metadata storage using RocksDB
44 ///
45 /// Safety: All operations include integrity checks and atomic updates
46 /// Transparency: All metadata operations are logged for audit
47 /// Privacy: Supports encrypted filename storage
48 pub struct MetadataStore {
49 /// RocksDB instance for file metadata
50 db: Arc<DB>,
51
52 /// In-memory cache for frequently accessed metadata
53 metadata_cache: Arc<RwLock<HashMap<String, FileMetadata>>>,
54 }
55
56 impl MetadataStore {
57 /// Create a new MetadataStore with secure configuration
58 ///
59 /// Safety: Creates database with paranoid checks enabled
60 pub fn new<P: AsRef<Path>>(db_path: P) -> Result<Self> {
61 info!("Initializing MetadataStore with security-focused configuration");
62
63 let mut opts = Options::default();
64 opts.create_if_missing(true);
65 opts.set_paranoid_checks(true); // Safety: Enable paranoid consistency checks
66 opts.set_use_fsync(true); // Safety: Force fsync for durability
67
68 let db = DB::open(&opts, db_path)
69 .context("Failed to open metadata database")?;
70
71 let store = Self {
72 db: Arc::new(db),
73 metadata_cache: Arc::new(RwLock::new(HashMap::new())),
74 };
75
76 info!("MetadataStore initialized successfully");
77 Ok(store)
78 }
79
80 /// Store file metadata with integrity verification
81 ///
82 /// Safety: Includes checksum verification and atomic operations
83 /// Transparency: All operations logged with file hashes
84 pub async fn store_metadata(&self, file_id: &str, mut metadata: FileMetadata) -> Result<()> {
85 debug!("Storing metadata for file: {} ({})", file_id, metadata.name);
86
87 // Calculate integrity checksum
88 metadata.checksum = self.calculate_metadata_checksum(&metadata);
89
90 // Update timestamp
91 metadata.modified_at = std::time::SystemTime::now()
92 .duration_since(std::time::UNIX_EPOCH)?
93 .as_secs();
94
95 // Serialize metadata
96 let metadata_bytes = bincode::serialize(&metadata)
97 .context("Failed to serialize file metadata")?;
98
99 // Store in database
100 let key = format!("file:{}", file_id);
101 self.db.put(&key, metadata_bytes)
102 .context("Failed to store metadata in database")?;
103
104 // Update cache
105 {
106 let mut cache = self.metadata_cache.write().await;
107 cache.insert(file_id.to_string(), metadata.clone());
108 }
109
110 info!("Successfully stored metadata for file: {} with hash: {}",
111 file_id, metadata.file_hash);
112 Ok(())
113 }
114
115 /// Retrieve file metadata with integrity verification
116 ///
117 /// Safety: Verifies checksum before returning metadata
118 /// Transparency: Cache hits/misses are tracked and logged
119 pub async fn get_metadata(&self, file_id: &str) -> Result<Option<FileMetadata>> {
120 debug!("Retrieving metadata for file: {}", file_id);
121
122 // Check cache first
123 {
124 let cache = self.metadata_cache.read().await;
125 if let Some(metadata) = cache.get(file_id) {
126 debug!("Cache hit for metadata: {}", file_id);
127 return Ok(Some(metadata.clone()));
128 }
129 }
130
131 // Load from database
132 let key = format!("file:{}", file_id);
133 let metadata_bytes = match self.db.get(&key)? {
134 Some(bytes) => bytes,
135 None => {
136 debug!("Metadata not found for file: {}", file_id);
137 return Ok(None);
138 }
139 };
140
141 // Deserialize metadata
142 let metadata: FileMetadata = bincode::deserialize(&metadata_bytes)
143 .context("Failed to deserialize file metadata")?;
144
145 // Verify integrity
146 if !self.verify_metadata_integrity(&metadata)? {
147 warn!("Metadata integrity verification failed for file: {}", file_id);
148 return Err(anyhow::anyhow!("Metadata integrity verification failed"));
149 }
150
151 // Update cache
152 {
153 let mut cache = self.metadata_cache.write().await;
154 cache.insert(file_id.to_string(), metadata.clone());
155 }
156
157 debug!("Successfully retrieved and verified metadata for file: {}", file_id);
158 Ok(Some(metadata))
159 }
160
161 /// Delete file metadata
162 ///
163 /// Safety: Atomic deletion with comprehensive logging
164 pub async fn delete_metadata(&self, file_id: &str) -> Result<bool> {
165 debug!("Attempting to delete metadata for file: {}", file_id);
166
167 let key = format!("file:{}", file_id);
168
169 // Check if metadata exists
170 if self.db.get(&key)?.is_none() {
171 debug!("Cannot delete non-existent metadata: {}", file_id);
172 return Ok(false);
173 }
174
175 // Delete from database
176 self.db.delete(&key)
177 .context("Failed to delete metadata from database")?;
178
179 // Remove from cache
180 {
181 let mut cache = self.metadata_cache.write().await;
182 cache.remove(file_id);
183 }
184
185 info!("Successfully deleted metadata for file: {}", file_id);
186 Ok(true)
187 }
188
189 /// List all stored files with optional filtering
190 ///
191 /// Transparency: Provides comprehensive file listing for audit
192 pub async fn list_files(&self, limit: Option<usize>) -> Result<Vec<(String, FileMetadata)>> {
193 debug!("Listing stored files (limit: {:?})", limit);
194
195 let mut files = Vec::new();
196 let iter = self.db.iterator(rocksdb::IteratorMode::Start);
197
198 for (i, item) in iter.enumerate() {
199 if let Some(limit) = limit {
200 if i >= limit {
201 break;
202 }
203 }
204
205 let (key, value) = item?;
206 let key_str = String::from_utf8_lossy(&key);
207
208 // Only process file metadata keys
209 if !key_str.starts_with("file:") {
210 continue;
211 }
212
213 let file_id = key_str.strip_prefix("file:").unwrap().to_string();
214
215 match bincode::deserialize::<FileMetadata>(&value) {
216 Ok(metadata) => {
217 if self.verify_metadata_integrity(&metadata)? {
218 files.push((file_id, metadata));
219 } else {
220 warn!("Skipping file with corrupted metadata: {}", file_id);
221 }
222 }
223 Err(e) => {
224 warn!("Failed to deserialize metadata for {}: {}", file_id, e);
225 }
226 }
227 }
228
229 debug!("Retrieved {} files", files.len());
230 Ok(files)
231 }
232
233 /// Check if file metadata exists
234 pub async fn file_exists(&self, file_id: &str) -> Result<bool> {
235 // Check cache first
236 {
237 let cache = self.metadata_cache.read().await;
238 if cache.contains_key(file_id) {
239 return Ok(true);
240 }
241 }
242
243 // Check database
244 let key = format!("file:{}", file_id);
245 Ok(self.db.get(&key)?.is_some())
246 }
247
248 /// Calculate checksum for metadata integrity verification
249 fn calculate_metadata_checksum(&self, metadata: &FileMetadata) -> String {
250 let mut hasher = blake3::Hasher::new();
251 hasher.update(metadata.name.as_bytes());
252 hasher.update(&metadata.size.to_le_bytes());
253 hasher.update(metadata.file_hash.as_bytes());
254 hasher.update(&metadata.created_at.to_le_bytes());
255 hasher.update(&metadata.permissions.to_le_bytes());
256
257 // Include chunk IDs in checksum
258 for chunk_id in &metadata.chunk_ids {
259 hasher.update(chunk_id.as_bytes());
260 }
261
262 hex::encode(hasher.finalize().as_bytes())
263 }
264
265 /// Verify metadata integrity using checksum
266 ///
267 /// Safety: Prevents use of corrupted metadata
268 fn verify_metadata_integrity(&self, metadata: &FileMetadata) -> Result<bool> {
269 let computed_checksum = self.calculate_metadata_checksum(metadata);
270 Ok(computed_checksum == metadata.checksum)
271 }
272 }