Rename project to quicnprotochat

crates/quicnprotochat-server/src/storage.rs

@@ -0,0 +1,114 @@
+use std::{
+    collections::{HashMap, VecDeque},
+    fs,
+    path::{Path, PathBuf},
+    sync::Mutex,
+};
+
+use serde::{Deserialize, Serialize};
+
+#[derive(thiserror::Error, Debug)]
+pub enum StorageError {
+    #[error("io error: {0}")]
+    Io(String),
+    #[error("serialization error")]
+    Serde,
+}
+
+#[derive(Serialize, Deserialize, Default)]
+struct QueueMap {
+    map: HashMap<Vec<u8>, VecDeque<Vec<u8>>>,
+}
+
+/// File-backed storage for KeyPackages and delivery queues.
+///
+/// Each mutation flushes the entire map to disk. Suitable for MVP-scale loads.
+pub struct FileBackedStore {
+    kp_path: PathBuf,
+    ds_path: PathBuf,
+    key_packages: Mutex<HashMap<Vec<u8>, VecDeque<Vec<u8>>>>,
+    deliveries: Mutex<HashMap<Vec<u8>, VecDeque<Vec<u8>>>>,
+}
+
+impl FileBackedStore {
+    pub fn open(dir: impl AsRef<Path>) -> Result<Self, StorageError> {
+        let dir = dir.as_ref();
+        if !dir.exists() {
+            fs::create_dir_all(dir).map_err(|e| StorageError::Io(e.to_string()))?;
+        }
+        let kp_path = dir.join("keypackages.bin");
+        let ds_path = dir.join("deliveries.bin");
+
+        let key_packages = Mutex::new(Self::load_map(&kp_path)?);
+        let deliveries = Mutex::new(Self::load_map(&ds_path)?);
+
+        Ok(Self {
+            kp_path,
+            ds_path,
+            key_packages,
+            deliveries,
+        })
+    }
+
+    pub fn upload_key_package(
+        &self,
+        identity_key: &[u8],
+        package: Vec<u8>,
+    ) -> Result<(), StorageError> {
+        let mut map = self.key_packages.lock().unwrap();
+        map.entry(identity_key.to_vec())
+            .or_default()
+            .push_back(package);
+        self.flush_map(&self.kp_path, &*map)
+    }
+
+    pub fn fetch_key_package(&self, identity_key: &[u8]) -> Result<Option<Vec<u8>>, StorageError> {
+        let mut map = self.key_packages.lock().unwrap();
+        let package = map.get_mut(identity_key).and_then(|q| q.pop_front());
+        self.flush_map(&self.kp_path, &*map)?;
+        Ok(package)
+    }
+
+    pub fn enqueue(&self, recipient_key: &[u8], payload: Vec<u8>) -> Result<(), StorageError> {
+        let mut map = self.deliveries.lock().unwrap();
+        map.entry(recipient_key.to_vec())
+            .or_default()
+            .push_back(payload);
+        self.flush_map(&self.ds_path, &*map)
+    }
+
+    pub fn fetch(&self, recipient_key: &[u8]) -> Result<Vec<Vec<u8>>, StorageError> {
+        let mut map = self.deliveries.lock().unwrap();
+        let messages = map
+            .get_mut(recipient_key)
+            .map(|q| q.drain(..).collect())
+            .unwrap_or_default();
+        self.flush_map(&self.ds_path, &*map)?;
+        Ok(messages)
+    }
+
+    fn load_map(path: &Path) -> Result<HashMap<Vec<u8>, VecDeque<Vec<u8>>>, StorageError> {
+        if !path.exists() {
+            return Ok(HashMap::new());
+        }
+        let bytes = fs::read(path).map_err(|e| StorageError::Io(e.to_string()))?;
+        if bytes.is_empty() {
+            return Ok(HashMap::new());
+        }
+        let map: QueueMap = bincode::deserialize(&bytes).map_err(|_| StorageError::Serde)?;
+        Ok(map.map)
+    }
+
+    fn flush_map(
+        &self,
+        path: &Path,
+        map: &HashMap<Vec<u8>, VecDeque<Vec<u8>>>,
+    ) -> Result<(), StorageError> {
+        let payload = QueueMap { map: map.clone() };
+        let bytes = bincode::serialize(&payload).map_err(|_| StorageError::Serde)?;
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent).map_err(|e| StorageError::Io(e.to_string()))?;
+        }
+        fs::write(path, bytes).map_err(|e| StorageError::Io(e.to_string()))
+    }
+}