flyer 3.0.7

HTTP framework for rust
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

use std::{
    path::{Component, Path, PathBuf},
    time::Duration,
};

use bytes::Bytes;
use mime_guess::from_path;
use moka::sync::Cache;

use crate::{
    hooks::Hook,
    request::Request,
    response::{HTTP_INTERNAL_SERVER_ERROR, HTTP_NOT_FOUND, HTTP_OK, Response},
    routing::next::Next,
};

#[derive(Clone)]
pub(crate) struct Asset {
    pub data: Bytes,
    pub content_type: String,
}

impl Asset {
    pub fn new(data: Bytes, content_type: String) -> Self {
        Self {
            data: data,
            content_type: content_type
        }
    }
}

pub struct AssetsHook {
    base_dir: PathBuf,
    max_file_size_bytes: usize,
    cache: Cache<String, Asset>,
}

impl AssetsHook {
    pub fn new(directory: impl AsRef<Path>, expires_in: Duration, max_cache_size_kilobytes: u64) -> Self {
        let base_dir = directory
            .as_ref()
            .canonicalize()
            .unwrap_or_else(|_| directory.as_ref().to_path_buf());

        let max_file_size_bytes = (max_cache_size_kilobytes as usize).saturating_mul(1024);

        let mut builder = Cache::builder()
            .max_capacity(100_000_000)
            .weigher(|_key, asset: &Asset| asset.data.len() as u32);

        if !expires_in.is_zero() {
            builder = builder.time_to_live(expires_in);
        }

        Self {
            base_dir,
            max_file_size_bytes,
            cache: builder.build(),
        }
    }

    fn get_safe_path(&self, req_path: &str) -> Option<PathBuf> {
        let mut path = self.base_dir.clone();

        for component in Path::new(req_path).components() {
            match component {
                Component::Normal(c) => path.push(c),
                Component::RootDir | Component::CurDir => continue,
                _ => return None,
            }
        }

        if path.is_file() {
            return Some(path);
        }

        None
    }

    fn guess_content_type(path: &Path) -> String {
        from_path(path)
            .first_or_octet_stream()
            .to_string()
    }
}

impl Hook for AssetsHook {
    async fn before(&self,req: Request, res: Response, next: Next) -> Response {
        next.handle(req, res)
    }

    async fn after(&self, req: Request, res: Response, next: Next) -> Response {
        if res.status_code != HTTP_NOT_FOUND {
            return next.handle(req, res);
        }

        let path = req.path();

        if let Some(asset) = self.cache.get(&path) {
            return res
                .status_code(HTTP_OK)
                .body(asset.data)
                .set_header("Content-Type", asset.content_type);
        }

        let Some(file_path) = self.get_safe_path(&path) else {
            return next.handle(req, res)
        };

        let Ok(file_bytes) = tokio::fs::read(&file_path).await else {
            return res.status_code(HTTP_INTERNAL_SERVER_ERROR);
        };

        let data = Bytes::from(file_bytes);
        let content_type = Self::guess_content_type(&file_path);

        if data.len() < self.max_file_size_bytes {
            self.cache.insert(path.to_string(), Asset::new(data.clone(), content_type.clone()));
        }

        res
            .status_code(HTTP_OK)
            .body(data)
            .set_header("Content-Type", content_type)
    }
}