# wmproxy
`wmproxy`已用`Rust`实现`http/https`代理, `socks5`代理, 反向代理, 静态文件服务器，四层TCP/UDP转发，七层负载均衡，内网穿透，后续将实现`websocket`代理等，会将实现过程分享出来，感兴趣的可以一起造个轮子

## 项目地址

[国内: https://gitee.com/tickbh/wmproxy](https://gitee.com/tickbh/wmproxy)

[github: https://github.com/tickbh/wmproxy](https://github.com/tickbh/wmproxy)

### 项目设计目标
在同一个端口上同时支持HTTP/HTTPS/SOCKS5代理，即假设监听8090端口，那么可以设置如下：
```
curl --proxy socks5://127.0.0.1:8090 http://www.baidu.com

curl --proxy http://127.0.0.1:8090 http://www.baidu.com

curl --proxy http://127.0.0.1:8090 https://www.baidu.com
```
以上方案需要都可以兼容打通，才算成功。

### 初始方案
不做HTTP服务器，仅简单的解析数据流，然后进行数据转发
```RUST
pub async fn process<T>(
 username: &Option<String>,
 password: &Option<String>,
 mut inbound: T,
) -> Result<(), ProxyError<T>>
where
 T: AsyncRead + AsyncWrite + Unpin,
{
 let mut outbound;
 let mut request;
 let mut buffer = BinaryMut::new();
 loop {
 let size = {
 let mut buf = ReadBuf::uninit(buffer.chunk_mut());
 inbound.read_buf(&mut buf).await?;
 buf.filled().len()
 };

 if size == 0 {
 return Err(ProxyError::Extension("empty"));
 }
 unsafe {
 buffer.advance_mut(size);
 }
 request = webparse::Request::new();
 // 通过该方法解析标头是否合法, 若是partial(部分)则继续读数据
 // 若解析失败, 则表示非http协议能处理, 则抛出错误
 // 此处clone为浅拷贝，不确定是否一定能解析成功，不能影响偏移
 match request.parse_buffer(&mut buffer.clone()) {
 Ok(_) => match request.get_connect_url() {
 Some(host) => {
 match HealthCheck::connect(&host).await {
 Ok(v) => outbound = v,
 Err(e) => {
 Self::err_server_status(inbound, 503).await?;
 return Err(ProxyError::from(e));
 }
 }
 break;
 }
 None => {
 if !request.is_partial() {
 Self::err_server_status(inbound, 503).await?;
 return Err(ProxyError::UnknownHost);
 }
 }
 },
 Err(WebError::Http(HttpError::Partial)) => {
 continue;
 }
 Err(_) => {
 return Err(ProxyError::Continue((Some(buffer), inbound)));
 }
 }
 }

 match request.method() {
 &Method::Connect => {
 log::trace!(
 "https connect {:?}",
 String::from_utf8_lossy(buffer.chunk())
 );
 inbound.write_all(b"HTTP/1.1 200 OK\r\n\r\n").await?;
 }
 _ => {
 outbound.write_all(buffer.chunk()).await?;
 }
 }
 let _ = copy_bidirectional(&mut inbound, &mut outbound).await?;
 Ok(())
}
```
此方案仅做浅解析，处理相当高效，但遇到如下问题：
* HTTP/HTTPS代理服务器需要验证密码
* HTTP服务存在不同的协议，此方法只兼容HTTP/1.1，无法兼容明确的HTTP/2协议
* 请求的协议头有些得做修改，此方法无法修改

### 改造方案
* 引入HTTP服务器介入
* 但是因为需要兼容不同协议，只有等确定协议后才能引入协议，需要预读数据，进行协议判定。
* HTTPS代理协议只处理一组Connect协议，之后需要解除http协议进行双向绑定。

[完整源码](https://github.com/tickbh/wmproxy/blob/main/src/proxy/http.rs)

1. 预读数据
* Socks5：第一个字节为`0X05`，非ascii字符，其它协议不会影响
* Https: https代理必须发送Connect方法，所以必须以`CONNECT`或者`connect`开头，且查询其它HTTP方法没有以C开头的，这里仅判断第一个字符为`C`或者`c`，该协议仅处理一条http请求不参与后续TLS握手协议等保证数据安全
* 其它开头的均被认为http代理
```RUST
let mut buffer = BinaryMut::with_capacity(24);
let size = {
 let mut buf = ReadBuf::uninit(buffer.chunk_mut());
 inbound.read_buf(&mut buf).await?;
 buf.filled().len()
};

if size == 0 {
 return Err(ProxyError::Extension("empty"));
}
unsafe {
 buffer.advance_mut(size);
}
// socks5 协议, 直接返回, 交给socks5层处理
if buffer.as_slice()[0] == 5 {
 return Err(ProxyError::Continue((Some(buffer), inbound)));
}

let mut max_req_num = usize::MAX;
// https 协议, 以connect开头, 仅处理一条HTTP请求
if buffer.as_slice()[0] == b'C' || buffer.as_slice()[0] == b'c' {
 max_req_num = 1;
}
```
2. 构建HTTP服务器，构建服务类：
```RUST
/// http代理类处理类
struct Operate {
 /// 用户名
 username: Option<String>,
 /// 密码
 password: Option<String>,
 /// Stream类, https连接后给后续https使用
 stream: Option<TcpStream>,
 /// http代理keep-alive的复用
 sender: Option<Sender<RecvRequest>>,
 /// http代理keep-alive的复用
 receiver: Option<Receiver<ProtResult<RecvResponse>>>,
}
```
构建HTTP服务
```RUST
// 需要将已读的数据buffer重新加到server的已读cache中, 否则解析会出错
let mut server = Server::new_by_cache(inbound, None, buffer);
// 构建HTTP服务回调
let mut operate = Operate {
 username: username.clone(),
 password: password.clone(),
 stream: None,
 sender: None,
 receiver: None,
};
server.set_max_req(max_req_num);
let _e = server.incoming(&mut operate).await?;
if let Some(outbound) = &mut operate.stream {
 let mut inbound = server.into_io();
 let _ = copy_bidirectional(&mut inbound, outbound).await?;
}
```
此时我们已将数据用HTTP服务进行处理，收到相应的请求再进行给远端做转发：

HTTP核心处理回调，此处我们用的是`async_trait`异步回调
```RUST

#[async_trait]
impl OperateTrait for &mut Operate {
 async fn operate(&mut self, request: &mut RecvRequest) -> ProtResult<RecvResponse> {
 // 已连接直接进行后续处理
 if let Some(sender) = &self.sender {
 sender.send(request.replace_clone(Body::empty())).await?;
 if let Some(res) = self.receiver.as_mut().unwrap().recv().await {
 return Ok(res?)
 }
 return Err(ProtError::Extension("already close by other"))
 }
 // 获取要连接的对象
 let stream = if let Some(host) = request.get_connect_url() {
 match HealthCheck::connect(&host).await {
 Ok(v) => v,
 Err(e) => {
 return Err(ProtError::from(e));
 }
 }
 } else {
 return Err(ProtError::Extension("unknow tcp stream"));
 };

 // 账号密码存在，将获取`Proxy-Authorization`进行校验，如果检验错误返回407协议
 if self.username.is_some() && self.password.is_some() {
 let mut is_auth = false;
 if let Some(auth) = request.headers_mut().remove(&"Proxy-Authorization") {
 if let Some(val) = auth.as_string() {
 is_auth = self.check_basic_auth(&val);
 }
 }
 if !is_auth {
 return Ok(Response::builder().status(407).body("")?.into_type());
 }
 }

 // 判断用户协议
 match request.method() {
 &Method::Connect => {
 // https返回200内容直接进行远端和客户端的双向绑定
 self.stream = Some(stream);
 return Ok(Response::builder().status(200).body("")?.into_type());
 }
 _ => {
 // http协议，需要将客户端的内容转发到服务端，并将服务端数据转回客户端
 let client = Client::new(ClientOption::default(), MaybeHttpsStream::Http(stream));
 let (mut recv, sender) = client.send2(request.replace_clone(Body::empty())).await?;
 match recv.recv().await {
 Some(res) => {
 self.sender = Some(sender);
 self.receiver = Some(recv);
 return Ok(res?)
 },
 None => return Err(ProtError::Extension("already close by other")),
 }
 }
 }

 }
}
```

密码校验，由`Basic`的密码加密方法，先用base64解密，再用`:`做拆分，再与用户密码比较
```RUST
pub fn check_basic_auth(&self, value: &str) -> bool
{
 use base64::engine::general_purpose;
 use std::io::Read;

 let vals: Vec<&str> = value.split_whitespace().collect();
 if vals.len() == 1 {
 return false;
 }

 let mut wrapped_reader = Cursor::new(vals[1].as_bytes());
 let mut decoder = base64::read::DecoderReader::new(
 &mut wrapped_reader,
 &general_purpose::STANDARD);
 // handle errors as you normally would
 let mut result: Vec<u8> = Vec::new();
 decoder.read_to_end(&mut result).unwrap();

 if let Ok(value) = String::from_utf8(result) {
 let up: Vec<&str> = value.split(":").collect();
 if up.len() != 2 {
 return false;
 }
 if up[0] == self.username.as_ref().unwrap() ||
 up[1] == self.password.as_ref().unwrap() {
 return true;
 }
 }

 return false;
}
```

### 小结
代理在计算机网络很常见，比如服务器群组内部通常只会开一个口进行对外访问，就可以通过内网代理来进行处理，从而更好的保护内网服务器。代理让我们网络更安全，但是警惕非正规的代理可能会窃取您的数据。请用HTTPS内容访问更安全。

点击 **[关注]**，**[在看]**，**[点赞]** 是对作者最大的支持

35干货系列从零用Rust编写负载均衡及代理，代理服务器的源码升级改造

# wmproxy
`wmproxy`已用`Rust`实现`http/https`代理, `socks5`代理, 反向代理, 静态文件服务器，四层TCP/UDP转发，七层负载均衡，内网穿透，后续将实现`websocket`代理等，会将实现过程分享出来，感兴趣的可以一起造个轮子

## 项目地址

[国内: https://gitee.com/tickbh/wmproxy](https://gitee.com/tickbh/wmproxy)

[github: https://github.com/tickbh/wmproxy](https://github.com/tickbh/wmproxy)

## 关于 ++trait++
&emsp;&emsp;trait是`Rust`中的概念，类似于其他语言中的接口`（interface）`。
&emsp;&emsp;在`Rust`中不存在继承的概念，所有关于结构体的拓展功能全部均由`trait`来代替。比如`std::io::Read`这是一个关于io的`trait`，在`TcpStream`中和在`File`中均实现了该功能，这样子如果上层只关心读操作的，我们就可以将其转化成`std::io::Read`的一个对象，比如`io: std::io::Read`，后面我们也可以把他包裹成`BufferReader`等实现功能的转化。

### 为什么不在Rust中使用继承
* 继承破坏了封装性，父类的改变会影响子类。如果父类的出现发生变化，所有继承自该父类的子类都需要相应地进行修改，这会增加代码的维护成本。
* Rust追求内存安全和无数据竞争，继承不利于编译器进行静态检查。
* 继承关系的耦合度高。子类和父类之间是紧密耦合的关系，这会影响代码的灵活性和可移植性。
* 继承往往被过度使用,导致子类与父类功能紧密耦合。

> 下面举下例子，设计关于车的通用基类，能跑能停等
```JAVA
public class BaseCar { 
 //... 省略其他属性和方法... 
 public void run() { //... }
 public void stop() { //... }
}
```
一开始自行车都很完美，接下来设计摩托车，摩托车需要加油，那么基类被改成
```JAVA
public class BaseCar { 
 //... 省略其他属性和方法... 
 public void run() { //... }
 public void stop() { //... }
 public void refuel() { //... }
}
```
但是自行车又没有加油的需求
```JAVA
// 自行车
public class Bicycle extends BaseCar { 
 //... 省略其他属性和方法... 
 public void refuel() { 
 throw new UnSupportedMethodException("我不需要加油！");
 }
}
```
如果接下来又有修理引擎的接口，那基类又得加`repairEngine`的接口。自行车继承这个基类将会产生严重的负担，不继承又得重新写一些关于基础能力的函数，又会增加重复代码。

那么接下来是以`trait`方案的实现
```RUST
pub trait Base {
 fn run(&self); 
 fn stop(&self); 
}
pub trait Refuel {
 fn refuel(&mut self); 
}
pub trait RepairEngine {
 fn repair_engine(&mut self); 
}
```
那么自行车只需要实现`Base`能力，然后摩托车在自行车的基础上实现`Refuel`及`RepairEngine`即可实现解耦。

### 异步的`trait`
在程序中均使用的是异步`(async)`编程，那么我们可能需要将trait实现成：
```rust
pub trait Base {
 async fn run(&self); 
 async fn stop(&self); 
}
```
当我们如此写的时候编译器就会提示我们：
```
functions in traits cannot be declared `async`
`async` trait functions are not currently supported
consider using the `async-trait` crate: https://crates.io/crates/async-trait
see issue #91611 <https://github.com/rust-lang/rust/issues/91611> for more informationrustcClick for full compiler diagnostic
```
原来异步的trait实现还没有进入到`stable`阶段，暂时只能有预览版即`nightly`版本进行使用。

那么本文将探讨该功能在未`stable`前如何实现异步的`trait`。

#### 假如返回一个异步的Future
```RUST
trait Base {
 type FetchData<'a>: std::future::Future<Output = String> + 'a where Self: 'a;
 fn run<'a>(&'a self) -> Self::FetchData<'a>;
}
```
那么实现自行车的函数将为：
```RUST
trait Base {
 type FetchData<'a>: /* 将要何种类型呢？？ */;
 fn run<'a>(&'a self) -> Self::FetchData<'a>;
}
```
我们尝试过各种类型，编译器都无法通过编译，所以我们需要进行返回值的修改，我们将通过运行时类型擦除来实现。

首先，我们可以通过用 擦除 future 类型来避免编写 future 类型。以上面的例子为例，你可以这样写你的特征：dyn
```RUST
trait Base {
 fn run<'a>(&'a self) -> Pin<Box<dyn Future<Output = String> + Send + '_>>;
}
```
那么实现将为：
```RUST
impl Base for Bicycle {
 fn run<'a>(&'a self) -> std::pin::Pin<Box<dyn std::future::Future<Output = String> + Send + '_>> {
 Box::pin(async {
 "ok".to_string()
 })
 }
}
```
可以看出整个函数非常的冗余，相当的让人难受。

那么此时我们可以借助`async-trait`的宏处理库，他将帮我们自动处理掉无用的数据，那么我们的代码将变成如下：
```RUST
#[async_trait]
trait Base {
 async fn run(&self) -> String;
}
#[async_trait]
impl Base for Bicycle {
 async fn run(&self) -> String {
 "ok".to_string()
 }
}
```

当然现在此方法会造成额外的开销，像`Box`，`Send`等都会造成一定的性能损失，如果要零损失实现异步还可以尝试以下方案

#### 手动实现`Poll`
需要零开销或在no_std上下文中工作的特征还有另一种选择：它们可以从 Future 特征中获取轮询的概念，并将其直接构建到它们的界面中。如果 future 已完成，并且 future 正在等待其他事件，则该方法将返回。`Future::poll`,`Poll::Ready(Output)`,`Poll::Pending`

```RUST
pub trait Base {
 type Item;
 fn poll_next(
 self: Pin<&mut Self>,
 cx: &mut Context<'_>
 ) -> Poll<Option<Self::Item>>;
}
```
当然控制Poll的方式相当的麻烦，只要在对性能要求极高的情况下在进行此操作。

#### 预期的官方实现
在最新的Beta或者nightly版本中可以用`#![feature(async_fn_in_trait)]`来启用该能力，那么我们就可以如下编程：
```RUST
#![feature(async_fn_in_trait)]

trait Base {
 async fn run(&self) -> String;
}

impl Base for Bicycle {
 async fn run(&self) -> String {
 "ok".to_string()
 }
}
```
这样子就和普通的实现没有什么差别了。

#### 实现该功能的难点
理论上来说，一个异步只有你在调用await的时候他才会真正的被调用，如果在此前有引用对话的存在，那么他的生命周期管理才是比较麻烦的存在。

### 小结
当前的Rust版本为`1.74.0`，好消息的是当前`async trait`已经`Beta Channel`了，如果不出意外的话下一次发布版本的稳定版将会拥有该能力了。该功能的官方实现将会给异步编程的带来极大的方便。让`async/await`能力越来越强。预期2023年末就可以直接使用了。下一章节我们将讲`async trait`在项目中的应用。


点击 **[关注]**，**[在看]**，**[点赞]** 是对作者最大的支持

29干货系列从零用Rust编写正反向代理，异步回调(async trait)的使用

# wmproxy
`wmproxy`已用`Rust`实现`http/https`代理, `socks5`代理, 反向代理, 静态文件服务器，四层TCP/UDP转发，内网穿透，后续将实现`websocket`代理等，会将实现过程分享出来，感兴趣的可以一起造个轮子

## 项目地址

[国内: https://gitee.com/tickbh/wmproxy](https://gitee.com/tickbh/wmproxy)

[github: https://github.com/tickbh/wmproxy](https://github.com/tickbh/wmproxy)

## 项目中的使用
> 目前需要将每条请求数据进入的日志，如`access_log`，或者项目相关的错误日志`error_log`记录下来。

以下将介绍项目中如何进行记录并格式化日志的

### 文件配置
> 当前需要根据项目中的配置进行相应的初始化，需要用代码将当前的配置进行初始化。

```TOML
[http]
# 访问列表的写入文件及格式
access_log = "access main debug"
# 错误列表的写入文件及格式，错误的第二个是错误等级。
error_log = "error debug"

# 日志格式
[http.log_format]
main = "{d(%Y-%m-%d %H:%M:%S)} {client_ip} {l} {url} path:{path} query:{query} host:{host} status: {status} {up_status} referer: {referer} user_agent: {user_agent} cookie: {cookie}"

[http.log_names]
access = "logs/access.log trace"
error = "logs/error.log"
default = "logs/default.log"
```

### 日志的组成部分
> 日志的组成分为三个部分
1. access_log及error_log的写入文件、格式及日志等级
2. log_names日志的别名，包含日志文件及可能包含日志等级，没有等级默认Info
3. 日志格式，记录日志携带的相关消息，如访问的客户端ip`{client_ip}`或者访问Url`{url}`等，遵循Rust的打印结构，用`{}`里面包含要打印的相关消息

以下是访问信息打印的数据
```
2023-11-16 15:02:00 127.0.0.1:55922 INFO http://127.0.0.1:82/root/?aaa=1 path:/root/ query:aaa=1 host:127.0.0.1 status: ??? referer: user_agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/119.0 cookie: 
```

### 注意点
因为`access_log`及`error_log`可以在`[http]`的层级下任意配置，第一步我们需要收集到合适的`log_names`进行初始化，我们用的是一个`HashMap`做键值对，防止重复：
```RUST
/// http.rs
pub fn get_log_names(&self, names: &mut HashMap<String, String>) {
 self.comm.get_log_names(names);
 for s in &self.server {
 s.get_log_names(names);
 }
}
/// server.rs
pub fn get_log_names(&self, names: &mut HashMap<String, String>) {
 self.comm.get_log_names(names);
 for l in &self.location {
 l.get_log_names(names);
 }
}
/// common.rs
pub fn get_log_names(&self, names: &mut HashMap<String, String>) {
 for val in &self.log_names {
 if !names.contains_key(val.0) {
 names.insert(val.0.clone(), val.1.clone());
 }
 }
}
```
收集好正确的log文件后，我们需要对其初始化或者重加载，其中重新加载需要拥有上次初始化的`Handle`那么我们需对基进行存储：
```RUST
lazy_static! {
 /// 用静态变量存储log4rs的Handle
 static ref LOG4RS_HANDLE: Mutex<Option<log4rs::Handle>> = Mutex::new(None);
}

/// 尝试初始化, 如果已初始化则重新加载
pub fn try_init_log(option: &ConfigOption) {
 let log_names = option.get_log_names();
 let mut log_config = log4rs::config::Config::builder();
 let mut root = Root::builder();
 for (name, path) in log_names {
 let (path, level) = {
 let vals: Vec<&str> = path.split(' ').collect();
 if vals.len() == 1 {
 (path, Level::Info)
 } else {
 (
 vals[0].to_string(),
 Level::from_str(vals[1]).ok().unwrap_or(Level::Info),
 )
 }
 };
 // 设置默认的匹配类型打印时间信息
 let parttern =
 log4rs::encode::pattern::PatternEncoder::new("{d(%Y-%m-%d %H:%M:%S)} {m}{n}");
 let appender = FileAppender::builder()
 .encoder(Box::new(parttern))
 .build(path)
 .unwrap();
 if name == "default" {
 root = root.appender(name.clone());
 }
 log_config =
 log_config.appender(Appender::builder().build(name.clone(), Box::new(appender)));
 log_config = log_config.logger(
 Logger::builder()
 .appender(name.clone())
 // 当前target不在输出到stdout中
 .additive(false)
 .build(name.clone(), level.to_level_filter()),
 );
 }

 if !option.disable_stdout {
 let stdout: ConsoleAppender = ConsoleAppender::builder().build();
 log_config = log_config.appender(Appender::builder().build("stdout", Box::new(stdout)));
 root = root.appender("stdout");
 }

 let log_config = log_config.build(root.build(LevelFilter::Info)).unwrap();
 // 检查静态变量中是否存在handle可能在多线程中,需加锁
 if LOG4RS_HANDLE.lock().unwrap().is_some() {
 LOG4RS_HANDLE
 .lock()
 .unwrap()
 .as_mut()
 .unwrap()
 .set_config(log_config);
 } else {
 let handle = log4rs::init_config(log_config).unwrap();
 *LOG4RS_HANDLE.lock().unwrap() = Some(handle);
 }
}
```
我们需要在初始化参数的时候在重新调用该函数，保证新的日志信息能正确的初始化。

下面是将访问日志的数据打印下来：
```RUST
/// 记录HTTP的访问数据并将其格式化
pub fn log_acess(
 log_formats: &HashMap<String, String>,
 access: &Option<ConfigLog>,
 req: &Request<RecvStream>,
) {
 if let Some(access) = access {
 if let Some(formats) = log_formats.get(&access.format) {
 // 需要先判断是否该日志已开启, 如果未开启直接写入将浪费性能
 if log_enabled!(target: &access.name, access.level) {
 // 将format转化成pattern会有相当的性能损失, 此处缓存pattern结果
 let pw = FORMAT_PATTERN_CACHE.with(|m| {
 if !m.borrow().contains_key(&**formats) {
 let p = PatternEncoder::new(formats);
 m.borrow_mut()
 .insert(Box::leak(formats.clone().into_boxed_str()), Arc::new(p));
 }
 m.borrow()[&**formats].clone()
 });

 // 将其转化成Record然后进行encode
 let record = ProxyRecord::new_req(Record::builder().level(Level::Info).build(), req);
 let mut buf = vec![];
 pw.encode(&mut SimpleWriter(&mut buf), &record).unwrap();
 log::info!(target: &access.name, "{}", String::from_utf8_lossy(&buf[..]))
 }
 }
 }
}
```

其中缓存pattern的结果性能损失的要求不高，但需要访问速度要高：
```RUST
thread_local! {
 static FORMAT_PATTERN_CACHE: RefCell<HashMap<&'static str, Arc<PatternEncoder>>> = RefCell::new(HashMap::new());
}
```
加RefCell是因为默认是不可变的，如果有新的数据，需要将其变成可变数据，从而进行缓存。
HashMap中的key用`&'static str`是可以不必要将一些数据转化成`String`避免不必要的拷贝。
如果将`String`变成`&'static str`那么意味着这段内存将会变成不可回收的数据，意味着内存泄漏，所以我们需要用`Box::leak`
```RUST
Box::leak(formats.clone().into_boxed_str()
```
HashMap中的value中用Arc，因为我们是一个全部变量，我们要尽量的减少其访问的时间，但是我们又需要持有Pattern，所以我们在这里应用了一个引用计数`Arc`，拷贝的时候仅仅消耗加减引用计数。
```RUST
m.borrow()[&**formats].clone()
```

### 分析Pattern
> 以下代码大部分来自log4rs
```RUST
pub struct PatternEncoder {
 chunks: Vec<Chunk>,
 pattern: String,
}
```
首先会将一个字符串拆成若干个`Chunk`信息，
```rust
enum Chunk {
 Text(String),
 Formatted {
 chunk: FormattedChunk,
 params: Parameters,
 },
 Error(String),
}
```
以下用`date: {d(%Y-%m-%d %H:%M:%S)} url: {url}{n}`做示范，我们在解析这字符串的时候将会得到以下五个部分：
1. `date: `这是一个常量数据也就是`Text`将原样输出
2. `{d(%Y-%m-%d %H:%M:%S)}`将会转化成`Formatted::FormattedChunk::Time(String, Timezone)`，然后根据数组遍历，若为这个，那边将写入时间信息`2023-11-16 15:02:00`
3. ` url:`常量，原样输出
4. `{url}`将会转成`FormattedChunk::Url`如果存在`Request`将从其中获取url地址，若没有则输出`???`
5. `{N}`将会转成`FormattedChunk::Newline`，将会 根据平台输出换行符。

此时我们的输出只需要进行一次遍历即可`O(n)`，也不必`replace`等造成字符串的数据重排导致时间的变化。

此外还有额外参数：
* `{client_ip}` 客户端IP
* `{url}` 访问Url
* `{path}` 访问路径，如`/user/login`
* `{query}` 访问请求参数，如`user=wmproxy&password=wmproxy`
* `{host}` 访问Host
* `{referer}` 访问的referer
* `{user_agent}` 客户端Agent
* `{cookie}` 当前访问的cookie

#### 小结
日志在程序中必不可少，那么需要尽可能的高效，所以尽可能的提升日志的效率是必须处理的一环。

点击 **[关注]**，**[在看]**，**[点赞]** 是对作者最大的支持

28干货系列从零用Rust编写正反向代理，项目日志的源码实现

# wmproxy
`wmproxy`已用`Rust`实现`http/https`代理, `socks5`代理, 反向代理, 静态文件服务器，四层TCP/UDP转发，内网穿透，后续将实现`websocket`代理等，会将实现过程分享出来，感兴趣的可以一起造个轮子

## 项目地址

[国内: https://gitee.com/tickbh/wmproxy](https://gitee.com/tickbh/wmproxy)

[github: https://github.com/tickbh/wmproxy](https://github.com/tickbh/wmproxy)


## 日志
日志在程序中的重要性非常的重要，当系统发生故障时，我们要随时能排查出相关的日志，所以通常有了日志分级的概念（如错误error，警告warn，信息info，调试debug，追踪trace），如果系统出了严重的Bug，那我们此时应该排查warn及error看是否有相应的错误信息。如果是程序流程上的问题，可能会很琐碎，那我们可能需要排查trace的消息。

> 相对来说，trace的日志数据量极大，当然也最琐碎，排查起来会极难排查，要根据相关的关键字来定位相关日志，通常一个类型的日志会定义相同的关键字，在Java中类似Tag这种，在Rust库中日志会根据库自动显示出来，我们可以轻松的根据库名定位同一个库的问题。同一个库内可根据关键字来定位。

### 日志分类
#### 标准输出
> 程序中存在标准输出`(stdout)`及错误输出`(stderr)`，通常程序的运行中会将标准输出的内容显示在控制台上，我们就可以根据输出的内容来判定程序是否正常执行。在Rust中，最常用的是宏`println!()`。

#### 文件输出
> 如果是服务类型的程序，常常会将数据输出到文件中，因为它运行时间通常按天或者月甚至是年来计算。产生的日志量也极为庞大，通常要按天来切割日志，且单文件可能上GB大小，在后台运行时，通过也会通过重定向将控制台的内容输出到文件上。
后台执行command命令，并将内容输出到myout.log，且将stderr重定向到stdout。如：
```BASH
nohup command > myout.log 2>&1 &
```

### Rust中的日志库
通常在Rust中有日志库基本上都是基于`log`库去做实现，他定义了日志的等级，总共5个级别
```RUST
pub enum Level {
 Error = 1,
 Warn,
 Info,
 Debug,
 Trace,
}
```
通常用宏来进行输出，下面来看下输出宏的定义：
```RUST
#[macro_export]
macro_rules! info {
 (target: $target:expr, $($arg:tt)+) => ($crate::log!(target: $target, $crate::Level::Info, $($arg)+));

 ($($arg:tt)+) => ($crate::log!($crate::Level::Info, $($arg)+))
}
```
他分为两种情况，一种是有目标`target`，一种是默认target为`root`

在wmproxy中，我们通过服务的类型，找到日志输出的不同target，就可以控制输出目录一致或者不一致的控制，如：
```RUST
log::info!(target: "access", "{}", String::from_utf8_lossy(&buf[..]));
```

此外设定日志的等级，如果设定为等级为`Level::Info`那么`log::trace!`及`log::debug!`的日志将不会做任何输出。

以下是我用过的两个日志库：
1. **env_logger**
这是一个根据环境变量来控制日志等级，并可以自由设置target输出的日志库，我们需要手动调用初始化：
```rust
env_logger::init();
```
&emsp;&emsp;以下是如何启动控制最简单版：
```bash
RUST_LOG=debug cargo run

# windows
$env:RUST_LOG="debug"
cargo run
```
此外还可以设定特定库的日志等级：
> 当前库默认的日志等级是info，但是wenmeng及webparse库的日志等级为warn，可以有效的过滤第三方库日志信息又不影响自身的信息

```BASH
RUST_LOG="info,wenmeng=warn,webparse=warn" cargo run
```

2. **log4rs**
这是一个根据配置文件来控制日志输出到控制台或者输出到文件及文件是否压缩是否切割等数据，也可以同时输出到控制台及文件中。
他通常通过配置文件来加载配置，以下是他的配置内容
```YAML
# 每隔30秒检查当前文件
refresh_rate: 30 seconds

appenders:
 # 标准输出的类型设置为控制台
 stdout:
 kind: console

 # 请求数据放置在log/requests.log文件中
 requests:
 kind: file
 path: "log/requests.log"
 encoder:
 # 输出格式d为日期，m为内容，n为换行符
 pattern: "{d} - {m}{n}"

root:
 # 默认的日志等级为warn
 level: warn
 # 标准输出只输到stdout的配置，即上面配置的控制台
 appenders:
 - stdout

loggers:
 app::backend::db:
 level: info

 app::requests:
 level: info
 appenders:
 - requests
 # 是否追加到root里，如果配置为true他将同时输出两个
 additive: false
```

然后调用初始化：
```RUST
log4rs::init_file("log4rs.yml", Default::default()).unwrap();
```

#### log4rs规则
应用程序获取日志记录并将其记录到某个地方，例如，将其记录到文件、控制台或系统日志中。

#### 实现格式:

- **console**: 控制台输出，需要`console_appender`特征
- **file**: 文件输出，需要`file_appender`特征
- **rolling_file**: 滚动文件输出，需要`rolling_file_appender`特征且必须配置`compound_policy`
 - **compound**: 如何触发文件切割
 - **Rollers**
 - **delete**: 触发时删除旧数据
 - **fixed_window**: 将旧数据如何进行存储配置
 - **Triggers**
 - **size**: 触发大小的限制

以下是只保留10m大小的日志，多余数据全部删除的配置：
```YAML
kind: rolling_file

path: log/foo.log

append: true

encoder:
 kind: pattern

policy:
 kind: compound

 trigger:
 kind: size
 limit: 10 mb

 roller:
 kind: delete
```
如果要保留旧数据，可以修改`roller`的配置：
```YAML
kind: fixed_window

pattern: archive/foo.{}.log

count: 5

base: 1
```
旧文件将会保持`archive/foo.0.log`，`archive/foo.1.log`……`archive/foo.4.log`
如果配置的后缀名称为`.gz`且开始了gzip的特征，那么目标文件将会被自动压缩成gz格式，如`archive/foo.{}.log.gz`。如：
```TOML
log4rs = { version ="1.0.0", features = ["gzip"] }
```

#### 匹配模型:
这是log4rs的简单模型输出，以`{}`里面包含目标数据及可能携带的参数：
* `d`, `date` - 当前的日期格式.
 一个自定义的格式，依赖于`chrono`，获取的日志的写入的当前时间，第一个参数为时间的自定为格式，第二个参数 是`utc`或者为`local`。以下参数
 * `{d}` - `2022-11-15T14:22:20.644420340-08:00`
 * `{d(%Y-%m-%d %H:%M:%S)}` - `2022-11-15 14:22:20`
 * `{d(%Y-%m-%d %H:%M:%S %Z)(utc)}` - `2022-11-15 22:22:20 UTC`
* `f`, `file` - 当前打印的源文件，如果没有显示`???`。
* `h`, `highlight` - 高亮当前日志，如果有错误显示红色，蓝色显示info等
 * `{h(the level is {l})}` -
 `<code style="color: red; font-weight: bold">the level is ERROR</code>`
* `l`, `level` - 当前日志等级.
* `L`, `line` - 当前打印的源文件的行数，如果没有显示`???`
* `m`, `message` - 当前的消息详情.
* `M`, `module` - 当前打印的源模块，如果没有显示`???`
* `P`, `pid` - 当前的进程id.
* `i`, `tid` - 当前的线程id.
* `n` - 换行符.
* `t`, `target` - 目标输出的target.
* `T`, `thread` - 当前的线程名称.
* `I`, `thread_id` - pthread的线程id.

### 结语
log4rs提供了自定义的一些功能，可以友好的设置一些日志的功能，下一篇将讲解如何自定义实现`access_log`和`error_log`的功能。
 

点击 **[关注]**，**[在看]**，**[点赞]** 是对作者最大的支持

27干货系列从零用Rust编写正反向代理，Rust中日志库的应用基础准备

# wmproxy
`wmproxy`已用`Rust`实现`http/https`代理, `socks5`代理, 反向代理, 静态文件服务器，四层TCP/UDP转发，七层负载均衡，内网穿透，后续将实现`websocket`代理等，会将实现过程分享出来，感兴趣的可以一起造个轮子

## 项目地址

[国内: https://gitee.com/tickbh/wmproxy](https://gitee.com/tickbh/wmproxy)

[github: https://github.com/tickbh/wmproxy](https://github.com/tickbh/wmproxy)

### 自动化测试
在程序中，通常会写一些自动化测试的功能，来保证我们的代码正确的执行符合预期的效果，随着时间的变化，当代码变动的数据越来越多时，保证能实时的测试确保整个系统高概率的正常运转，不会因为改一个Bug而产生另一个Bug

### Rust中的测试
Rust中的测试分为两个部分
* **文档测试**
> 文档测试通常在函数前面或者类前面，通过文档测试来保证该函数的运行能符合我们的预期，通常` /// ``` ` 包围，以下为测试示例，如果仅仅以`///`开头那么测试
```RUST
/// 测试vec的大小 
///
/// use std::vec::Vec;
/// 
/// let mut vec = Vec::new();
/// assert_eq!(vec.len(), 0);
/// vec.push(1);
/// assert_eq!(vec.len(), 1);
fn show_test() {

}
```
此时我们运行`cargo test`可以看的到如下输出:
```
running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
```
此时并不能识别我们的文档测试用例，那么我们在代码前后加上` /// ``` `再来运行

```RUST
/// 测试vec的大小 
///
/// ```
/// use std::vec::Vec;
/// 
/// let mut vec = Vec::new();
/// assert_eq!(vec.len(), 0);
/// vec.push(1);
/// assert_eq!(vec.len(), 1);
/// ```
fn show_test() {

}
```
将得到如下输出
```
running 1 test
test src\lib.rs - show_test (line 3) ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.22s 
```
此时测试通过自动化模块

* **测试模块**
这是每个模块下可以通过自定义测试函数来对每个类进行自动化测试，让我们来看下面一个例子：
```RUST
fn str_len(s: &str) -> usize {
 s.len()
}

async fn str_len_async(s: &str) -> usize {
 // 做些异步的事情
 s.len()
}

#[cfg(test)]
#[allow(non_snake_case)]
mod tests {
 use super::*;

 #[test]
 fn test_str_len() {
 assert_eq!(str_len("x5ff"), 4);
 }
```
此时运行测试结果很完美的通过测试
```
running 1 test
test tests::test_str_len ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s 
```
当我们将`str_len`->`str_len_async`时，那么他提示我们
```
error[E0369]: binary operation `==` cannot be applied to type `impl Future<Output = usize>` 
 --> src\lib.rs:29:9
 |
29 | assert_eq!(str_len_async("x5ff"), 4);
 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 | |
 | impl Future<Output = usize>
 | {integer}
 |
 = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0277]: `impl Future<Output = usize>` doesn't implement `Debug`
 --> src\lib.rs:29:9
 |
29 | assert_eq!(str_len_async("x5ff"), 4);
 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `impl Future<Output = usize>` cannot be formatted using `{:?}` because it doesn't implement `Debug`
 |
 = help: the trait `Debug` is not implemented for `impl Future<Output = usize>`
 = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)

Some errors have detailed explanations: E0277, E0369.
For more information about an error, try `rustc --explain E0277`.
```
因为异步返回的结果是Future，所以我们无法通过编译。

> 那么异步的函数如何通过自动化测试呢？

我们尝试将测试函数改成异步
```
mod tests {
 use super::*;

 #[test]
 async fn test_str_len() {
 assert_eq!(str_len_async("x5ff").await, 4);
 }
}
```
编译器提示我们，因为编译器暂时不能支持异步的测试
```
error: async functions cannot be used for tests
 --> src\lib.rs:28:5
 |
28 | async fn test_str_len() {
 | ^----
 | |
 | _____`async` because of this
 | |
29 | | assert_eq!(str_len_async("x5ff").await, 4);
30 | | }
 | |_____^
```

#### 异步测试的两种方法
此处讲的依赖`tokio`的`runtime`，其它的异步为类似。

* **用`#[tokio::test]`来完成异步测试**
首先我们依赖：
```TOML
[dependencies]
tokio = { version = "*", features = [
 "macros",
 "test-util",
] }
tokio-test = "0.4.3"
```
此刻我们将代码改写成：
```RUST
#[cfg(test)]
#[allow(non_snake_case)]
mod tests {
 use super::*;

 #[tokio::test]
 async fn test_str_len() {
 assert_eq!(str_len_async("x5ff").await, 4);
 }
}
```
此时运行`cargo test`，将正常的运行通过

* **用宏定义来完成异步测试**
> 此方法运用的是通过同步函数中运行一个runtime来运行异步函数

以下是我们的宏定义及调用
```
macro_rules! aw {
 ($e:expr) => {
 tokio_test::block_on($e)
 };
}
#[test]
fn test_str_len_async_2() {
 assert_eq!(aw!(str_len_async("x5ff")), 4);
}
```
此时运行`cargo test`，将正常的运行通过
```
running 2 tests
test tests::test_str_len_async_2 ... ok
test tests::test_str_len ... ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s 
```
但是此时如果是局部测试，该方法有另一个好处，编辑器的识别度较高，能更好的显示支持
![image.png](https://note.youdao.com/yws/res/13597/WEBRESOURCEf73bc5351affdaca1c71b4c8c16f1bcb)

### 小结
测试是编程中不可缺少的伙伴，他可以让我们更早的发现问题解决问题，编写测试用例可能看起来会慢一些，但是对后期可能潜在的Bug的排查会节省大量的时间。

点击 **[关注]**，**[在看]**，**[点赞]** 是对作者最大的支持

34干货系列从零用Rust编写负载均衡及代理，异步测试在Rust中的实现

用Rust实现http/https代理, socks5代理, 负载均衡, 反向代理, 静态文件服务器，四层TCP/UDP转发，websocket转发, 内网穿透nat 