hyprstream_core/services/
kata_9p_backend.rs1use std::sync::atomic::AtomicU32;
24
25use async_trait::async_trait;
26use dashmap::DashMap;
27use hyprstream_9p::backend::{Backend, OpenResult, StatResult, WalkResult};
28use hyprstream_9p::msg::Qid;
29
30use hyprstream_rpc_std::model_client::{ModelClient, ModelFsClient};
31use hyprstream_rpc_std::model_client::{
32 NpClunk, NpOpen, NpRead, NpStatReq, NpWalk, NpWrite, ROpen, RStat, RWalk,
33};
34
35#[derive(Clone, Debug)]
37struct ModelFidState {
38 model_ref: String,
40}
41
42pub struct ModelBackend {
48 client: ModelClient,
49 rt: tokio::runtime::Runtime,
50 fids: DashMap<u32, ModelFidState>,
52 #[allow(dead_code)]
56 next_path_id: AtomicU32,
57}
58
59impl ModelBackend {
60 #[allow(clippy::expect_used)] pub fn new(client: ModelClient) -> Self {
64 let rt = tokio::runtime::Builder::new_current_thread()
65 .enable_all()
66 .build()
67 .expect("failed to create tokio runtime for ModelBackend");
68 Self {
69 client,
70 rt,
71 fids: DashMap::new(),
72 next_path_id: AtomicU32::new(1),
73 }
74 }
75
76 fn fs_client(&self, model_ref: &str) -> ModelFsClient {
78 self.client.fs(model_ref)
79 }
80}
81
82fn qid_from_rpc(q: &hyprstream_rpc_std::model_client::Qid) -> Qid {
83 Qid {
84 qtype: q.qtype,
85 version: q.version,
86 path: q.path,
87 }
88}
89
90#[async_trait]
91impl Backend for ModelBackend {
92 async fn walk(
93 &self,
94 fid: u32,
95 newfid: u32,
96 components: &[String],
97 ) -> anyhow::Result<WalkResult> {
98 if components.len() > 1 {
99 anyhow::bail!("ModelBackend only supports single-name walks; refusing an ambiguous multi-name binding");
100 }
101 let (model_ref, wnames): (String, Vec<String>) = if components.is_empty() {
104 let mr = self
106 .fids
107 .get(&fid)
108 .map(|s| s.model_ref.clone())
109 .ok_or_else(|| anyhow::anyhow!("walk: source fid {fid} has no model_ref"))?;
110 (mr, Vec::new())
111 } else if let Some(state) = self.fids.get(&fid) {
112 (state.model_ref.clone(), components.to_vec())
115 } else {
116 let model_ref = components[0].clone();
118 let rest = components[1..].to_vec();
119 (model_ref, rest)
120 };
121
122 let fs = self.fs_client(&model_ref);
124 let req = NpWalk {
125 fid,
126 newfid,
127 wnames,
128 };
129 let RWalk { qid, .. } = self.rt.block_on(fs.walk(&req))?;
130 self.fids.insert(newfid, ModelFidState { model_ref });
131
132 Ok(WalkResult {
133 qids: vec![qid_from_rpc(&qid)],
134 reached: components.to_vec(),
135 })
136 }
137
138 async fn open(&self, fid: u32, flags: u32) -> anyhow::Result<OpenResult> {
139 let state = self
140 .fids
141 .get(&fid)
142 .ok_or_else(|| anyhow::anyhow!("open: fid {fid} not walked"))?
143 .clone();
144 let fs = self.fs_client(&state.model_ref);
145 let mode = lopen_flags_to_mode(flags);
149 let req = NpOpen { fid, mode };
150 let ROpen { qid, iounit } = self.rt.block_on(fs.open(&req))?;
151 Ok(OpenResult {
152 qid: qid_from_rpc(&qid),
153 iounit,
154 })
155 }
156
157 async fn read(&self, fid: u32, offset: u64, count: u32) -> anyhow::Result<Vec<u8>> {
158 let state = self
159 .fids
160 .get(&fid)
161 .ok_or_else(|| anyhow::anyhow!("read: fid {fid} not walked"))?
162 .clone();
163 let fs = self.fs_client(&state.model_ref);
164 let req = NpRead { fid, offset, count };
165 let result = self.rt.block_on(fs.read(&req))?;
166 Ok(result.data)
167 }
168
169 async fn write(&self, fid: u32, offset: u64, data: &[u8]) -> anyhow::Result<u32> {
170 let state = self
171 .fids
172 .get(&fid)
173 .ok_or_else(|| anyhow::anyhow!("write: fid {fid} not walked"))?
174 .clone();
175 let fs = self.fs_client(&state.model_ref);
176 let req = NpWrite {
177 fid,
178 offset,
179 data: data.to_vec(),
180 };
181 let result = self.rt.block_on(fs.write(&req))?;
182 Ok(result.count)
183 }
184
185 async fn stat(&self, fid: u32) -> anyhow::Result<StatResult> {
186 let state = self
187 .fids
188 .get(&fid)
189 .ok_or_else(|| anyhow::anyhow!("stat: fid {fid} not walked"))?
190 .clone();
191 let fs = self.fs_client(&state.model_ref);
192 let req = NpStatReq { fid };
193 let RStat { stat } = self.rt.block_on(fs.stat(&req))?;
194 Ok(StatResult {
195 qid: qid_from_rpc(&stat.qid),
196 mode: stat.mode,
197 size: stat.length,
198 mtime_sec: stat.mtime as u64,
199 })
200 }
201
202 async fn readdir(&self, fid: u32, offset: u64, count: u32) -> anyhow::Result<Vec<u8>> {
203 self.read(fid, offset, count).await
207 }
208
209 async fn clunk(&self, fid: u32) -> anyhow::Result<()> {
210 if let Some((_, state)) = self.fids.remove(&fid) {
212 let fs = self.fs_client(&state.model_ref);
213 let req = NpClunk { fid };
214 let _ = self.rt.block_on(fs.clunk(&req));
215 }
216 Ok(())
217 }
218}
219
220fn lopen_flags_to_mode(flags: u32) -> u8 {
225 const O_WRONLY: u32 = 0o1;
226 const O_RDWR: u32 = 0o2;
227 let acc = flags & 0o3;
228 match acc {
229 O_WRONLY => 1, O_RDWR => 2, _ => 0, }
233}
234
235#[cfg(test)]
236mod tests {
237 use super::*;
238
239 #[test]
240 fn lopen_flags_mapping() {
241 assert_eq!(lopen_flags_to_mode(0), 0); assert_eq!(lopen_flags_to_mode(0o1), 1); assert_eq!(lopen_flags_to_mode(0o2), 2); assert_eq!(lopen_flags_to_mode(0o100), 0); assert_eq!(lopen_flags_to_mode(0o101), 1); }
247}