1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use crate::{
    support::Context,
    config::{LoadBalancer, RouteAddr},
};
use gateway_common::FusenFuture;
use std::{str::FromStr, sync::Arc};

pub trait RequestHandler_: Send + Sync {
    fn handler_(&'static self, context: Context, config: Option<String>) -> FusenFuture<Context>;
}

#[allow(async_fn_in_trait)]
pub trait RequestHandler {
    async fn handler(&self, context: Context, config: Option<String>) -> Context;
}

pub trait ResponseHandler_: Send + Sync {
    fn handler_(&'static self, context: Context, config: Option<String>) -> FusenFuture<Context>;
}

#[allow(async_fn_in_trait)]
pub trait ResponseHandler {
    async fn handler(&self, context: Context, config: Option<String>) -> Context;
}

pub trait BaseHandler_: Send + Sync {
    fn handler_(&'static self, context: Context, config: Option<String>) -> FusenFuture<Context>;
}

#[allow(async_fn_in_trait)]
pub trait BaseHandler {
    async fn handler(&self, context: Context, config: Option<String>) -> Context;
}

pub trait LoadBalance_: Send + Sync {
    fn select_(
        &'static self,
        load_balancer: Arc<LoadBalancer>,
    ) -> FusenFuture<Option<Arc<RouteAddr>>>;
}

#[allow(async_fn_in_trait)]
pub trait LoadBalance {
    async fn select(&self, addrs: Vec<Arc<RouteAddr>>) -> Option<Arc<RouteAddr>>;
}

pub enum HandlerInvoker {
    RequestHandler(&'static dyn RequestHandler_),
    ResponseHandler(&'static dyn ResponseHandler_),
    BaseHandler(&'static dyn BaseHandler_),
    LoadBalance(&'static dyn LoadBalance_),
}

pub struct Handler {
    id: String,
    handler_invoker: HandlerInvoker,
}

pub trait HandlerLoad {
    fn load(self) -> Handler;
}

impl Handler {
    pub fn new(id: String, handler_invoker: HandlerInvoker) -> Self {
        Self {
            id,
            handler_invoker,
        }
    }

    pub fn get_key(&self) -> String {
        let mut key = String::from_str(&self.id).unwrap();
        match &self.handler_invoker {
            HandlerInvoker::RequestHandler(_) => key.push_str(":RequestHandler"),
            HandlerInvoker::ResponseHandler(_) => key.push_str(":ResponseHandler"),
            HandlerInvoker::BaseHandler(_) => key.push_str(":BaseHandler"),
            HandlerInvoker::LoadBalance(_) => key.push_str(":LoadBalance"),
        }
        key
    }

    pub fn get_request_handler(&self) -> Option<&'static dyn RequestHandler_> {
        if let HandlerInvoker::RequestHandler(handler) = self.handler_invoker {
            Some(handler)
        } else {
            None
        }
    }

    pub fn get_response_handler(&self) -> Option<&'static dyn ResponseHandler_> {
        if let HandlerInvoker::ResponseHandler(handler) = self.handler_invoker {
            Some(handler)
        } else {
            None
        }
    }

    pub fn get_base_handler(&self) -> Option<&'static dyn BaseHandler_> {
        if let HandlerInvoker::BaseHandler(handler) = self.handler_invoker {
            Some(handler)
        } else {
            None
        }
    }
}