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

ambee/giterated

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

Please fix

View files Patch

Amber - ⁨2⁩ years ago

parent: tbd commit: ⁨2c88faf⁩

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