Skip to main content

hyprstream_core/auth/
policy_file_adapter.rs

1//! FileAdapter-compatible persistence that waits for the filesystem write.
2
3use casbin::{Adapter, FileAdapter, Filter, Model};
4use std::path::PathBuf;
5use tokio::io::AsyncWriteExt as _;
6
7/// Casbin's Tokio FileAdapter drops its file after write_all without flushing.
8/// Keep its parsing and incremental-operation behavior, but make full saves
9/// complete before a caller captures or reopens the policy file.
10pub(super) struct PolicyFileAdapter {
11    path: PathBuf,
12    inner: FileAdapter<PathBuf>,
13}
14
15impl PolicyFileAdapter {
16    pub(super) fn new(path: PathBuf) -> Self {
17        Self {
18            inner: FileAdapter::new(path.clone()),
19            path,
20        }
21    }
22
23    async fn write(&self, bytes: &[u8]) -> casbin::Result<()> {
24        let mut file = tokio::fs::File::create(&self.path).await?;
25        write_completed(&mut file, bytes).await?;
26        Ok(())
27    }
28}
29
30async fn write_completed(file: &mut tokio::fs::File, bytes: &[u8]) -> std::io::Result<()> {
31    file.write_all(bytes).await?;
32    // flush waits for Tokio's queued blocking write and propagates its errors.
33    // This is completion, not crash durability; publication still owns fsync.
34    file.flush().await
35}
36
37#[async_trait::async_trait]
38impl Adapter for PolicyFileAdapter {
39    async fn load_policy(&mut self, model: &mut dyn Model) -> casbin::Result<()> {
40        self.inner.load_policy(model).await
41    }
42
43    async fn load_filtered_policy<'a>(
44        &mut self,
45        model: &mut dyn Model,
46        filter: Filter<'a>,
47    ) -> casbin::Result<()> {
48        self.inner.load_filtered_policy(model, filter).await
49    }
50
51    async fn save_policy(&mut self, model: &mut dyn Model) -> casbin::Result<()> {
52        if self.path.as_os_str().is_empty() {
53            return Err(std::io::Error::other("save policy failed, file path is empty").into());
54        }
55        // Preserve FileAdapter's p/g sections, assertion names, row order,
56        // separators and absence of a trailing newline, including g2 domains.
57        let policies = model.get_model().get("p").ok_or_else(|| {
58            casbin::error::ModelError::P("Missing policy definition in conf file".to_owned())
59        })?;
60        let mut rows = Vec::new();
61        for (name, assertion) in policies
62            .iter()
63            .chain(model.get_model().get("g").into_iter().flatten())
64        {
65            for rule in assertion.get_policy() {
66                rows.push(format!("{name}, {}", rule.join(", ")));
67            }
68        }
69        self.write(rows.join("\n").as_bytes()).await
70    }
71
72    async fn clear_policy(&mut self) -> casbin::Result<()> {
73        self.write(&[]).await
74    }
75
76    fn is_filtered(&self) -> bool {
77        self.inner.is_filtered()
78    }
79
80    async fn add_policy(
81        &mut self,
82        sec: &str,
83        ptype: &str,
84        rule: Vec<String>,
85    ) -> casbin::Result<bool> {
86        self.inner.add_policy(sec, ptype, rule).await
87    }
88
89    async fn add_policies(
90        &mut self,
91        sec: &str,
92        ptype: &str,
93        rules: Vec<Vec<String>>,
94    ) -> casbin::Result<bool> {
95        self.inner.add_policies(sec, ptype, rules).await
96    }
97
98    async fn remove_policy(
99        &mut self,
100        sec: &str,
101        ptype: &str,
102        rule: Vec<String>,
103    ) -> casbin::Result<bool> {
104        self.inner.remove_policy(sec, ptype, rule).await
105    }
106
107    async fn remove_policies(
108        &mut self,
109        sec: &str,
110        ptype: &str,
111        rules: Vec<Vec<String>>,
112    ) -> casbin::Result<bool> {
113        self.inner.remove_policies(sec, ptype, rules).await
114    }
115
116    async fn remove_filtered_policy(
117        &mut self,
118        sec: &str,
119        ptype: &str,
120        index: usize,
121        values: Vec<String>,
122    ) -> casbin::Result<bool> {
123        self.inner
124            .remove_filtered_policy(sec, ptype, index, values)
125            .await
126    }
127}
128
129#[cfg(test)]
130#[allow(clippy::expect_used)]
131mod tests {
132    use super::*;
133
134    #[test]
135    fn policy_write_waits_for_blocking_io_completion() {
136        let runtime = tokio::runtime::Builder::new_current_thread()
137            .enable_all()
138            .max_blocking_threads(1)
139            .build()
140            .expect("runtime");
141        runtime.block_on(async {
142            let root = tempfile::tempdir().expect("policy directory");
143            let path = root.path().join("policy.csv");
144            let mut file = tokio::fs::File::create(&path).await.expect("policy file");
145            let (started_tx, started_rx) = std::sync::mpsc::channel();
146            let (release_tx, release_rx) = std::sync::mpsc::channel();
147            let blocker = tokio::task::spawn_blocking(move || {
148                started_tx.send(()).expect("started");
149                release_rx.recv().expect("release");
150            });
151            started_rx.recv().expect("sole blocking worker occupied");
152            let bytes = b"p, service:retained, *, model:*, ttt.writeback, deny";
153            let write = write_completed(&mut file, bytes);
154            tokio::pin!(write);
155            let first_poll = futures::poll!(&mut write);
156            let before_release = std::fs::read(&path).expect("read while write is queued");
157            // Release before asserting, so a failed old-behavior control cannot
158            // strand the runtime's sole blocking worker during teardown.
159            release_tx.send(()).expect("release worker");
160            blocker.await.expect("worker completed");
161            assert!(
162                first_poll.is_pending(),
163                "save returned before its filesystem write completed"
164            );
165            assert!(before_release.is_empty(), "write must still be queued");
166            write.await.expect("completed policy write");
167            assert_eq!(std::fs::read(path).expect("immediate read"), bytes);
168        });
169    }
170
171    #[cfg(target_os = "linux")]
172    #[tokio::test]
173    async fn policy_write_propagates_queued_io_error() {
174        let mut file = tokio::fs::OpenOptions::new()
175            .write(true)
176            .open("/dev/full")
177            .await
178            .expect("open failing write device");
179        let error = write_completed(&mut file, b"retained deny")
180            .await
181            .expect_err("queued filesystem error must propagate");
182        assert_eq!(error.raw_os_error(), Some(libc::ENOSPC));
183    }
184
185    #[tokio::test]
186    async fn policy_adapter_roundtrip_preserves_deny_and_both_groupings() {
187        use casbin::{CoreApi as _, DefaultModel, Enforcer, MgmtApi as _};
188        let root = tempfile::tempdir().expect("policy directory");
189        let path = root.path().join("policy.csv");
190        super::super::PolicyManager::new(root.path())
191            .await
192            .expect("initialize model");
193        let model_path = root.path().join("model.conf");
194        let model = DefaultModel::from_file(&model_path).await.expect("model");
195        let mut enforcer = Enforcer::new(model, casbin::MemoryAdapter::default())
196            .await
197            .expect("enforcer");
198        enforcer
199            .add_policy(
200                ["retained", "*", "model:*", "ttt.writeback", "deny"]
201                    .map(str::to_owned)
202                    .to_vec(),
203            )
204            .await
205            .expect("deny");
206        enforcer
207            .add_grouping_policy(["alice", "reader"].map(str::to_owned).to_vec())
208            .await
209            .expect("global grouping");
210        enforcer
211            .add_named_grouping_policy(
212                "g2",
213                ["bob", "reader", "tenant-a"].map(str::to_owned).to_vec(),
214            )
215            .await
216            .expect("domain grouping");
217        let mut adapter = PolicyFileAdapter::new(path.clone());
218        adapter
219            .save_policy(enforcer.get_mut_model())
220            .await
221            .expect("save");
222        let serialized = std::fs::read_to_string(&path).expect("immediate read");
223        assert_eq!(
224            serialized
225                .lines()
226                .collect::<std::collections::BTreeSet<_>>(),
227            [
228                "p, retained, *, model:*, ttt.writeback, deny",
229                "g, alice, reader",
230                "g2, bob, reader, tenant-a",
231            ]
232            .into_iter()
233            .collect()
234        );
235        assert!(!serialized.ends_with('\n'));
236        let model = DefaultModel::from_file(&model_path)
237            .await
238            .expect("reload model");
239        let reopened = Enforcer::new(model, PolicyFileAdapter::new(path.clone()))
240            .await
241            .expect("reopen");
242        assert_eq!(reopened.get_policy(), enforcer.get_policy());
243        assert_eq!(
244            reopened.get_grouping_policy(),
245            enforcer.get_grouping_policy()
246        );
247        assert_eq!(
248            reopened.get_named_grouping_policy("g2"),
249            enforcer.get_named_grouping_policy("g2")
250        );
251        adapter.clear_policy().await.expect("clear");
252        assert!(std::fs::read(path)
253            .expect("immediate clear read")
254            .is_empty());
255    }
256}