JavaScript is disabled, refresh for a better experience. ambee/giterated

ambee/giterated

Git repository hosting, collaboration, and discovery for the Fediverse.

Fix handling stack

View files Patch

Amber - ⁨2⁩ years ago

parent: tbd commit: ⁨c53b026⁩

⁨giterated-daemon/src/database_backend/handler.rs⁩ - ⁨11249⁩ bytes
Raw
1 use std::{collections::HashMap, error::Error, pin::Pin, sync::Arc};
2
3 use futures_util::{future::BoxFuture, Future, FutureExt};
4 use giterated_models::{
5 error::{GetValueError, OperationError, RepositoryError, UserError},
6 object::{AnyObject, GiteratedObject},
7 object_backend::ObjectBackend,
8 operation::{AnyOperation, GiteratedOperation},
9 repository::{
10 DefaultBranch, Description, LatestCommit, Repository, RepositoryFileInspectRequest,
11 RepositoryInfoRequest, RepositorySummary, RepositoryView, Visibility,
12 },
13 settings::{AnySetting, GetSetting, GetSettingError, SetSetting, SetSettingError},
14 user::{User, UserRepositoriesRequest},
15 value::{AnyValue, GetValue},
16 };
17
18 use super::DatabaseBackend;
19
20 #[async_trait::async_trait]
21 pub trait GiteratedOperationHandler<
22 O: GiteratedObject,
23 D: GiteratedOperation<O>,
24 S: Send + Sync + Clone,
25 >
26 {
27 fn operation_name(&self) -> &str;
28 fn object_name(&self) -> &str;
29
30 async fn handle(
31 &self,
32 object: &O,
33 operation: D,
34 state: S,
35 ) -> Result<D::Success, OperationError<D::Failure>>;
36 }
37
38 #[async_trait::async_trait]
39 impl<O, D, F, S> GiteratedOperationHandler<O, D, S> for F
40 where
41 F: FnMut(
42 &O,
43 D,
44 S,
45 ) -> Pin<
46 Box<dyn Future<Output = Result<D::Success, OperationError<D::Failure>>> + Send>,
47 > + Send
48 + Sync
49 + Clone,
50 O: GiteratedObject + Send + Sync,
51 D: GiteratedOperation<O> + 'static,
52 <D as GiteratedOperation<O>>::Failure: Send,
53 S: Send + Sync + Clone + 'static,
54 {
55 fn operation_name(&self) -> &str {
56 D::operation_name()
57 }
58
59 fn object_name(&self) -> &str {
60 O::object_name()
61 }
62
63 async fn handle(
64 &self,
65 object: &O,
66 operation: D,
67 state: S,
68 ) -> Result<D::Success, OperationError<D::Failure>> {
69 self.clone()(object, operation, state).await
70 }
71 }
72
73 pub struct OperationWrapper<S: Send + Sync + Clone>(
74 Box<
75 dyn Fn(
76 AnyObject,
77 AnyOperation,
78 S,
79 )
80 -> Pin<Box<dyn Future<Output = Result<Vec<u8>, OperationError<Vec<u8>>>> + Send>>
81 + Send
82 + Sync,
83 >,
84 );
85
86 impl<S: Send + Sync + Clone + 'static> OperationWrapper<S> {
87 pub fn new<
88 O: GiteratedObject + Send + Sync,
89 D: GiteratedOperation<O> + 'static,
90 F: GiteratedOperationHandler<O, D, S> + Send + Sync + 'static + Clone,
91 >(
92 handler: F,
93 ) -> Self {
94 let handler = Arc::new(Box::pin(handler));
95 Self(Box::new(move |any_object, any_operation, state| {
96 let handler = handler.clone();
97 async move {
98 let handler = handler.clone();
99 let object: O = O::from_object_str(&any_object.0).unwrap();
100 let operation: D = serde_json::from_value(any_operation.0.clone()).unwrap();
101
102 let result = handler.handle(&object, operation, state).await;
103 result
104 .map(|success| serde_json::to_vec(&success).unwrap())
105 .map_err(|err| match err {
106 OperationError::Operation(err) => {
107 OperationError::Operation(serde_json::to_vec(&err).unwrap())
108 }
109 OperationError::Internal(internal) => OperationError::Internal(internal),
110 OperationError::Unhandled => OperationError::Unhandled,
111 })
112 }
113 .boxed()
114 }))
115 }
116
117 async fn handle(
118 &mut self,
119 object: AnyObject,
120 operation: AnyOperation,
121 state: S,
122 ) -> Result<Vec<u8>, OperationError<Vec<u8>>> {
123 self.0(object, operation, state).await
124 }
125 }
126
127 pub fn user_get_repositories(
128 object: &User,
129 _operation: UserRepositoriesRequest,
130 state: DatabaseBackend,
131 ) -> BoxFuture<'static, Result<Vec<RepositorySummary>, OperationError<UserError>>> {
132 let object = object.clone();
133
134 async move {
135 let mut user_backend = state.user_backend.lock().await;
136 let repositories = user_backend
137 .repositories_for_user(None, &object)
138 .await
139 .map_err(|e| OperationError::Internal(e.to_string()))?;
140
141 Ok(repositories)
142 }
143 .boxed()
144 }
145
146 pub fn user_get_value(
147 object: &User,
148 operation: GetValue<AnyValue<User>>,
149 state: DatabaseBackend,
150 ) -> BoxFuture<'static, Result<AnyValue<User>, OperationError<GetValueError>>> {
151 let object = object.clone();
152
153 async move {
154 let mut user_backend = state.user_backend.lock().await;
155 let value = user_backend
156 .get_value(&object, &operation.value_name)
157 .await
158 .map_err(|e| OperationError::Internal(e.to_string()))?;
159
160 Ok(value)
161 }
162 .boxed()
163 }
164
165 pub fn user_get_setting(
166 object: &User,
167 operation: GetSetting<AnySetting>,
168 state: DatabaseBackend,
169 ) -> BoxFuture<'static, Result<AnySetting, OperationError<GetSettingError>>> {
170 let object = object.clone();
171
172 async move {
173 let mut user_backend = state.user_backend.lock().await;
174 let value = user_backend
175 .get_setting(&object, &operation.setting_name)
176 .await
177 .map_err(|e| OperationError::Internal(e.to_string()))?;
178
179 Ok(value)
180 }
181 .boxed()
182 }
183
184 pub fn user_set_setting(
185 object: &User,
186 operation: SetSetting<AnySetting>,
187 state: DatabaseBackend,
188 ) -> BoxFuture<'static, Result<(), OperationError<SetSettingError>>> {
189 let object = object.clone();
190
191 async move {
192 let mut user_backend = state.user_backend.lock().await;
193 let value = user_backend
194 .write_setting(&object, &operation.setting_name, &operation.value.0)
195 .await
196 .map_err(|e| OperationError::Internal(e.to_string()))?;
197
198 Ok(value)
199 }
200 .boxed()
201 }
202
203 pub fn repository_info(
204 object: &Repository,
205 operation: RepositoryInfoRequest,
206 state: DatabaseBackend,
207 ) -> BoxFuture<'static, Result<RepositoryView, OperationError<RepositoryError>>> {
208 let object = object.clone();
209
210 async move {
211 let mut object = state
212 .get_object::<Repository>(&object.to_string())
213 .await
214 .unwrap();
215
216 let mut repository_backend = state.repository_backend.lock().await;
217 let tree = repository_backend
218 .repository_file_inspect(
219 None,
220 object.object(),
221 &RepositoryFileInspectRequest {
222 extra_metadata: operation.extra_metadata,
223 path: operation.path,
224 rev: operation.rev.clone(),
225 },
226 )
227 .await
228 .map_err(|err| OperationError::Internal(format!("{:?}", err)))?;
229 drop(repository_backend);
230
231 let _visibility = object.get::<Visibility>().await.map_err(|e| {
232 OperationError::Internal(format!("{:?}: {}", e.source(), e.to_string()))
233 })?;
234 let _default_branch = object.get::<DefaultBranch>().await.map_err(|e| {
235 OperationError::Internal(format!("{:?}: {}", e.source(), e.to_string()))
236 })?;
237
238 let info = RepositoryView {
239 name: object.object().name.clone(),
240 owner: object.object().owner.clone(),
241 description: object.get::<Description>().await.ok(),
242 visibility: object
243 .get::<Visibility>()
244 .await
245 .map_err(|e| OperationError::Internal(e.to_string()))?,
246 default_branch: object
247 .get::<DefaultBranch>()
248 .await
249 .map_err(|e| OperationError::Internal(e.to_string()))?,
250 // TODO: Can't be a simple get function, this needs to be returned alongside the tree as this differs depending on the rev and path.
251 latest_commit: object.get::<LatestCommit>().await.ok(),
252 tree_rev: operation.rev,
253 tree,
254 };
255
256 Ok(info)
257 }
258 .boxed()
259 }
260
261 pub fn repository_get_value(
262 object: &Repository,
263 operation: GetValue<AnyValue<Repository>>,
264 state: DatabaseBackend,
265 ) -> BoxFuture<'static, Result<AnyValue<Repository>, OperationError<GetValueError>>> {
266 let object = object.clone();
267
268 async move {
269 let mut repository_backend = state.repository_backend.lock().await;
270 let value = repository_backend
271 .get_value(&object, &operation.value_name)
272 .await
273 .map_err(|e| {
274 OperationError::Internal(format!("error getting value: {}", e.to_string()))
275 })?;
276
277 Ok(value)
278 }
279 .boxed()
280 }
281
282 pub fn repository_get_setting(
283 object: &Repository,
284 operation: GetSetting<AnySetting>,
285 state: DatabaseBackend,
286 ) -> BoxFuture<'static, Result<AnySetting, OperationError<GetSettingError>>> {
287 let object = object.clone();
288
289 async move {
290 let mut repository_backend = state.repository_backend.lock().await;
291 let value = repository_backend
292 .get_setting(&object, &operation.setting_name)
293 .await
294 .map_err(|e| OperationError::Internal(e.to_string()))?;
295
296 Ok(value)
297 }
298 .boxed()
299 }
300
301 pub fn repository_set_setting(
302 object: &Repository,
303 operation: SetSetting<AnySetting>,
304 state: DatabaseBackend,
305 ) -> BoxFuture<'static, Result<(), OperationError<SetSettingError>>> {
306 let object = object.clone();
307
308 async move {
309 let mut repository_backend = state.repository_backend.lock().await;
310 let value = repository_backend
311 .write_setting(&object, &operation.setting_name, &operation.value.0)
312 .await
313 .map_err(|e| OperationError::Internal(e.to_string()))?;
314
315 Ok(value)
316 }
317 .boxed()
318 }
319
320 pub struct OperationHandlers<S: Send + Sync + Clone> {
321 operations: HashMap<String, OperationWrapper<S>>,
322 }
323
324 impl<S: Send + Sync + Clone> Default for OperationHandlers<S> {
325 fn default() -> Self {
326 Self {
327 operations: HashMap::new(),
328 }
329 }
330 }
331
332 impl<S: Send + Sync + Clone + 'static> OperationHandlers<S> {
333 pub fn insert<
334 O: GiteratedObject + Send + Sync,
335 D: GiteratedOperation<O> + 'static,
336 H: GiteratedOperationHandler<O, D, S> + Send + Sync + 'static + Clone,
337 >(
338 &mut self,
339 handler: H,
340 ) -> &mut Self {
341 let operation_name = handler.operation_name().to_string();
342
343 let wrapped = OperationWrapper::new(handler);
344
345 self.operations.insert(operation_name, wrapped);
346
347 self
348 }
349
350 pub async fn handle<O: GiteratedObject>(
351 &mut self,
352 object: &O,
353 operation_name: &str,
354 operation: AnyOperation,
355 state: S,
356 ) -> Result<Vec<u8>, OperationError<Vec<u8>>> {
357 if let Some(handler) = self.operations.get_mut(operation_name) {
358 handler
359 .handle(AnyObject(object.to_string()), operation, state)
360 .await
361 } else {
362 Err(OperationError::Internal(format!(
363 "unknown operation: {}",
364 operation_name
365 )))
366 }
367 }
368 }
369