@feltdb/core 0.4.12 → 0.4.14

package/dist/create/server-source/crates/feltdb-server/src/leases.rs

@@ -0,0 +1,123 @@
+use serde::{Deserialize, Serialize};
+use std::{
+    collections::HashMap,
+    fs, io,
+    path::PathBuf,
+    sync::{Arc, Mutex},
+};
+
+#[derive(Clone, Serialize, Deserialize)]
+struct LeaseRecord {
+    claim_id: String,
+    owner: String,
+    expires_ms: u64,
+}
+
+#[derive(Clone)]
+pub struct LeaseStore {
+    path: Arc<PathBuf>,
+    records: Arc<Mutex<HashMap<String, LeaseRecord>>>,
+}
+
+impl LeaseStore {
+    pub fn load(path: PathBuf) -> io::Result<Self> {
+        let records = if path.exists() {
+            serde_json::from_slice(&fs::read(&path)?).map_err(io::Error::other)?
+        } else {
+            HashMap::new()
+        };
+        Ok(Self {
+            path: Arc::new(path),
+            records: Arc::new(Mutex::new(records)),
+        })
+    }
+
+    pub fn reserve(
+        &self,
+        resource: &str,
+        claim_id: &str,
+        owner: &str,
+        expires_ms: u64,
+        now: u64,
+    ) -> io::Result<bool> {
+        let mut records = self.records.lock().expect("lease lock poisoned");
+        records.retain(|_, lease| lease.expires_ms > now);
+        if records
+            .get(resource)
+            .is_some_and(|lease| lease.claim_id != claim_id)
+        {
+            return Ok(false);
+        }
+        records.insert(
+            resource.to_string(),
+            LeaseRecord {
+                claim_id: claim_id.to_string(),
+                owner: owner.to_string(),
+                expires_ms,
+            },
+        );
+        if let Some(parent) = self.path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        let temporary = self.path.with_extension("leases.tmp");
+        fs::write(
+            &temporary,
+            serde_json::to_vec(&*records).map_err(io::Error::other)?,
+        )?;
+        fs::rename(temporary, self.path.as_ref())?;
+        Ok(true)
+    }
+
+    pub fn holds(&self, resource: &str, claim_id: &str, now: u64) -> bool {
+        self.records
+            .lock()
+            .expect("lease lock poisoned")
+            .get(resource)
+            .is_some_and(|lease| lease.claim_id == claim_id && lease.expires_ms > now)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn promises_survive_restart_and_expire() {
+        let path = std::env::temp_dir().join(format!("feltdb-leases-{}.json", std::process::id()));
+        let _ = fs::remove_file(&path);
+        let store = LeaseStore::load(path.clone()).unwrap();
+        assert!(store
+            .reserve("work", "claim-a", "node-a", 2_000, 1_000)
+            .unwrap());
+        let reopened = LeaseStore::load(path.clone()).unwrap();
+        assert!(!reopened
+            .reserve("work", "claim-b", "node-b", 2_500, 1_500)
+            .unwrap());
+        assert!(reopened
+            .reserve("work", "claim-b", "node-b", 3_500, 2_500)
+            .unwrap());
+        let _ = fs::remove_file(path);
+    }
+
+    #[test]
+    fn owner_can_renew_but_a_competing_owner_cannot_publish_during_the_term() {
+        let path = std::env::temp_dir().join(format!(
+            "feltdb-lease-renew-{}-{}.json",
+            std::process::id(),
+            rand::random::<u64>()
+        ));
+        let store = LeaseStore::load(path.clone()).unwrap();
+        assert!(store
+            .reserve("execution", "term-1", "worker-a", 2_000, 1_000)
+            .unwrap());
+        assert!(store
+            .reserve("execution", "term-1", "worker-a", 3_000, 1_500)
+            .unwrap());
+        assert!(!store
+            .reserve("execution", "term-2", "worker-b", 3_500, 2_000)
+            .unwrap());
+        assert!(store.holds("execution", "term-1", 2_999));
+        assert!(!store.holds("execution", "term-1", 3_000));
+        let _ = fs::remove_file(path);
+    }
+}

package/dist/create/server-source/crates/feltdb-server/src/lib.rs

@@ -0,0 +1,25 @@
+pub mod app_state;
+pub mod application_contract;
+pub mod artifacts;
+pub mod audit;
+pub mod auth;
+pub mod authorization;
+pub mod backup;
+pub mod key_management;
+pub mod causal;
+pub mod certification;
+pub mod clock;
+pub mod cluster;
+pub mod connections;
+pub mod content;
+pub mod identity;
+pub mod key_provider;
+pub mod leases;
+pub mod metrics;
+pub mod portable_bundle;
+pub mod principals;
+pub mod providers;
+pub mod releases;
+pub mod sessions;
+pub mod tenancy;
+pub mod versions;