e62rs 1.5.0

An in-terminal E621/926 browser.
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

//! server configuration stuff
use {
    color_eyre::eyre::Result,
    std::{net::SocketAddr, path::PathBuf},
};

#[derive(Debug, Clone)]
/// configuration for the server
pub struct ServerConfig {
    /// the path to the downloaded media
    pub media_directory: PathBuf,
    /// the address to bind to
    pub bind_address: SocketAddr,
    /// the max file size to index
    pub max_file_size: Option<u64>,
    /// whether to enable filtering by metadata
    pub enable_metadata_filtering: bool,
    /// whether to cache metadata
    pub cache_metadata: bool,
    /// the number of threads to use when loading
    pub num_threads: usize,
}

impl ServerConfig {
    /// make a builder
    pub fn builder() -> ServerConfigBuilder {
        ServerConfigBuilder::default()
    }

    /// get the current set media directory
    pub fn media_directory(&self) -> &PathBuf {
        &self.media_directory
    }

    /// get the current bind addr
    pub fn bind_address(&self) -> &SocketAddr {
        &self.bind_address
    }
}

#[derive(Default)]
/// a builder for the server configuration
pub struct ServerConfigBuilder {
    /// the path to the downloaded media
    media_directory: Option<PathBuf>,
    /// the address to bind to
    bind_address: Option<SocketAddr>,
    /// the max file size to index
    max_file_size: Option<u64>,
    /// whether to enable filtering by metadata
    enable_metadata_filtering: bool,
    /// whether to cache metadata
    cache_metadata: bool,
    /// the number of threads to use when loading
    num_threads: usize,
}

impl ServerConfigBuilder {
    /// make a new ServerConfigBuilder
    pub fn new() -> Self {
        Self::default()
    }

    /// set the media directory
    pub fn media_directory(mut self, dir: PathBuf) -> Self {
        self.media_directory = Some(dir);
        self
    }

    /// set the bind address
    pub fn bind_address(mut self, addr: SocketAddr) -> Self {
        self.bind_address = Some(addr);
        self
    }

    /// set the max file size
    pub fn max_file_size(mut self, size: u64) -> Self {
        self.max_file_size = Some(size);
        self
    }

    /// set whether to enable metadata filtering
    pub fn enable_metadata_filtering(mut self, enabled: bool) -> Self {
        self.enable_metadata_filtering = enabled;
        self
    }

    /// set the metadata caching mode
    pub fn cache_metadata(mut self, enabled: bool) -> Self {
        self.cache_metadata = enabled;
        self
    }

    /// set the number of load threads
    pub fn num_threads(mut self, threads: usize) -> Self {
        self.num_threads = threads;
        self
    }

    /// build the ServerConfigBuilder into a ServerConfig
    pub fn build(self) -> Result<ServerConfig, String> {
        let media_directory = self
            .media_directory
            .ok_or_else(|| "Media directory is required".to_string())?;

        if !media_directory.exists() {
            return Err(format!(
                "Media directory does not exist: {}",
                media_directory.display()
            ));
        }

        let bind_address = self
            .bind_address
            .unwrap_or_else(|| "127.0.0.1:23794".parse().unwrap());

        Ok(ServerConfig {
            media_directory,
            bind_address,
            max_file_size: self.max_file_size,
            enable_metadata_filtering: self.enable_metadata_filtering,
            cache_metadata: self.cache_metadata,
            num_threads: self.num_threads,
        })
    }
}