CNWei/mock-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

merge: 合并0321分支的热重载功能与body字段匹配支持

Browse Source
This commit is contained in:
CNWei
2026-03-25 16:59:09 +08:00
parent 5f3269bad5 3097a16465
commit 18e0ccad58
5 changed files with 155 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
src/handler.rs
View File

@@ -5,31 +5,29 @@ use axum::{
response::{IntoResponse, Response},
};
use std::collections::HashMap;
use std::sync::Arc;
use tokio_util::io::ReaderStream; // 需在 Cargo.toml 确认有 tokio-util
use std::sync::{Arc, RwLock}; // 必须引入 RwLock
use tokio_util::io::ReaderStream;
use crate::router::MockRouter;
/// 共享的应用状态
/// 共享的应用状态，router 现在由 RwLock 保护以支持热重载
pub struct AppState {
pub router: MockRouter,
pub router: RwLock<MockRouter>,
}
/// 全局统一请求处理函数
pub async fn mock_handler(
State(state): State<Arc<AppState>>,
State(state): State<Arc<AppState>>, // State 必须是第一个或靠前的参数
method: Method,
headers: HeaderMap,
Query(params): Query<HashMap<String, String>>,
req: Request<Body>,
req: Request<Body>, // Request<Body> 必须是最后一个参数
) -> impl IntoResponse {
// let path = req.uri().path();
// 1. 【关键】将需要的数据克隆出来，断开与 req 的借用关系
// 1. 提取 path 和 method
let path = req.uri().path().to_string();
let method_str = method.as_str().to_string();
// 1. 将 Axum HeaderMap 转换为简单的 HashMap 供 Router 使用
// 2. 现在可以安全地消耗 req 了，因为上面没有指向 req 内部的引用了
// 2. 读取请求 body（用于 body 字段匹配）
let body_bytes = match axum::body::to_bytes(req.into_body(), 10 * 1024 * 1024).await {
Ok(bytes) => bytes,
Err(_) => {
@@ -39,43 +37,43 @@ pub async fn mock_handler(
.unwrap();
}
};
let incoming_json: Option<serde_json::Value> = serde_json::from_slice(&body_bytes).ok();
// 3. 将 Axum HeaderMap 转换为简单的 HashMap
let mut req_headers = HashMap::new();
for (name, value) in headers.iter() {
if let Ok(v) = value.to_str() {
req_headers.insert(name.as_str().to_string(), v.to_string());
}
}
// 2. 执行匹配逻辑
if let Some(rule) =
state
.router
.match_rule(&method_str, &path, &params, &req_headers, &incoming_json)
{
// 3. 处理模拟延迟
// 4. 执行匹配逻辑：先获取读锁 (Read Lock)
let maybe_rule = {
let router = state.router.read().expect("Failed to acquire read lock");
router.match_rule(&method_str, &path, &params, &req_headers, &incoming_json).cloned()
// 此处使用 .cloned() 以便尽早释放读锁，避免阻塞热重载写锁
};
if let Some(rule) = maybe_rule {
// 5. 处理模拟延迟
if let Some(ref settings) = rule.settings {
if let Some(delay) = settings.delay_ms {
tokio::time::sleep(std::time::Duration::from_millis(delay)).await;
}
}
// 4. 构建响应基础信息
// 6. 构建响应
let status = StatusCode::from_u16(rule.response.status).unwrap_or(StatusCode::OK);
let mut response_builder = Response::builder().status(status);
// 注入 YAML 定义的 Header
if let Some(ref h) = rule.response.headers {
for (k, v) in h {
// println!("{}:{}",k.clone(), v.clone());
response_builder = response_builder.header(k, v);
}
}
// 5. 执行 Smart Body 协议逻辑
// 7. Smart Body 逻辑
if let Some(file_path) = rule.response.get_file_path() {
// A. 文件模式：异步打开文件并转换为流，实现低内存占用
match tokio::fs::File::open(file_path).await {
Ok(file) => {
let stream = ReaderStream::new(file);
@@ -91,13 +89,12 @@ pub async fn mock_handler(
.unwrap(),
}
} else {
// B. 内联模式：直接返回字符串内容
// 内联模式：直接返回字符串内容
response_builder
.body(Body::from(rule.response.body.clone()))
.unwrap()
}
} else {
println!("请求头{:?}", req_headers.clone());
// 匹配失败返回 404
Response::builder()
.status(StatusCode::NOT_FOUND)

48
src/main.rs
View File

@@ -1,43 +1,63 @@
use std::net::SocketAddr;
use std::path::Path;
use std::sync::Arc;
use std::sync::{Arc, RwLock};
use std::time::Duration;
use axum::{routing::any, Router};
use notify_debouncer_mini::{new_debouncer, notify::*};
use mock_server::loader::MockLoader;
use mock_server::router::MockRouter;
use mock_server::handler::{mock_handler, AppState};
#[tokio::main]
async fn main() {
// 1. 初始化日志（建议添加，方便观察加载情况）
// 需要在 Cargo.toml 添加 tracing-subscriber = "0.3"
tracing_subscriber::fmt::init();
// 2. 递归加载所有的 YAML 配置文件
let mocks_dir = Path::new("./mocks");
if !mocks_dir.exists() {
println!("Warning: 'mocks/' directory not found. Creating it...");
std::fs::create_dir_all(mocks_dir).unwrap();
}
// 1. 初始加载
println!("Scanning mocks directory...");
let index = MockLoader::load_all_from_dir(mocks_dir);
// 3. 构建路由引擎并包装为共享状态
let router_engine = MockRouter::new(index);
let shared_state = Arc::new(AppState {
router: router_engine,
router: RwLock::new(MockRouter::new(index)),
});
// 4. 配置 Axum 路由
// 使用 any(mock_handler) 意味着它会接管所有 HTTP 方法和所有路径的请求
// 2. 设置热加载监听器
let state_for_watcher = shared_state.clone();
let watch_path = mocks_dir.to_path_buf();
let (tx, rx) = std::sync::mpsc::channel();
// 200ms 防抖，防止编辑器保存文件时产生多次干扰
let mut debouncer = new_debouncer(Duration::from_millis(200), tx).unwrap();
debouncer.watcher().watch(&watch_path, RecursiveMode::Recursive).unwrap();
// 启动异步任务监听文件变动
tokio::spawn(async move {
while let Ok(res) = rx.recv() {
match res {
Ok(_) => {
println!("🔄 Detecting changes in mocks/, reloading...");
let new_index = MockLoader::load_all_from_dir(&watch_path);
// 获取写锁 (Write Lock) 更新索引
let mut writer = state_for_watcher.router.write().expect("Failed to acquire write lock");
*writer = MockRouter::new(new_index);
println!("✅ Mocks reloaded successfully.");
}
Err(e) => eprintln!("Watcher error: {:?}", e),
}
}
});
// 3. 配置 Axum 路由
let app = Router::new()
.fallback(any(mock_handler))
.with_state(shared_state);
// 5. 启动服务
let addr = SocketAddr::from(([127, 0, 0, 1], 8080));
println!("🚀 Rust Mock Server is running on http://{}", addr);
println!("Ready to handle requests based on your YAML definitions.");
println!("🚀 Server running at http://{}", addr);
let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
axum::serve(listener, app).await.unwrap();