mrps 0.1.1

Mini reverse proxy 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

use std::ffi::OsStr;
use std::error::Error;
use std::fs::read_to_string;
use std::path::{Path, PathBuf};
use serde_derive::Deserialize;

#[derive(Deserialize, Clone, Debug)]
pub struct Route {
    pub path: String,
    pub method: String,
    pub template: String
}

#[derive(Deserialize, Clone, Debug, Default)]
pub struct Config {
    pub all: Option<bool>,
    pub key: Option<PathBuf>,
    pub cors: Option<Vec<String>>,
    pub port: Option<u16>,
    pub cert: Option<PathBuf>,
    pub data: Option<PathBuf>, 
    pub ignore: Option<Vec<String>>,
    pub assets: Option<PathBuf>, 
    pub routes: Option<Vec<Route>>,
    pub templates: Option<PathBuf>
}

impl Config {
    pub fn new(file: Option<&Path>) -> Result<Config, Box<dyn Error>> {
        match file {
            None => Ok(Default::default()),
            Some(file) => {
                let data = match read_to_string(file) {
                    Ok(data) => data,
                    Err(err) => {
                        return Err(format!(
                            "Unable to read <{}>\n{:#}",
                            file.display(), err
                        ).into());
                    }
                };

                let mut config: Config = match file.extension().unwrap_or(
                    OsStr::new("")
                ).to_str() {
                    Some("json") => {
                        match serde_json::from_str(&data) {
                            Ok(config) => config,
                            Err(err) => {
                                return Err(format!(
                                    "Unable to parse config file <{}>!\n{:#}",
                                    file.display(), err
                                ).into());
                            }
                        }
                    },
                    Some("toml") => {
                        match toml::from_str(&data) {
                            Ok(config) => config,
                            Err(err) => {
                                return Err(format!(
                                    "Unable to parse config file <{}>!\n{:#}",
                                    file.display(), err
                                ).into());
                            }
                        }
                    },
                    _ => {
                        return Err(format!(
                            "Configuration file <{}> must be .json or .toml",
                            file.display()
                        ).into());
                    }
                };

                if let Some(dir) = file.parent() {
                    if let Some(templates) = config.templates {
                        config.templates = Some(dir.join(templates));
                    }

                    if let Some(data) = config.data {
                        config.data = Some(dir.join(data));
                    }
                    
                    if let Some(assets) = config.assets {
                        config.assets = Some(dir.join(assets));
                    }
                    
                    if let Some(cert) = config.cert {
                        config.cert = Some(dir.join(cert));
                    }
                    
                    if let Some(key) = config.key {
                        config.key = Some(dir.join(key));
                    }
                }

                Ok(config)
            }
        }
    }
}