vetis 0.1.4-beta.8

Very Tiny 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
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

use std::path::PathBuf;

/// Builder for creating FileMetadata instances
pub struct FileMetadataBuilder {
    mime: Option<String>,
    size: u64,
    modified: std::time::SystemTime,
    etag: Option<String>,
}

impl FileMetadataBuilder {
    /// Set the MIME type of the file
    pub fn mime(mut self, mime: Option<String>) -> Self {
        self.mime = mime;
        self
    }

    /// Set the size of the file
    pub fn size(mut self, size: u64) -> Self {
        self.size = size;
        self
    }

    /// Set the last modified time of the file
    pub fn modified(mut self, modified: std::time::SystemTime) -> Self {
        self.modified = modified;
        self
    }

    /// Set the ETag of the file
    pub fn etag(mut self, etag: Option<String>) -> Self {
        self.etag = etag;
        self
    }

    /// Build the FileMetadata instance
    pub fn build(self) -> FileMetadata {
        FileMetadata { mime: self.mime, size: self.size, modified: self.modified, etag: self.etag }
    }
}

/// Metadata for a file
#[derive(Clone)]
pub struct FileMetadata {
    mime: Option<String>,
    size: u64,
    modified: std::time::SystemTime,
    etag: Option<String>,
}

impl FileMetadata {
    /// Create a new FileMetadataBuilder
    pub fn builder() -> FileMetadataBuilder {
        FileMetadataBuilder {
            mime: None,
            size: 0,
            modified: std::time::SystemTime::now(),
            etag: None,
        }
    }

    /// Get the MIME type of the file
    pub fn mime(&self) -> Option<&String> {
        self.mime.as_ref()
    }

    /// Get the size of the file
    pub fn size(&self) -> u64 {
        self.size
    }

    /// Get the last modified time of the file
    pub fn modified(&self) -> std::time::SystemTime {
        self.modified
    }

    /// Get the ETag of the file
    pub fn etag(&self) -> Option<&String> {
        self.etag.as_ref()
    }
}

pub trait File {
    fn metadata(&self) -> &FileMetadata;
    fn data(&self) -> Option<&Vec<u8>>;
    fn path(&self) -> Option<&PathBuf>;
}

/// Represents a file that can be either in memory or on disk
#[derive(Clone)]
pub enum FileSource {
    /// File data in memory
    Data {
        /// The file data
        data: Vec<u8>,
        /// The file metadata
        metadata: FileMetadata,
    },
    /// File path on disk
    Path {
        /// The file path
        path: PathBuf,
        /// The file metadata
        metadata: FileMetadata,
    },
}

impl File for FileSource {
    /// Get the metadata for the file
    fn metadata(&self) -> &FileMetadata {
        match self {
            FileSource::Data { metadata, .. } => metadata,
            FileSource::Path { metadata, .. } => metadata,
        }
    }

    /// Get the data for the file (if in memory)
    fn data(&self) -> Option<&Vec<u8>> {
        match self {
            FileSource::Data { data, .. } => Some(data),
            FileSource::Path { .. } => None,
        }
    }

    /// Get the path for the file (if on disk)
    fn path(&self) -> Option<&PathBuf> {
        match self {
            FileSource::Data { .. } => None,
            FileSource::Path { path, .. } => Some(path),
        }
    }
}