rust_web_server/entry_point/command_line_args/
mod.rs

1use std::env;
2use crate::entry_point::Config;
3
4#[cfg(test)]
5mod tests;
6
7pub fn override_environment_variables_from_command_line_args() {
8    println!("\n  Start of Reading Command Line Arguments Section");
9
10    let args = env::args().collect();
11    let params = CommandLineArgument::get_command_line_arg_list();
12    CommandLineArgument::_parse(args, params);
13
14    println!("  End of Reading Command Line Arguments\n");
15}
16
17/// Returns the text to print for an informational flag — `--version` / `-V`
18/// or `--help` — if `args` (as from `env::args()`, program name first)
19/// contains one, so the binary can print it and exit before starting a
20/// server. `None` means start normally. `-h` is not a help alias: it's
21/// already `--cors-allow-headers`'s short form.
22pub fn informational_flag_output(args: &[String]) -> Option<String> {
23    let flags = args.iter().skip(1);
24    for arg in flags {
25        match arg.as_str() {
26            "--version" | "-V" => {
27                return Some(format!("rws {}\n", env!("CARGO_PKG_VERSION")));
28            }
29            "--help" => return Some(help_text()),
30            _ => {}
31        }
32    }
33    None
34}
35
36fn help_text() -> String {
37    let mut text = format!(
38        "rws {} — HTTP/1.1, HTTP/2 and HTTP/3 web server and reverse proxy\n\n\
39         Usage: rws [OPTIONS]\n\n\
40         Serves the current directory on http://0.0.0.0:7878 by default. Drop an\n\
41         rws.config.toml with [[route]]/[[upstream]] sections in the working\n\
42         directory to run as a config-driven reverse proxy instead.\n\n\
43         Options (each also settable via the environment variable shown):\n",
44        env!("CARGO_PKG_VERSION")
45    );
46    for argument in CommandLineArgument::get_command_line_arg_list() {
47        let flag = if argument.short_form.is_empty() {
48            format!("    --{}=<value>", argument.long_form)
49        } else {
50            format!("-{}, --{}=<value>", argument.short_form, argument.long_form)
51        };
52        let hint = argument._hint.unwrap_or_default();
53        text.push_str(&format!("  {:<44} {}\n  {:<44} [env: {}]\n", flag, hint, "", argument.environment_variable));
54    }
55    text.push_str("      --check[=<file>]                         Validate rws.config.toml (or <file>) and exit:\n");
56    text.push_str("                                               0 if it has no errors, 1 otherwise\n");
57    text.push_str("  -V, --version                                Print version and exit\n");
58    text.push_str("      --help                                   Print this help and exit\n\n");
59    text.push_str("Docs: https://rws8.tech\n");
60    text
61}
62
63pub struct CommandLineArgument {
64    pub short_form: String,
65    pub long_form: String,
66    pub environment_variable: String,
67    pub _hint: Option<String>,
68}
69
70impl CommandLineArgument {
71    pub fn get_command_line_arg_list() -> Vec<CommandLineArgument> {
72        let mut argument_list : Vec<CommandLineArgument> = vec![];
73
74        let argument = CommandLineArgument {
75            short_form: "p".to_string(),
76            long_form: "port".to_string(),
77            environment_variable: Config::RWS_CONFIG_PORT.to_string(),
78            _hint: Some("Port".to_string())
79        };
80        argument_list.push(argument);
81
82        let argument = CommandLineArgument {
83            short_form: "i".to_string(),
84            long_form: "ip".to_string(),
85            environment_variable: Config::RWS_CONFIG_IP.to_string(),
86            _hint: Some("IP or domain".to_string())
87        };
88        argument_list.push(argument);
89
90        let argument = CommandLineArgument {
91            short_form: "t".to_string(),
92            long_form: "thread-count".to_string(),
93            environment_variable: Config::RWS_CONFIG_THREAD_COUNT.to_string(),
94            _hint: Some("Number of threads".to_string())
95        };
96        argument_list.push(argument);
97
98
99        let argument = CommandLineArgument {
100            short_form: "a".to_string(),
101            long_form: "cors-allow-all".to_string(),
102            environment_variable: Config::RWS_CONFIG_CORS_ALLOW_ALL.to_string(),
103            _hint: Some("If set to true, will allow all CORS requests, other CORS properties will be ignored".to_string())
104        };
105        argument_list.push(argument);
106
107        let argument = CommandLineArgument {
108            short_form: "o".to_string(),
109            long_form: "cors-allow-origins".to_string(),
110            environment_variable: Config::RWS_CONFIG_CORS_ALLOW_ORIGINS.to_string(),
111            _hint: Some("Comma separated list of allowed origins, example: https://foo.example,https://bar.example".to_string())
112        };
113        argument_list.push(argument);
114
115        let argument = CommandLineArgument {
116            short_form: "m".to_string(),
117            long_form: "cors-allow-methods".to_string(),
118            environment_variable: Config::RWS_CONFIG_CORS_ALLOW_METHODS.to_string(),
119            _hint: Some("Comma separated list of allowed methods, example: POST,PUT".to_string())
120        };
121        argument_list.push(argument);
122
123        let argument = CommandLineArgument {
124            short_form: "h".to_string(),
125            long_form: "cors-allow-headers".to_string(),
126            environment_variable: Config::RWS_CONFIG_CORS_ALLOW_HEADERS.to_string(),
127            _hint: Some("Comma separated list of allowed request headers, in lowercase, example: content-type,x-custom-header".to_string())
128        };
129        argument_list.push(argument);
130
131        let argument = CommandLineArgument {
132            short_form: "c".to_string(),
133            long_form: "cors-allow-credentials".to_string(),
134            environment_variable: Config::RWS_CONFIG_CORS_ALLOW_CREDENTIALS.to_string(),
135            _hint: Some("If set to true, will allow to transmit credentials via CORS requests".to_string())
136        };
137        argument_list.push(argument);
138
139        let argument = CommandLineArgument {
140            short_form: "e".to_string(),
141            long_form: "cors-expose-headers".to_string(),
142            environment_variable: Config::RWS_CONFIG_CORS_EXPOSE_HEADERS.to_string(),
143            _hint: Some("Comma separated list of allowed response headers, in lowercase, example: content-type,x-custom-header".to_string())
144        };
145        argument_list.push(argument);
146
147        let argument = CommandLineArgument {
148            short_form: "g".to_string(),
149            long_form: "cors-max-age".to_string(),
150            environment_variable: Config::RWS_CONFIG_CORS_MAX_AGE.to_string(),
151            _hint: Some("How long results of preflight requests can be cached (in seconds)".to_string())
152        };
153        argument_list.push(argument);
154
155        let argument = CommandLineArgument {
156            short_form: "r".to_string(),
157            long_form: "request-allocation-size-in-bytes".to_string(),
158            environment_variable: Config::RWS_CONFIG_REQUEST_ALLOCATION_SIZE_IN_BYTES.to_string(),
159            _hint: Some("In bytes, how much memory to allocate for each request".to_string())
160        };
161        argument_list.push(argument);
162
163        let argument = CommandLineArgument {
164            short_form: "s".to_string(),
165            long_form: "tls-cert-file".to_string(),
166            environment_variable: Config::RWS_CONFIG_TLS_CERT_FILE.to_string(),
167            _hint: Some("Path to TLS certificate PEM file (enables HTTPS and HTTP/2)".to_string())
168        };
169        argument_list.push(argument);
170
171        let argument = CommandLineArgument {
172            short_form: "k".to_string(),
173            long_form: "tls-key-file".to_string(),
174            environment_variable: Config::RWS_CONFIG_TLS_KEY_FILE.to_string(),
175            _hint: Some("Path to TLS private key PEM file (enables HTTPS and HTTP/2)".to_string())
176        };
177        argument_list.push(argument);
178
179        // Long-form only (empty short_form): every single letter that reads
180        // naturally is taken. In rws.config.toml these are `http_redirect_port`
181        // at the top level and the keys of an `[acme]` section (`domains`,
182        // `email`, ...), which the config-file reader prefixes to `acme-*`.
183        let long_only = [
184            ("http-redirect-port", Config::RWS_CONFIG_HTTP_REDIRECT_PORT,
185                "Plain-HTTP port that 301-redirects to HTTPS (and answers ACME HTTP-01 challenges), e.g. 80"),
186            ("acme-domains", Config::RWS_CONFIG_ACME_DOMAINS,
187                "Comma separated domains to get a Let's Encrypt certificate for; enables automatic HTTPS"),
188            ("acme-email", Config::RWS_CONFIG_ACME_EMAIL,
189                "Contact email for the ACME account"),
190            ("acme-staging", Config::RWS_CONFIG_ACME_STAGING,
191                "If set to true, uses the Let's Encrypt staging environment (untrusted test certificates)"),
192            ("acme-directory", Config::RWS_CONFIG_ACME_DIRECTORY,
193                "ACME directory URL of a CA other than Let's Encrypt"),
194            ("acme-ca-file", Config::RWS_CONFIG_ACME_CA_FILE,
195                "PEM file of extra root CAs to trust for the ACME directory (private ACME CAs)"),
196            ("acme-challenge-port", Config::RWS_CONFIG_ACME_CHALLENGE_PORT,
197                "Port the CA connects to for HTTP-01 challenges (default 80)"),
198            ("acme-cert-path", Config::RWS_CONFIG_ACME_CERT_PATH,
199                "Where to store the issued certificate (default: tls-cert-file, else .rws/acme/cert.pem)"),
200            ("acme-key-path", Config::RWS_CONFIG_ACME_KEY_PATH,
201                "Where to store the certificate's private key (default: tls-key-file, else .rws/acme/key.pem)"),
202            ("acme-profile", Config::RWS_CONFIG_ACME_PROFILE,
203                "Certificate profile to order, as the CA offers them (e.g. classic, tlsserver, shortlived)"),
204        ];
205        for (long_form, environment_variable, hint) in long_only {
206            argument_list.push(CommandLineArgument {
207                short_form: "".to_string(),
208                long_form: long_form.to_string(),
209                environment_variable: environment_variable.to_string(),
210                _hint: Some(hint.to_string()),
211            });
212        }
213
214        argument_list
215    }
216
217    pub fn _parse(args: Vec<String>, argument_list : Vec<CommandLineArgument>) -> Vec<CommandLineArgument> {
218        for unparsed_argument in args.iter() {
219
220            let boxed_split = unparsed_argument.split_once('=');
221            if boxed_split.is_some() {
222
223                let (parameter, value) = boxed_split.unwrap();
224                println!("\n    {}={}", parameter, value);
225                let boxed_predefined_argument =
226                    argument_list
227                        .iter()
228                        .find(
229                            |predefined_argument| {
230                                let short_form = predefined_argument.short_form.to_string();
231                                let long_form = predefined_argument.long_form.to_string();
232                                let _param_short_form = ["-", &short_form].join("");
233                                let _param_long_form = ["--", &long_form].join("");
234
235                                (!short_form.is_empty() && parameter.eq(_param_short_form.as_str())) ||
236                                    parameter.eq(_param_long_form.as_str())
237                });
238                if boxed_predefined_argument.is_some() {
239                    let predefined_argument = boxed_predefined_argument.unwrap();
240                    CommandLineArgument::set_environment_variable(predefined_argument, value.to_string());
241                }
242
243            }
244        }
245        argument_list
246    }
247
248    pub fn set_environment_variable(argument: &CommandLineArgument, value: String) {
249        if value.contains('\0') {
250            // env::set_var panics on NUL; reachable from rws.config.toml values.
251            eprintln!("    Warning: value for --{} contains a NUL byte — ignored", argument.long_form);
252            return;
253        }
254        env::set_var(&argument.environment_variable, &value);
255        crate::server_config::invalidate();
256        println!("    Set env variable '{}' to value '{}'", argument.environment_variable, &value);
257    }
258}
rust_web_server/entry_point/command_line_args/mod.rs

rust_web_server/entry_point/command_line_args/
mod.rs
