volo-http 0.5.5

HTTP framework implementation of volo.
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

//! Service for serving a directory.
//!
//! This module includes [`ServeDir`], which can be used for serving a directory through a
//! catch-all uri like `/static/{*path}` or `Router::nest_service`.
//!
//! # Examples
//!
//! ```
//! use volo_http::server::{
//!     route::{Router, get},
//!     utils::ServeDir,
//! };
//!
//! let router: Router = Router::new()
//!     .route("/", get(|| async { "Hello, World" }))
//!     .nest_service("/static/", ServeDir::new("."));
//! ```
//!
//! The `"."` means `ServeDir` will serve the CWD (current working directory) and then you can
//! access any file in the directory.

use std::{
    fs,
    marker::PhantomData,
    path::{Path, PathBuf},
};

use http::{header::HeaderValue, status::StatusCode};
use motore::service::Service;

use super::FileResponse;
use crate::{context::ServerContext, request::Request, response::Response, server::IntoResponse};

/// [`ServeDir`] is a service for sending files from a given directory.
pub struct ServeDir<E, F> {
    path: PathBuf,
    mime_getter: F,
    _marker: PhantomData<fn(E)>,
}

impl<E> ServeDir<E, fn(&Path) -> HeaderValue> {
    /// Create a new [`ServeDir`] service with the given path.
    ///
    /// # Panics
    ///
    /// - Panics if the path is invalid
    /// - Panics if the path is not a directory
    pub fn new<P>(path: P) -> Self
    where
        P: AsRef<Path>,
    {
        let path = fs::canonicalize(path).expect("ServeDir: failed to canonicalize path");
        assert!(path.is_dir());
        Self {
            path,
            mime_getter: guess_mime,
            _marker: PhantomData,
        }
    }

    /// Set a function for getting mime from file path.
    ///
    /// By default, [`ServeDir`] will use `mime_guess` crate for guessing a mime through the file
    /// extension name.
    pub fn mime_getter<F>(self, mime_getter: F) -> ServeDir<E, F>
    where
        F: Fn(&Path) -> HeaderValue,
    {
        ServeDir {
            path: self.path,
            mime_getter,
            _marker: self._marker,
        }
    }
}

impl<B, E, F> Service<ServerContext, Request<B>> for ServeDir<E, F>
where
    B: Send,
    F: Fn(&Path) -> HeaderValue + Sync,
{
    type Response = Response;
    type Error = E;

    async fn call(
        &self,
        _: &mut ServerContext,
        req: Request<B>,
    ) -> Result<Self::Response, Self::Error> {
        // Get relative path from uri
        let path = req.uri().path();
        let path = path.strip_prefix('/').unwrap_or(path);

        tracing::trace!("[Volo-HTTP] ServeDir: path: {path}");

        // Join to the serving directory and canonicalize it
        let path = self.path.join(path);
        let Ok(path) = fs::canonicalize(path) else {
            return Ok(StatusCode::NOT_FOUND.into_response());
        };

        // Reject file which is out of the serving directory
        if path.strip_prefix(self.path.as_path()).is_err() {
            tracing::debug!("[Volo-HTTP] ServeDir: illegal path: {}", path.display());
            return Ok(StatusCode::FORBIDDEN.into_response());
        }

        // Check metadata and permission
        if !path.is_file() {
            return Ok(StatusCode::NOT_FOUND.into_response());
        }

        // Get mime and return it!
        let content_type = (self.mime_getter)(&path);
        let Ok(resp) = FileResponse::new(path, content_type) else {
            return Ok(StatusCode::INTERNAL_SERVER_ERROR.into_response());
        };
        Ok(resp.into_response())
    }
}

pub fn guess_mime(path: &Path) -> HeaderValue {
    mime_guess::from_path(path)
        .first_raw()
        .map(HeaderValue::from_static)
        .unwrap_or_else(|| HeaderValue::from_str(mime::APPLICATION_OCTET_STREAM.as_ref()).unwrap())
}

#[cfg(test)]
mod serve_dir_tests {
    use http::{StatusCode, method::Method};

    use super::ServeDir;
    use crate::{
        body::Body,
        server::{Router, Server},
    };

    #[tokio::test]
    async fn read_file() {
        // volo/volo-http
        let router: Router<Option<Body>> =
            Router::new().nest_service("/static/", ServeDir::new("."));
        let server = Server::new(router).into_test_server();
        // volo/volo-http/Cargo.toml
        assert!(
            server
                .call_route(Method::GET, "/static/Cargo.toml", None)
                .await
                .status()
                .is_success()
        );
        // volo/volo-http/src/lib.rs
        assert!(
            server
                .call_route(Method::GET, "/static/src/lib.rs", None)
                .await
                .status()
                .is_success()
        );
        // volo/volo-http/Cargo.lock, this file does not exist
        assert_eq!(
            server
                .call_route(Method::GET, "/static/Cargo.lock", None)
                .await
                .status(),
            StatusCode::NOT_FOUND
        );
        // volo/Cargo.toml, this file should be rejected
        assert_eq!(
            server
                .call_route(Method::GET, "/static/../Cargo.toml", None)
                .await
                .status(),
            StatusCode::FORBIDDEN
        );
    }
}