fsv 0.1.3

fsv
Documentation 
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use axum::{
    extract::{Request, State},
    http::Method,
    response::{IntoResponse, Response},
};
use percent_encoding::percent_decode_str;

use crate::error::FsvError;
use crate::handlers;
use crate::types::AppState;
use crate::webdav;

/// Unified handler that routes based on HTTP method:
/// - GET: Serve HTML (root) or files
/// - POST: API endpoints (determined by path)
/// - PROPFIND/OPTIONS/HEAD: WebDAV protocol
pub async fn unified_handler(
    State(state): State<AppState>,
    method: Method,
    request: Request,
) -> Result<Response, FsvError> {
    // Decode URL-encoded path (e.g., %20 -> space)
    let path = percent_decode_str(request.uri().path())
        .decode_utf8()
        .unwrap_or_default()
        .to_string();

    match method {
        // WebDAV methods
        Method::OPTIONS => webdav::webdav_handler(State(state), method, request).await,
        ref m if m.as_str() == "PROPFIND" => {
            webdav::webdav_handler(State(state), method, request).await
        }
        Method::HEAD => webdav::webdav_handler(State(state), method, request).await,

        // GET: HTML or file download
        Method::GET => handle_get(State(state), &path, request).await,

        // POST: API calls
        Method::POST => handle_post(State(state), &path, request).await,

        _ => Ok(axum::response::Response::builder()
            .status(405)
            .body("Method not allowed".into())
            .unwrap()),
    }
}

/// Handle GET requests - serve HTML or files
async fn handle_get(
    State(state): State<AppState>,
    path: &str,
    request: Request,
) -> Result<Response, FsvError> {
    // Root path returns the HTML UI
    if path == "/" {
        return Ok(handlers::index().await.into_response());
    }

    // Check for Range header
    let range_header = request
        .headers()
        .get(axum::http::header::RANGE)
        .and_then(|v| v.to_str().ok());

    // All other paths: serve as files
    let rel_path = path.trim_start_matches('/');
    let rel_path = if rel_path.is_empty() {
        None
    } else {
        Some(rel_path)
    };

    if let Some(range) = range_header {
        webdav::webdav_get_range(&state, rel_path, range).await
    } else {
        webdav::webdav_get(&state, rel_path).await
    }
}

/// Handle POST requests - API endpoints
async fn handle_post(
    State(state): State<AppState>,
    path: &str,
    request: Request,
) -> Result<Response, FsvError> {
    match path {
        "/list" => {
            let query = request.uri().query().unwrap_or("");
            let params: crate::types::FileParams =
                serde_urlencoded::from_str(query).unwrap_or_default();
            handlers::list(State(state), axum::extract::Query(params))
                .await
                .map(|json| json.into_response())
        }

        "/file" => {
            let query = request.uri().query().unwrap_or("");
            let params: crate::types::FileParams =
                serde_urlencoded::from_str(query).unwrap_or_default();
            handlers::file(State(state), axum::extract::Query(params))
                .await
                .map(|resp| resp.into_response())
        }

        "/ws-info" => Ok(handlers::ws_info(State(state))
            .await
            .into_response()),

        "/health" => Ok(handlers::health()
            .await
            .into_response()),

        _ => Ok(axum::response::Response::builder()
            .status(404)
            .body("API endpoint not found".into())
            .unwrap()),
    }
}