servlin 0.8.0

Modular HTTP server library, threaded handlers and async performance
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

#![allow(clippy::unnecessary_debug_formatting)]
use std::cmp::Ordering;
use std::collections::BinaryHeap;
use std::fs::remove_file;
use std::path::{Path, PathBuf};
use std::time::{Duration, SystemTime};

pub struct PrefixFile {
    pub path: PathBuf,
    pub mtime: SystemTime,
    pub len: u64,
}
impl PartialEq for PrefixFile {
    fn eq(&self, other: &Self) -> bool {
        other.mtime.eq(&self.mtime)
    }
}
impl Eq for PrefixFile {}
impl PartialOrd for PrefixFile {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}
impl Ord for PrefixFile {
    fn cmp(&self, other: &Self) -> Ordering {
        other.mtime.cmp(&self.mtime)
    }
}

pub struct PrefixFileSet {
    files: BinaryHeap<PrefixFile>,
    len: u64,
}
impl PrefixFileSet {
    /// # Errors
    /// Returns `Err` when it fails to list the directory or get the metadata of files in it.
    ///
    /// # Panics
    /// Panics on platforms that do not support [`std::fs::Metadata::modified`].
    pub fn new(path_prefix: &Path) -> Result<Self, String> {
        let dir = path_prefix
            .parent()
            .ok_or_else(|| format!("path has no parent: {path_prefix:?}"))?;
        let mut files = BinaryHeap::new();
        for dir_entry in dir
            .read_dir()
            .map_err(|e| format!("error reading dir {dir:?}: {e:?}"))?
        {
            let dir_entry = dir_entry.map_err(|e| format!("error reading dir {dir:?}: {e:?}"))?;
            let path = dir_entry.path();
            if path.starts_with(path_prefix) {
                let metadata = dir_entry.metadata().map_err(|e| {
                    format!("error reading metadata of {:?}: {e:?}", dir_entry.path())
                })?;
                if metadata.is_file() {
                    let mtime = metadata.modified().unwrap();
                    let len = metadata.len();
                    files.push(PrefixFile { path, mtime, len });
                }
            }
        }
        let len = files.iter().map(|f| f.len).sum();
        Ok(Self { files, len })
    }

    /// # Errors
    /// Returns `Err` when it fails to delete the file.
    #[allow(clippy::missing_panics_doc)]
    pub fn delete_oldest(&mut self) -> Result<(), String> {
        let file = self.files.peek().unwrap();
        remove_file(&file.path)
            .map_err(|e| format!("error deleting file {:?}: {e:?}", file.path))?;
        self.len -= file.len;
        self.files.pop();
        Ok(())
    }

    /// # Errors
    /// Returns `Err` when it fails to delete a file.
    pub fn delete_older_than(&mut self, now: SystemTime, duration: Duration) -> Result<(), String> {
        let min_mtime = now - duration;
        while let Some(file) = self.files.peek() {
            if file.mtime < min_mtime {
                self.delete_oldest()?;
            } else {
                break;
            }
        }
        Ok(())
    }

    /// # Errors
    /// Returns `Err` when it fails to delete a file.
    pub fn delete_oldest_while_over_max_len(&mut self, max_len: u64) -> Result<(), String> {
        while self.len > max_len {
            self.delete_oldest()?;
        }
        Ok(())
    }

    pub fn push(&mut self, file: PrefixFile) {
        self.files.push(file);
    }
}