cyfs_lib/rmeta/
requestor.rs

1use super::def::*;
2use super::output_request::*;
3use super::processor::*;
4use crate::base::*;
5use crate::root_state::*;
6use crate::stack::SharedObjectStackDecID;
7use crate::requestor::*;
8use cyfs_base::*;
9
10use http_types::{Method, Request, Url};
11use std::sync::Arc;
12
13#[derive(Clone)]
14pub struct GlobalStateMetaRequestor {
15    category: GlobalStateCategory,
16    dec_id: Option<SharedObjectStackDecID>,
17    requestor: HttpRequestorRef,
18    service_url: Url,
19}
20
21impl GlobalStateMetaRequestor {
22    pub fn new_root_state(
23        dec_id: Option<SharedObjectStackDecID>,
24        requestor: HttpRequestorRef,
25    ) -> Self {
26        Self::new(GlobalStateCategory::RootState, dec_id, requestor)
27    }
28
29    pub fn new_local_cache(
30        dec_id: Option<SharedObjectStackDecID>,
31        requestor: HttpRequestorRef,
32    ) -> Self {
33        Self::new(GlobalStateCategory::LocalCache, dec_id, requestor)
34    }
35
36    pub fn new(
37        category: GlobalStateCategory,
38        dec_id: Option<SharedObjectStackDecID>,
39        requestor: HttpRequestorRef,
40    ) -> Self {
41        let addr = requestor.remote_addr();
42
43        let url = format!("http://{}/{}/meta/", addr, category.as_str());
44        let url = Url::parse(&url).unwrap();
45
46        let ret = Self {
47            category,
48            dec_id,
49            requestor,
50            service_url: url,
51        };
52
53        ret
54    }
55
56    pub fn category(&self) -> &GlobalStateCategory {
57        &self.category
58    }
59
60    pub fn into_processor(self) -> GlobalStateMetaOutputProcessorRef {
61        Arc::new(Box::new(self))
62    }
63
64    pub fn clone_processor(&self) -> GlobalStateMetaOutputProcessorRef {
65        self.clone().into_processor()
66    }
67
68    // TODO: 目前和request的body部分编码一部分冗余的信息
69    fn encode_common_headers(
70        &self,
71        action: MetaAction,
72        com_req: &MetaOutputRequestCommon,
73        http_req: &mut Request,
74    ) {
75        if let Some(dec_id) = &com_req.dec_id {
76            http_req.insert_header(cyfs_base::CYFS_DEC_ID, dec_id.to_string());
77        } else if let Some(dec_id) = &self.dec_id {
78            if let Some(dec_id) = dec_id.get() {
79                http_req.insert_header(cyfs_base::CYFS_DEC_ID, dec_id.to_string());
80            }
81        }
82
83        if let Some(target_dec_id) = &com_req.target_dec_id {
84            http_req.insert_header(cyfs_base::CYFS_TARGET_DEC_ID, target_dec_id.to_string());
85        }
86
87        if let Some(target) = &com_req.target {
88            http_req.insert_header(cyfs_base::CYFS_TARGET, target.to_string());
89        }
90
91        http_req.insert_header(cyfs_base::CYFS_FLAGS, com_req.flags.to_string());
92
93        http_req.insert_header(cyfs_base::CYFS_META_ACTION, action.to_string());
94    }
95
96    // global-state-meta add-access
97    fn encode_add_access_request(&self, req: &GlobalStateMetaAddAccessOutputRequest) -> Request {
98        let url = self.service_url.join("access").unwrap();
99        let mut http_req = Request::new(Method::Put, url);
100        self.encode_common_headers(MetaAction::GlobalStateAddAccess, &req.common, &mut http_req);
101
102        let value = serde_json::to_string(&req).unwrap();
103        http_req.set_body(value);
104        http_req
105    }
106
107    async fn add_access(
108        &self,
109        req: GlobalStateMetaAddAccessOutputRequest,
110    ) -> BuckyResult<GlobalStateMetaAddAccessOutputResponse> {
111        let http_req = self.encode_add_access_request(&req);
112        let mut resp = self.requestor.request(http_req).await?;
113
114        if resp.status().is_success() {
115            let resp: GlobalStateMetaAddAccessOutputResponse =
116                RequestorHelper::decode_serde_json_body(&mut resp).await?;
117            info!(
118                "global state meta add access success: req={:?}, resp={:?}",
119                req, resp,
120            );
121            Ok(resp)
122        } else {
123            let e = RequestorHelper::error_from_resp(&mut resp).await;
124            error!("global state meta add access error! req={:?}, {}", req, e);
125            Err(e)
126        }
127    }
128
129    // global-state-meta remove-access
130    fn encode_remove_access_request(
131        &self,
132        req: &GlobalStateMetaRemoveAccessOutputRequest,
133    ) -> Request {
134        let url = self.service_url.join("access").unwrap();
135        let mut http_req = Request::new(Method::Delete, url);
136        self.encode_common_headers(
137            MetaAction::GlobalStateRemoveAccess,
138            &req.common,
139            &mut http_req,
140        );
141
142        let value = serde_json::to_string(&req).unwrap();
143        http_req.set_body(value);
144        http_req
145    }
146
147    async fn remove_access(
148        &self,
149        req: GlobalStateMetaRemoveAccessOutputRequest,
150    ) -> BuckyResult<GlobalStateMetaRemoveAccessOutputResponse> {
151        let http_req = self.encode_remove_access_request(&req);
152        let mut resp = self.requestor.request(http_req).await?;
153
154        if resp.status().is_success() {
155            let resp: GlobalStateMetaRemoveAccessOutputResponse =
156                RequestorHelper::decode_serde_json_body(&mut resp).await?;
157            info!(
158                "global state meta remove access success: req={:?}, resp={:?}",
159                req, resp,
160            );
161            Ok(resp)
162        } else {
163            let e = RequestorHelper::error_from_resp(&mut resp).await;
164            error!(
165                "global state meta remove access error! req={:?}, {}",
166                req, e
167            );
168            Err(e)
169        }
170    }
171
172    // global-state-meta clear-access
173    fn encode_clear_access_request(
174        &self,
175        req: &GlobalStateMetaClearAccessOutputRequest,
176    ) -> Request {
177        let url = self.service_url.join("accesses").unwrap();
178        let mut http_req = Request::new(Method::Delete, url);
179        self.encode_common_headers(
180            MetaAction::GlobalStateClearAccess,
181            &req.common,
182            &mut http_req,
183        );
184
185        let value = serde_json::to_string(&req).unwrap();
186        http_req.set_body(value);
187        http_req
188    }
189
190    async fn clear_access(
191        &self,
192        req: GlobalStateMetaClearAccessOutputRequest,
193    ) -> BuckyResult<GlobalStateMetaClearAccessOutputResponse> {
194        let http_req = self.encode_clear_access_request(&req);
195        let mut resp = self.requestor.request(http_req).await?;
196
197        if resp.status().is_success() {
198            let resp: GlobalStateMetaClearAccessOutputResponse =
199                RequestorHelper::decode_serde_json_body(&mut resp).await?;
200            info!(
201                "global state meta clear access success: req={:?}, resp={:?}",
202                req, resp,
203            );
204            Ok(resp)
205        } else {
206            let e = RequestorHelper::error_from_resp(&mut resp).await;
207            error!("global state meta clear access error! req={:?}, {}", req, e);
208            Err(e)
209        }
210    }
211
212    // global-state-meta add-link
213    fn encode_add_link_request(&self, req: &GlobalStateMetaAddLinkOutputRequest) -> Request {
214        let url = self.service_url.join("link").unwrap();
215        let mut http_req = Request::new(Method::Put, url);
216        self.encode_common_headers(MetaAction::GlobalStateAddLink, &req.common, &mut http_req);
217
218        let value = serde_json::to_string(&req).unwrap();
219        http_req.set_body(value);
220        http_req
221    }
222
223    async fn add_link(
224        &self,
225        req: GlobalStateMetaAddLinkOutputRequest,
226    ) -> BuckyResult<GlobalStateMetaAddLinkOutputResponse> {
227        let http_req = self.encode_add_link_request(&req);
228        let mut resp = self.requestor.request(http_req).await?;
229
230        if resp.status().is_success() {
231            let resp = RequestorHelper::decode_serde_json_body(&mut resp).await?;
232            info!(
233                "global state meta add link success: req={:?}, resp={:?}",
234                req, resp,
235            );
236            Ok(resp)
237        } else {
238            let e = RequestorHelper::error_from_resp(&mut resp).await;
239            error!("global state meta add link error! req={:?}, {}", req, e);
240            Err(e)
241        }
242    }
243
244    // global-state-meta remove-access
245    fn encode_remove_link_request(&self, req: &GlobalStateMetaRemoveLinkOutputRequest) -> Request {
246        let url = self.service_url.join("link").unwrap();
247        let mut http_req = Request::new(Method::Delete, url);
248        self.encode_common_headers(
249            MetaAction::GlobalStateRemoveLink,
250            &req.common,
251            &mut http_req,
252        );
253
254        let value = serde_json::to_string(&req).unwrap();
255        http_req.set_body(value);
256        http_req
257    }
258
259    async fn remove_link(
260        &self,
261        req: GlobalStateMetaRemoveLinkOutputRequest,
262    ) -> BuckyResult<GlobalStateMetaRemoveLinkOutputResponse> {
263        let http_req = self.encode_remove_link_request(&req);
264        let mut resp = self.requestor.request(http_req).await?;
265
266        if resp.status().is_success() {
267            let resp = RequestorHelper::decode_serde_json_body(&mut resp).await?;
268            info!(
269                "global state meta remove link success: req={:?}, resp={:?}",
270                req, resp,
271            );
272            Ok(resp)
273        } else {
274            let e = RequestorHelper::error_from_resp(&mut resp).await;
275            error!("global state meta remove link error! req={:?}, {}", req, e);
276            Err(e)
277        }
278    }
279
280    // global-state-meta clear-link
281    fn encode_clear_link_request(&self, req: &GlobalStateMetaClearLinkOutputRequest) -> Request {
282        let url = self.service_url.join("links").unwrap();
283        let mut http_req = Request::new(Method::Delete, url);
284        self.encode_common_headers(MetaAction::GlobalStateClearLink, &req.common, &mut http_req);
285
286        let value = serde_json::to_string(&req).unwrap();
287        http_req.set_body(value);
288        http_req
289    }
290
291    async fn clear_link(
292        &self,
293        req: GlobalStateMetaClearLinkOutputRequest,
294    ) -> BuckyResult<GlobalStateMetaClearLinkOutputResponse> {
295        let http_req = self.encode_clear_link_request(&req);
296        let mut resp = self.requestor.request(http_req).await?;
297
298        if resp.status().is_success() {
299            let resp = RequestorHelper::decode_serde_json_body(&mut resp).await?;
300            info!(
301                "global state meta clear links success: req={:?}, resp={:?}",
302                req, resp,
303            );
304            Ok(resp)
305        } else {
306            let e = RequestorHelper::error_from_resp(&mut resp).await;
307            error!("global state meta clear links error! req={:?}, {}", req, e);
308            Err(e)
309        }
310    }
311
312    // global-state-meta add-object_meta
313    fn encode_add_object_meta_request(
314        &self,
315        req: &GlobalStateMetaAddObjectMetaOutputRequest,
316    ) -> Request {
317        let url = self.service_url.join("object-meta").unwrap();
318        let mut http_req = Request::new(Method::Put, url);
319        self.encode_common_headers(
320            MetaAction::GlobalStateAddObjectMeta,
321            &req.common,
322            &mut http_req,
323        );
324
325        let value = serde_json::to_string(&req).unwrap();
326        http_req.set_body(value);
327        http_req
328    }
329
330    async fn add_object_meta(
331        &self,
332        req: GlobalStateMetaAddObjectMetaOutputRequest,
333    ) -> BuckyResult<GlobalStateMetaAddObjectMetaOutputResponse> {
334        let http_req = self.encode_add_object_meta_request(&req);
335        let mut resp = self.requestor.request(http_req).await?;
336
337        if resp.status().is_success() {
338            let resp: GlobalStateMetaAddObjectMetaOutputResponse =
339                RequestorHelper::decode_serde_json_body(&mut resp).await?;
340            info!(
341                "global state meta add object meta success: req={:?}, resp={:?}",
342                req, resp,
343            );
344            Ok(resp)
345        } else {
346            let e = RequestorHelper::error_from_resp(&mut resp).await;
347            error!(
348                "global state meta add object meta error! req={:?}, {}",
349                req, e
350            );
351            Err(e)
352        }
353    }
354
355    // global-state-meta remove-object_meta
356    fn encode_remove_object_meta_request(
357        &self,
358        req: &GlobalStateMetaRemoveObjectMetaOutputRequest,
359    ) -> Request {
360        let url = self.service_url.join("object-meta").unwrap();
361        let mut http_req = Request::new(Method::Delete, url);
362        self.encode_common_headers(
363            MetaAction::GlobalStateRemoveObjectMeta,
364            &req.common,
365            &mut http_req,
366        );
367
368        let value = serde_json::to_string(&req).unwrap();
369        http_req.set_body(value);
370        http_req
371    }
372
373    async fn remove_object_meta(
374        &self,
375        req: GlobalStateMetaRemoveObjectMetaOutputRequest,
376    ) -> BuckyResult<GlobalStateMetaRemoveObjectMetaOutputResponse> {
377        let http_req = self.encode_remove_object_meta_request(&req);
378        let mut resp = self.requestor.request(http_req).await?;
379
380        if resp.status().is_success() {
381            let resp: GlobalStateMetaRemoveObjectMetaOutputResponse =
382                RequestorHelper::decode_serde_json_body(&mut resp).await?;
383            info!(
384                "global state meta remove object meta success: req={:?}, resp={:?}",
385                req, resp,
386            );
387            Ok(resp)
388        } else {
389            let e = RequestorHelper::error_from_resp(&mut resp).await;
390            error!(
391                "global state meta remove object meta error! req={:?}, {}",
392                req, e
393            );
394            Err(e)
395        }
396    }
397
398    // global-state-meta clear-object_meta
399    fn encode_clear_object_meta_request(
400        &self,
401        req: &GlobalStateMetaClearObjectMetaOutputRequest,
402    ) -> Request {
403        let url = self.service_url.join("object-metas").unwrap();
404        let mut http_req = Request::new(Method::Delete, url);
405        self.encode_common_headers(
406            MetaAction::GlobalStateClearObjectMeta,
407            &req.common,
408            &mut http_req,
409        );
410
411        let value = serde_json::to_string(&req).unwrap();
412        http_req.set_body(value);
413        http_req
414    }
415
416    async fn clear_object_meta(
417        &self,
418        req: GlobalStateMetaClearObjectMetaOutputRequest,
419    ) -> BuckyResult<GlobalStateMetaClearObjectMetaOutputResponse> {
420        let http_req = self.encode_clear_object_meta_request(&req);
421        let mut resp = self.requestor.request(http_req).await?;
422
423        if resp.status().is_success() {
424            let resp: GlobalStateMetaClearObjectMetaOutputResponse =
425                RequestorHelper::decode_serde_json_body(&mut resp).await?;
426            info!(
427                "global state meta clear object meta success: req={:?}, resp={:?}",
428                req, resp,
429            );
430            Ok(resp)
431        } else {
432            let e = RequestorHelper::error_from_resp(&mut resp).await;
433            error!(
434                "global state meta clear object meta error! req={:?}, {}",
435                req, e
436            );
437            Err(e)
438        }
439    }
440
441    // path config
442    // global-state-meta add-path-config
443    fn encode_add_path_config_request(
444        &self,
445        req: &GlobalStateMetaAddPathConfigOutputRequest,
446    ) -> Request {
447        let url = self.service_url.join("path-config").unwrap();
448        let mut http_req = Request::new(Method::Put, url);
449        self.encode_common_headers(
450            MetaAction::GlobalStateAddPathConfig,
451            &req.common,
452            &mut http_req,
453        );
454
455        let value = serde_json::to_string(&req).unwrap();
456        http_req.set_body(value);
457        http_req
458    }
459
460    async fn add_path_config(
461        &self,
462        req: GlobalStateMetaAddPathConfigOutputRequest,
463    ) -> BuckyResult<GlobalStateMetaAddPathConfigOutputResponse> {
464        let http_req = self.encode_add_path_config_request(&req);
465        let mut resp = self.requestor.request(http_req).await?;
466
467        if resp.status().is_success() {
468            let resp: GlobalStateMetaAddPathConfigOutputResponse =
469                RequestorHelper::decode_serde_json_body(&mut resp).await?;
470            info!(
471                "global state meta add path config success: req={:?}, resp={:?}",
472                req, resp,
473            );
474            Ok(resp)
475        } else {
476            let e = RequestorHelper::error_from_resp(&mut resp).await;
477            error!(
478                "global state meta add path config error! req={:?}, {}",
479                req, e
480            );
481            Err(e)
482        }
483    }
484
485    // global-state-meta remove-path_config
486    fn encode_remove_path_config_request(
487        &self,
488        req: &GlobalStateMetaRemovePathConfigOutputRequest,
489    ) -> Request {
490        let url = self.service_url.join("path-config").unwrap();
491        let mut http_req = Request::new(Method::Delete, url);
492        self.encode_common_headers(
493            MetaAction::GlobalStateRemovePathConfig,
494            &req.common,
495            &mut http_req,
496        );
497
498        let value = serde_json::to_string(&req).unwrap();
499        http_req.set_body(value);
500        http_req
501    }
502
503    async fn remove_path_config(
504        &self,
505        req: GlobalStateMetaRemovePathConfigOutputRequest,
506    ) -> BuckyResult<GlobalStateMetaRemovePathConfigOutputResponse> {
507        let http_req = self.encode_remove_path_config_request(&req);
508        let mut resp = self.requestor.request(http_req).await?;
509
510        if resp.status().is_success() {
511            let resp: GlobalStateMetaRemovePathConfigOutputResponse =
512                RequestorHelper::decode_serde_json_body(&mut resp).await?;
513            info!(
514                "global state meta remove path config success: req={:?}, resp={:?}",
515                req, resp,
516            );
517            Ok(resp)
518        } else {
519            let e = RequestorHelper::error_from_resp(&mut resp).await;
520            error!(
521                "global state meta remove path config error! req={:?}, {}",
522                req, e
523            );
524            Err(e)
525        }
526    }
527
528    // global-state-meta clear-path_config
529    fn encode_clear_path_config_request(
530        &self,
531        req: &GlobalStateMetaClearPathConfigOutputRequest,
532    ) -> Request {
533        let url = self.service_url.join("path-configs").unwrap();
534        let mut http_req = Request::new(Method::Delete, url);
535        self.encode_common_headers(
536            MetaAction::GlobalStateClearPathConfig,
537            &req.common,
538            &mut http_req,
539        );
540
541        let value = serde_json::to_string(&req).unwrap();
542        http_req.set_body(value);
543        http_req
544    }
545
546    async fn clear_path_config(
547        &self,
548        req: GlobalStateMetaClearPathConfigOutputRequest,
549    ) -> BuckyResult<GlobalStateMetaClearPathConfigOutputResponse> {
550        let http_req = self.encode_clear_path_config_request(&req);
551        let mut resp = self.requestor.request(http_req).await?;
552
553        if resp.status().is_success() {
554            let resp: GlobalStateMetaClearPathConfigOutputResponse =
555                RequestorHelper::decode_serde_json_body(&mut resp).await?;
556            info!(
557                "global state meta clear path config success: req={:?}, resp={:?}",
558                req, resp,
559            );
560            Ok(resp)
561        } else {
562            let e = RequestorHelper::error_from_resp(&mut resp).await;
563            error!(
564                "global state meta clear path config error! req={:?}, {}",
565                req, e
566            );
567            Err(e)
568        }
569    }
570}
571
572#[async_trait::async_trait]
573impl GlobalStateMetaOutputProcessor for GlobalStateMetaRequestor {
574    async fn add_access(
575        &self,
576        req: GlobalStateMetaAddAccessOutputRequest,
577    ) -> BuckyResult<GlobalStateMetaAddAccessOutputResponse> {
578        Self::add_access(&self, req).await
579    }
580
581    async fn remove_access(
582        &self,
583        req: GlobalStateMetaRemoveAccessOutputRequest,
584    ) -> BuckyResult<GlobalStateMetaRemoveAccessOutputResponse> {
585        Self::remove_access(&self, req).await
586    }
587
588    async fn clear_access(
589        &self,
590        req: GlobalStateMetaClearAccessOutputRequest,
591    ) -> BuckyResult<GlobalStateMetaClearAccessOutputResponse> {
592        Self::clear_access(&self, req).await
593    }
594
595    async fn add_link(
596        &self,
597        req: GlobalStateMetaAddLinkOutputRequest,
598    ) -> BuckyResult<GlobalStateMetaAddLinkOutputResponse> {
599        Self::add_link(&self, req).await
600    }
601
602    async fn remove_link(
603        &self,
604        req: GlobalStateMetaRemoveLinkOutputRequest,
605    ) -> BuckyResult<GlobalStateMetaRemoveLinkOutputResponse> {
606        Self::remove_link(&self, req).await
607    }
608
609    async fn clear_link(
610        &self,
611        req: GlobalStateMetaClearLinkOutputRequest,
612    ) -> BuckyResult<GlobalStateMetaClearLinkOutputResponse> {
613        Self::clear_link(&self, req).await
614    }
615
616    // object meta
617    async fn add_object_meta(
618        &self,
619        req: GlobalStateMetaAddObjectMetaOutputRequest,
620    ) -> BuckyResult<GlobalStateMetaAddObjectMetaOutputResponse> {
621        Self::add_object_meta(&self, req).await
622    }
623
624    async fn remove_object_meta(
625        &self,
626        req: GlobalStateMetaRemoveObjectMetaOutputRequest,
627    ) -> BuckyResult<GlobalStateMetaRemoveObjectMetaOutputResponse> {
628        Self::remove_object_meta(&self, req).await
629    }
630
631    async fn clear_object_meta(
632        &self,
633        req: GlobalStateMetaClearObjectMetaOutputRequest,
634    ) -> BuckyResult<GlobalStateMetaClearObjectMetaOutputResponse> {
635        Self::clear_object_meta(&self, req).await
636    }
637
638    // path config
639    async fn add_path_config(
640        &self,
641        req: GlobalStateMetaAddPathConfigOutputRequest,
642    ) -> BuckyResult<GlobalStateMetaAddPathConfigOutputResponse> {
643        Self::add_path_config(&self, req).await
644    }
645
646    async fn remove_path_config(
647        &self,
648        req: GlobalStateMetaRemovePathConfigOutputRequest,
649    ) -> BuckyResult<GlobalStateMetaRemovePathConfigOutputResponse> {
650        Self::remove_path_config(&self, req).await
651    }
652
653    async fn clear_path_config(
654        &self,
655        req: GlobalStateMetaClearPathConfigOutputRequest,
656    ) -> BuckyResult<GlobalStateMetaClearPathConfigOutputResponse> {
657        Self::clear_path_config(&self, req).await
658    }
659}
cyfs_lib/rmeta/requestor.rs

cyfs_lib/rmeta/
requestor.rs
