br_web_server/
lib.rs

1pub mod stream;
2pub mod config;
3mod encoding;
4pub mod request;
5pub mod response;
6pub mod websocket;
7use crate::stream::{Protocol, Scheme};
8use crate::config::{Config};
9use crate::request::{Method, Request, Upgrade};
10use crate::response::Response;
11use crate::websocket::{CloseCode, ErrorCode, Message, Websocket, USERS};
12use log::{error, info, warn};
13use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
14use std::io::{Error};
15use std::net::{IpAddr, SocketAddr, TcpListener};
16use std::sync::{Arc, Mutex};
17use std::time::{Duration};
18use std::{io, thread};
19use std::fmt::Debug;
20
21/// 网络服务
22#[derive(Clone, Debug)]
23pub struct WebServer;
24
25impl WebServer {
26    /// 后台服务器
27    pub fn new_service(config: &Config, factory: fn(out: Websocket) -> Box<dyn Handler>) {
28        loop {
29            match WebServer::service(&config.clone(), factory) {
30                Ok(()) => {}
31                Err(e) => error!("服务器错误: {}[{}]: {}", file!(), line!(), e),
32            }
33            warn!("服务器 1秒后重启");
34            thread::sleep(Duration::from_secs(1));
35        }
36    }
37    fn service(config: &Config, factory: fn(out: Websocket) -> Box<dyn Handler>) -> io::Result<()> {
38        info!("==================== 网络服务 服务信息 ====================");
39        info!("日志记录: {}",if config.log {"开启"} else {"关闭"});
40        info!("调试模式: {}",if config.debug { "开启" } else { "关闭" });
41        info!("地    址: {}", config.host);
42        info!("端 口 号: {}", config.port);
43        info!("服务地址: {}://{}{}",if config.https { "https" } else { "http" },config.host,if config.port > 0 {format!(":{}", config.port)} else {String::new()});
44        info!("根 目 录: {}", config.root_path.to_str().unwrap());
45        info!("访问目录: {}", config.public);
46        info!("运行目录: {}", config.runtime);
47        info!("SSL/TLS: {}",if config.https { "开启" } else { "关闭" });
48
49        if config.https {
50            info!("证书目录KEY: {:?}", config.tls.key);
51            info!("证书目录PEM: {:?}", config.tls.certs);
52        }
53
54        let addrs = [SocketAddr::from((
55            IpAddr::V4(config.host.parse().unwrap()),
56            config.port,
57        ))];
58        let listener = TcpListener::bind(&addrs[..])?;
59        info!("==================== 网络服务 启动成功 ====================");
60
61        let acceptor = Self::ssl(&config.clone())?;
62        for stream in listener.incoming() {
63            match stream {
64                Ok(stream) => {
65                    let config_new = config.clone();
66                    let acceptor_new = acceptor.clone();
67
68                    thread::spawn(move || -> io::Result<()> {
69                        // 设置超时时间
70                        if config_new.write_timeout > 0 {
71                            stream.set_write_timeout(Some(Duration::from_secs(config_new.write_timeout))).unwrap_or_default();
72                        }
73                        if config_new.read_timeout > 0 {
74                            stream.set_read_timeout(Some(Duration::from_secs(config_new.read_timeout))).unwrap_or_default();
75                        }
76
77                        let mut scheme = if config_new.https {
78                            match acceptor_new.accept(stream.try_clone().unwrap()) {
79                                Ok(e) => Scheme::Https(Arc::new(Mutex::new(e))),
80                                Err(_) => return Err(Error::other("加载加密请求失败")),
81                            }
82                        } else {
83                            Scheme::Http(Arc::new(Mutex::new(stream.try_clone().unwrap())))
84                        };
85
86                        let mut request = Request::default(config_new.clone(), Arc::new(Mutex::new(scheme.clone())));
87                        let mut response = Response::default(config_new.clone(), Arc::new(Mutex::new(scheme.clone())));
88                        request.handle()?;
89
90                        match request.protocol {
91                            Protocol::HTTP1_0 | Protocol::HTTP1_1 => {
92                                response.set_request(&mut request);
93
94                                match request.upgrade {
95                                    Upgrade::Websocket => {
96                                        let mut websocket = Websocket::new(request.clone(), response.clone());
97                                        if let Ok(()) = websocket.handle(factory) {}
98                                        if USERS.get(&websocket.key.to_string()).is_some() {
99                                            USERS.remove(&websocket.key);
100                                        }
101                                        if response.config.debug {
102                                            let len = USERS.len();
103                                            info!("退出: {len}");
104                                        }
105                                    }
106                                    Upgrade::Http => {
107                                        match request.method {
108                                            Method::OPTIONS => {
109                                                let websocket = Websocket::new(request.clone(), response.clone());
110                                                factory(websocket).on_options(&mut response);
111                                                response.send()?;
112                                            }
113                                            _ => {
114                                                if let Ok(e) = request.read_resource() { response.status(200).file(&e).send()? } else {
115                                                    let websocket = Websocket::new(request.clone(), response.clone());
116                                                    let mut factory_new = factory(websocket);
117                                                    factory_new.on_request(request.clone(), &mut response);
118                                                    factory_new.on_response(request.clone(), &mut response);
119                                                    response.send()?;
120                                                }
121                                            }
122                                        }
123                                    }
124                                    Upgrade::None => {
125                                        response.status(404).send()?;
126                                    }
127                                }
128                            }
129                            Protocol::HTTP2 => {
130                                let mut bytes = vec![];
131
132                                let websocket = Websocket::new(request.clone(), response.clone());
133                                scheme.http2_handle(&mut bytes, &mut request, &mut response)?;
134                                let mut factory_new = factory(websocket);
135                                factory_new.on_request(request.clone(), &mut response);
136                                factory_new.on_response(request.clone(), &mut response);
137                                scheme.send_http2(&mut response)?;
138                                //loop {
139                                //    scheme.http2_handle(&mut bytes, &mut request, &mut response, &server_ip, &client_ip)?;
140                                //    let mut factory_new = factory(websocket);
141                                //    factory_new.on_request(request.clone(), &mut response);
142                                //    factory_new.on_response(request.clone(), &mut response);
143                                //    scheme.send_http2(&mut response)?;
144                                //    break;
145                                //}
146                            }
147                            Protocol::None => {
148                                return Err(Error::other("未知请求"));
149                            }
150                        }
151
152                        // 日志记录
153                        match request.save_log() {
154                            Ok(()) => {}
155                            Err(_) => {
156                                error!("日志记录错误");
157                            }
158                        }
159                        Ok(())
160                    });
161                }
162                Err(e) => return Err(e),
163            }
164        }
165        Ok(())
166    }
167
168    fn ssl(config: &Config) -> io::Result<Arc<SslAcceptor>> {
169        if config.https {
170            let mut acceptor = SslAcceptor::mozilla_intermediate(SslMethod::tls())?;
171            if !config.tls.key.is_file() {
172                return Err(Error::other(
173                    format!("private.key 不存在: {:?}", config.tls.key).as_str(),
174                ));
175            }
176            if !config.tls.certs.is_file() {
177                return Err(Error::other(
178                    format!("certificate.pem 不存在: {:?}", config.tls.certs).as_str(),
179                ));
180            }
181            acceptor.set_private_key_file(config.tls.key.clone(), SslFiletype::PEM)?;
182            acceptor.set_certificate_file(config.tls.certs.clone(), SslFiletype::PEM)?;
183            Ok(Arc::new(acceptor.build()))
184        } else {
185            Ok(Arc::new(SslAcceptor::mozilla_intermediate(SslMethod::tls())?.build()))
186        }
187    }
188}
189
190pub trait HandlerClone {
191    fn clone_box(&self) -> Box<dyn Handler>;
192}
193
194// 实现 HandlerClone for 所有 Handler + Clone 的实现者
195impl<T> HandlerClone for T
196where
197    T: 'static + Handler + Clone,
198{
199    fn clone_box(&self) -> Box<dyn Handler> {
200        Box::new(self.clone())
201    }
202}
203
204// 为 dyn Handler 实现 Clone
205impl Clone for Box<dyn Handler> {
206    fn clone(&self) -> Box<dyn Handler> {
207        self.clone_box()
208    }
209}
210pub trait Handler: Send + Sync + HandlerClone + Debug {
211    /// 请求 处理
212    fn on_request(&mut self, _request: Request, _response: &mut Response) {}
213    /// 预检请求处理 OPTIONS
214    fn on_options(&mut self, response: &mut Response) {
215        if !response.headers.has_key("Access-Control-Allow-Origin") {
216            response.header("Access-Control-Allow-Origin", "*");
217        }
218        // GET,POST,OPTIONS
219        if !response.headers.has_key("Access-Control-Allow-Methods") {
220            response.header("Access-Control-Allow-Methods", "*");
221        }
222        // Content-Type, Authorization, X-Real-IP,X-Forwarded-For
223        if response.headers.has_key("Access-Control-Allow-Headers") {
224            let headers = response.headers["Access-Control-Allow-Headers"].to_string();
225            response.header("Access-Control-Allow-Headers", format!("Content-Type,Authorization,X-Real-IP,X-Forwarded-For,{headers}").as_str());
226        } else {
227            response.header("Access-Control-Allow-Headers", "Content-Type,Authorization,X-Real-IP,X-Forwarded-For");
228        }
229        // 允许前端跨域请求时发送和接收 cookie / 凭据
230        if !response.headers.has_key("Access-Control-Expose-Headers") {
231            response.header("Access-Control-Expose-Headers", "true");
232        }
233        // 允许前端访问请求头
234        if !response.headers.has_key("Access-Control-Expose-Headers") {
235            response.header("Access-Control-Expose-Headers", "Content-Disposition");
236        }
237        if !response.headers.has_key("Access-Control-Max-Age") {
238            response.header("Access-Control-Max-Age", "0");
239        }
240    }
241    /// 响应 处理
242    fn on_response(&mut self, request: Request, response: &mut Response) {
243        if response.config.origin.is_empty() {
244            response.header("Access-Control-Allow-Origin", "*");
245        } else {
246            let origin = request.header["origin"].as_str().unwrap_or("");
247            for item in response.config.origin.clone() {
248                if origin.contains(item.as_str()) {
249                    response.header("Access-Control-Allow-Origin", origin);
250                }
251            }
252        }
253        if response.headers.has_key("Content-Disposition") {
254            response.header("Access-Control-Expose-Headers", "Content-Disposition");
255        }
256    }
257
258    fn on_frame(&mut self) -> io::Result<()> {
259        Ok(())
260    }
261    /// 握手监听
262    fn on_open(&mut self) -> io::Result<()> {
263        Ok(())
264    }
265    /// 接收到消息
266    fn on_message(&mut self, _msg: Message) -> io::Result<()> {
267        Ok(())
268    }
269    /// 关闭监听
270    fn on_close(&mut self, _code: CloseCode, _reason: &str) {}
271    /// 错误监听
272    fn on_error(&mut self, _err: ErrorCode) {}
273    /// 关机监听
274    fn on_shutdown(&mut self) {}
275}
276
br_web_server/lib.rs

br_web_server/
lib.rs
