1use casbin::{Adapter, FileAdapter, Filter, Model};
4use std::path::PathBuf;
5use tokio::io::AsyncWriteExt as _;
6
7pub(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 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 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_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}