fusen_rs/handler/
mod.rs

1use crate::{
2    error::FusenError,
3    filter::FusenFilter,
4    handler::{
5        aspect::DefaultAspect,
6        loadbalance::{DefaultLoadBalance, LoadBalance_},
7    },
8    protocol::fusen::service::ServiceDesc,
9};
10use std::{collections::HashMap, sync::Arc};
11
12pub mod aspect;
13pub mod loadbalance;
14
15#[derive(Clone)]
16pub struct HandlerController {
17    pub load_balance: Option<Arc<Box<dyn LoadBalance_>>>,
18    pub aspect: Arc<Vec<Arc<Box<dyn FusenFilter>>>>,
19}
20
21pub enum HandlerInvoker {
22    LoadBalance(Arc<Box<dyn LoadBalance_>>),
23    Aspect(Arc<Box<dyn FusenFilter>>),
24}
25
26pub struct HandlerContext {
27    handlers: HashMap<String, Arc<HandlerInvoker>>,
28    cache: HashMap<String, HandlerController>,
29}
30
31pub struct HandlerInfo {
32    pub service_desc: ServiceDesc,
33    pub handlers: Vec<String>,
34}
35
36impl Default for HandlerContext {
37    fn default() -> Self {
38        let mut context = Self {
39            handlers: Default::default(),
40            cache: Default::default(),
41        };
42        context.handlers.insert(
43            "DefaultLoadBalance".to_string(),
44            Arc::new(HandlerInvoker::LoadBalance(Arc::new(Box::new(
45                DefaultLoadBalance,
46            )))),
47        );
48        context.handlers.insert(
49            "DefaultAspect".to_string(),
50            Arc::new(HandlerInvoker::Aspect(Arc::new(Box::new(DefaultAspect)))),
51        );
52        context.load_controller(HandlerInfo {
53            service_desc: ServiceDesc::new("DefaultHandlerController", None, None),
54            handlers: vec![],
55        });
56        context
57    }
58}
59
60impl HandlerContext {
61    pub fn load_handler(&mut self, handler: Handler) {
62        self.handlers
63            .insert(handler.id, Arc::new(handler.handler_invoker));
64    }
65
66    pub fn get_controller(
67        &self,
68        service_desc: &ServiceDesc,
69    ) -> Result<&HandlerController, FusenError> {
70        Ok(self.cache.get(service_desc.get_tag()).unwrap_or(
71            self.cache.get("DefaultHandlerController:None:None").ok_or(
72                FusenError::ErrorMessage("get DefaultHandlerController error"),
73            )?,
74        ))
75    }
76
77    pub fn load_controller(&mut self, handler_info: HandlerInfo) {
78        let mut load_balance: Option<Arc<Box<dyn LoadBalance_>>> = None;
79        let mut aspect: Vec<Arc<Box<dyn FusenFilter>>> = Vec::new();
80        for handler_id in &handler_info.handlers {
81            if let Some(handler_invoker) = self.get_handler(handler_id) {
82                match handler_invoker.as_ref() {
83                    HandlerInvoker::LoadBalance(handler) => {
84                        let _ = load_balance.insert(handler.clone());
85                    }
86                    HandlerInvoker::Aspect(handler) => {
87                        aspect.push(handler.clone());
88                    }
89                };
90            }
91        }
92        if load_balance.is_none()
93            && let Some(handler_invoker) = self.get_handler("DefaultLoadBalance")
94        {
95            match handler_invoker.as_ref() {
96                HandlerInvoker::LoadBalance(handler) => load_balance.insert(handler.clone()),
97                _ => panic!("{}", FusenError::Impossible),
98            };
99        }
100
101        let handler_controller = HandlerController {
102            load_balance,
103            aspect: Arc::new(aspect),
104        };
105        self.cache.insert(
106            handler_info.service_desc.get_tag().to_owned(),
107            handler_controller,
108        );
109    }
110
111    fn get_handler(&self, handler_id: &str) -> Option<Arc<HandlerInvoker>> {
112        self.handlers.get(handler_id).cloned()
113    }
114}
115
116pub struct Handler {
117    pub id: String,
118    pub handler_invoker: HandlerInvoker,
119}
120
121pub trait HandlerLoad {
122    fn load(self) -> Handler;
123}
fusen_rs/handler/mod.rs

fusen_rs/handler/
mod.rs
