anydoor 0.0.1

A tool for forwarding traffic to a remote server
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

mod forwarder;
mod monitor;
mod storage;

use axum::{
    extract::State,
    routing::{get, post, delete},
    Router, Json,
};
use std::net::SocketAddr;
use tracing_subscriber;
use std::sync::Arc;
use forwarder::{ForwardManager, ForwardRule};
use storage::FileStorage;

type SharedState = Arc<AppState>;

struct AppState {
    forward_manager: ForwardManager,
}

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt::init();

    // 初始化存储
    let storage = FileStorage::new("data/rules.json")
        .expect("Failed to initialize storage");
    
    let forward_manager = ForwardManager::new(storage);
    
    // 恢复已保存的规则
    forward_manager.restore_rules()
        .await
        .expect("Failed to restore rules");

    let state = Arc::new(AppState {
        forward_manager,
    });

    let app = Router::new()
        .route("/api/stats", get(get_stats))
        .route("/api/forward", post(create_forward))
        .route("/api/forward/:id", delete(delete_forward))
        .route("/api/forward", get(list_forwards))
        .with_state(state);

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("Listening on {}", addr);
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

async fn get_stats() -> axum::Json<monitor::SystemStats> {
    let monitor = monitor::Monitor::new();
    let stats = monitor.collect_stats().await.unwrap();
    axum::Json(stats)
}

async fn create_forward(
    State(state): State<SharedState>,
    Json(rule): Json<ForwardRule>,
) -> Result<Json<ForwardRule>, String> {
    state
        .forward_manager
        .add_rule(rule.clone())
        .await
        .map_err(|e| e.to_string())?;
    
    Ok(Json(rule))
}

async fn delete_forward(
    State(state): State<SharedState>,
    axum::extract::Path(id): axum::extract::Path<String>,
) -> Result<(), String> {
    state
        .forward_manager
        .remove_rule(&id)
        .await
        .map_err(|e| e.to_string())
}

async fn list_forwards(
    State(state): State<SharedState>,
) -> Json<Vec<ForwardRule>> {
    Json(state.forward_manager.get_rules().await)
}