v1.0.0-rc.8 Update clap to 3.0.0, ready to release

.cargo/config

@@ -0,0 +1,2 @@
+[target.x86_64-pc-windows-msvc]
+rustflags = ["-C", "target-feature=+crt-static"]

.github/workflows/release.yml

@@ -17,16 +17,20 @@ jobs:
   upload-assets:
     strategy:
       matrix:
-        os:
+        include:
-          - ubuntu-latest
+          - target: x86_64-unknown-linux-musl
-          - macos-latest
+            os: ubuntu-latest
-          - windows-latest
+          - target: x86_64-apple-darwin
+            os: macos-latest
+          - target: x86_64-pc-windows-msvc
+            os: windows-latest
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v2
       - uses: taiki-e/upload-rust-binary-action@v1
         with:
           bin: srv
+          target: ${{ matrix.target }}
           tar: unix
           zip: windows
         env:

Cargo.toml

@@ -11,17 +11,18 @@ actix-http = "2.2"
 actix-web = {version = "3.3", features = ["rustls"]}
 actix-web-httpauth = "0.5"
 chrono = "0.4"
-clap = {version = "3.0.0-beta.4", features = ["wrap_help", "color"]}
+clap = {version = "3.0.0", features = ["wrap_help", "color", "cargo"]}
 env_logger = "0.9"
 lazy_static = "1.4"
 log = "0.4"
-mime_guess = "2"
+mime_guess = "2.0"
 regex = "1.5"
 rustls = "0.18"
-serde = "1"
+serde = "1.0"
 sha2 = "0.9"
-tera = "1"
+tera = "1.13"
 toml = "0.5"
+urlencoding = "2.1"
 
 [profile.release]
 lto = true

README.md

@@ -32,4 +32,67 @@ This is a simple HTTP Server for use in a development environment, inspired by [
 - HTTP Basic Authentication Support
 - TLS/SSL support, HTTP/2 support
 - One click to enable CORS, custom CORS header support
-- cargo doc support
+- cargo doc support
+
+## Install
+
+### Pre-compiled Version
+
+#### Linux
+
+##### Archlinux
+
+```shell
+yay -S srv-bin
+```
+
+##### Other Linux
+
+Download the pre-compiled `srv-x86_64-unknown-linux-musl.tar.gz` on the [releases](https://github.com/Tim-Paik/srv/releases/latest), and copy the srv file in the compressed package to `/usr/bin` as a ROOT user with 755 permissions.
+
+```shell
+wget https://github.com/Tim-Paik/srv/releases/download/v1.0.0-rc.6/srv-x86_64-unknown-linux-musl.tar.gz
+tar -xzvf srv-x86_64-unknown-linux-musl.tar.gz
+install -Dm0755 -t /usr/bin/ srv
+rm srv srv-x86_64-unknown-linux-musl.tar.gz
+```
+for reference only
+
+#### MacOS
+
+I'm sorry I don't have the corresponding equipment, but I can only provide `srv-x86_64-apple-darwin.tar.gz` (Of course, if someone can sponsor me a Mac I would be very grateful)
+
+#### Windows
+
+Download the pre-compiled `srv-x86_64-pc-windows-msvc.zip` in the [releases](https://github.com/Tim-Paik/srv/releases/latest), unzip the srv.exe and copy it to your `%PATH%` (if you don’t know what this is, move `srv.exe` to `%SystemRoot%\System32`)
+
+### Compile and Install
+
+You Need:
+
+ - Rust & Cargo Installation
+ - Git Installation
+ - Gcc/Msvc Toolchain Installation
+
+```shell
+git clone git@github.com:Tim-Paik/srv.git
+cd srv
+cargo build --release
+strip target/release/srv
+```
+
+Then you can find the compiled executable file named `srv` in the `target/release/` folder.
+
+## Usage
+
+Execute `srv --help` to get all the usage methods
+
+Waiting to be added...
+
+## License
+
+```text
+This Source Code Form is subject to the terms of the Mozilla Public
+License, v. 2.0. If a copy of the MPL was not distributed with this
+file, You can obtain one at https://mozilla.org/MPL/2.0/.
+```

src/main.rs

@@ -12,6 +12,7 @@ use actix_web::{
     dev::{self, Service, ServiceResponse},
     http, middleware, App, HttpResponse, HttpServer,
 };
+use clap::Arg;
 use env_logger::fmt::Color;
 use log::{error, info};
 use sha2::Digest;
@@ -180,9 +181,9 @@ struct File {
 }
 
 #[derive(serde::Serialize)]
-struct IndexContext<'r> {
+struct IndexContext {
-    title: &'r str,
+    title: String,
-    paths: Vec<&'r str>,
+    paths: Vec<String>,
     dirs: Vec<Dir>,
     files: Vec<File>,
 }
@@ -203,23 +204,26 @@ fn render_index(
         };
         return Ok(ServiceResponse::new(req.clone(), res));
     }
-    if var("NOINDEX").unwrap_or("false".to_string()) == "true" {
+    if var("NOINDEX").unwrap_or_else(|_| "false".to_string()) == "true" {
         return Ok(ServiceResponse::new(
             req.clone(),
             HttpResponse::NotFound().body(""),
         ));
     }
-    let show_dot_files = var("DOTFILES").unwrap_or("false".to_string()) == "true";
+    let show_dot_files = var("DOTFILES").unwrap_or_else(|_| "false".to_string()) == "true";
     let mut context = IndexContext {
-        title: "",
+        title: "".to_string(),
         paths: vec![],
         dirs: vec![],
         files: vec![],
     };
     for path in req.path().split('/') {
-        if path == "" {
+        if path.is_empty() {
             continue;
         }
+        let path =
+            urlencoding::decode(path).unwrap_or(std::borrow::Cow::Borrowed("[Parse URL Error]"));
+        let path = path.into_owned();
         context.paths.push(path);
     }
     match read_dir(&dir.path) {
@@ -242,7 +246,7 @@ fn render_index(
                         continue;
                     }
                 };
-                if !show_dot_files && name.starts_with(".") {
+                if !show_dot_files && name.starts_with('.') {
                     continue;
                 }
                 let metadata = match path.metadata() {
@@ -276,7 +280,7 @@ fn render_index(
             }
         }
     }
-    context.title = context.paths.last().unwrap_or(&"/");
+    context.title = context.paths.last().unwrap_or(&"/".to_string()).to_string();
     context.dirs.sort();
     context.files.sort();
     let content = tera::Context::from_serialize(&context);
@@ -289,7 +293,7 @@ fn render_index(
     };
     let index = TEMPLATE
         .render("index", &content)
-        .unwrap_or("TEMPLATE RENDER ERROR".to_string());
+        .unwrap_or_else(|_| "TEMPLATE RENDER ERROR".to_string());
     let res = HttpResponse::Ok()
         .content_type("text/html; charset=utf-8")
         .body(index);
@@ -302,7 +306,7 @@ fn display_path(path: &Path) -> String {
     if root.starts_with("\\\\?\\") {
         root[4..root.len()].to_string()
     } else {
-        root.to_string()
+        root
     }
 }
 
@@ -318,9 +322,14 @@ async fn validator(
     req: dev::ServiceRequest,
     auth: actix_web_httpauth::extractors::basic::BasicAuth,
 ) -> Result<dev::ServiceRequest, actix_web::Error> {
-    if auth.user_id() == var("AUTH_USERNAME").unwrap_or("".to_string()).as_str()
+    if auth.user_id()
+        == var("AUTH_USERNAME")
+            .unwrap_or_else(|_| "".to_string())
+            .as_str()
         && hash(auth.password().unwrap_or(&std::borrow::Cow::from("")))
-            == var("AUTH_PASSWORD").unwrap_or("".to_string()).as_str()
+            == var("AUTH_PASSWORD")
+                .unwrap_or_else(|_| "".to_string())
+                .as_str()
     {
         return Ok(req);
     }
@@ -334,102 +343,71 @@ async fn validator(
 
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
-    let matches = clap_app!((crate_name!()) =>
+    let check_does_dir_exits = |path: &str| match std::fs::metadata(path) {
-        (version: crate_version!())
+        Ok(meta) => {
-        (author: crate_authors!())
+            if meta.is_dir() {
-        (about: crate_description!())
+                Ok(())
-        (@arg noindex: --noindex "Disable automatic index page generation")
+            } else {
-        (@arg compress: -c --compress "Enable streaming compression (Content-length/segment download will be disabled)")
+                Err("Parameter is not a directory".to_owned())
-        // (@arg upload: -u --upload "Enable file upload")
-        (@arg nocache: --nocache "Disable HTTP cache")
-        (@arg nocolor: --nocolor "Disable cli colors")
-        (@arg cors: --cors [VALUE] min_values(0) max_values(1) "Enable CORS")
-        (@arg spa: --spa "Enable Single-Page Application mode (always serve /index.html when the file is not found)")
-        (@arg dotfiles: -d --dotfiles "Show dotfiles")
-        (@arg open: -o --open "Open the page in the default browser")
-        (@arg quiet: -q --quiet "Disable access log output")
-        (@arg quietall: --quietall "Disable all output")
-        (@arg ROOT: default_value["."] {
-            |path| match std::fs::metadata(path) {
-                Ok(meta) => {
-                    if meta.is_dir() {
-                        Ok(())
-                    } else {
-                        Err("Parameter is not a directory".to_owned())
-                    }
-                }
-                Err(e) => Err(e.to_string()),
             }
-        } "Root directory")
+        }
-        (@arg address: -a --address +takes_value default_value["0.0.0.0"] {
+        Err(e) => Err(e.to_string()),
-            |s| match IpAddr::from_str(&s) {
+    };
-                Ok(_) => Ok(()),
+    let check_does_file_exits = |path: &str| match std::fs::metadata(path) {
-                Err(e) => Err(e.to_string()),
+        Ok(metadata) => {
+            if metadata.is_file() {
+                Ok(())
+            } else {
+                Err("Parameter is not a file".to_owned())
             }
-        } "IP address to serve on")
+        }
-        (@arg port: -p --port +takes_value default_value["8000"] {
+        Err(e) => Err(e.to_string()),
-            |s| match s.parse::<u16>() {
+    };
-                Ok(_) => Ok(()),
+    let check_is_ip_addr = |s: &str| match IpAddr::from_str(s) {
-                Err(e) => Err(e.to_string()),
+        Ok(_) => Ok(()),
-            }
+        Err(e) => Err(e.to_string()),
-        } "Port to serve on")
+    };
-        (@arg auth: --auth +takes_value {
+    let check_is_port_num = |s: &str| match s.parse::<u16>() {
-            |s| {
+        Ok(_) => Ok(()),
-                let parts = s.splitn(2, ':').collect::<Vec<&str>>();
+        Err(e) => Err(e.to_string()),
-                if parts.len() < 2 || parts.len() >= 2 && parts[1].is_empty() {
+    };
-                    Err("Password not found".to_owned())
+    let check_is_auth = |s: &str| {
-                } else if parts[0].is_empty() {
+        let parts = s.splitn(2, ':').collect::<Vec<&str>>();
-                    Err("Username not found".to_owned())
+        if parts.len() < 2 || parts.len() >= 2 && parts[1].is_empty() {
-                } else {
+            Err("Password not found".to_owned())
-                    Ok(())
+        } else if parts[0].is_empty() {
-                }
+            Err("Username not found".to_owned())
-            }
+        } else {
-        } "HTTP Auth (username:password)")
+            Ok(())
-        (@arg cert: --cert +takes_value {
+        }
-            |s| match std::fs::metadata(s) {
+    };
-                Ok(metadata) => {
+    let matches = app_from_crate!()
-                    if metadata.is_file() {
+        .arg(Arg::new("noindex").long("noindex").help("Disable automatic index page generation"))
-                        Ok(())
+        .arg(Arg::new("compress").short('c').long("compress").help("Enable streaming compression (Content-length/segment download will be disabled)"))
-                    } else {
+        .arg(Arg::new("nocache").long("nocache").help("Disable HTTP cache"))
-                        Err("Parameter is not a file".to_owned())
+        .arg(Arg::new("nocolor").long("nocolor").help("Disable cli colors"))
-                    }
+        .arg(Arg::new("cors").long("cors").takes_value(true).min_values(0).max_values(1).help("Enable CORS [with custom value]"))
-                }
+        .arg(Arg::new("spa").long("spa").help("Enable Single-Page Application mode (always serve /index.html when the file is not found)"))
-                Err(e) => Err(e.to_string()),
+        .arg(Arg::new("dotfiles").short('d').long("dotfiles").help("Show dotfiles"))
-            }
+        .arg(Arg::new("open").short('o').long("open").help("Open the page in the default browser"))
-        } "Path of TLS/SSL public key (certificate)")
+        .arg(Arg::new("quiet").short('q').long("quiet").help("Disable access log output"))
-        (@arg key: --key +takes_value {
+        .arg(Arg::new("quietall").long("quietall").help("Disable all output"))
-            |s| match std::fs::metadata(s) {
+        .arg(Arg::new("ROOT").default_value(".").validator(check_does_dir_exits).help("Root directory"))
-                Ok(metadata) => {
+        .arg(Arg::new("address").short('a').long("address").default_value("0.0.0.0").takes_value(true).validator(check_is_ip_addr).help("IP address to serve on"))
-                    if metadata.is_file() {
+        .arg(Arg::new("port").short('p').long("port").default_value("8000").takes_value(true).validator(check_is_port_num).help("Port to serve on"))
-                        Ok(())
+        .arg(Arg::new("auth").long("auth").takes_value(true).validator(check_is_auth).help("HTTP Auth (username:password)"))
-                    } else {
+        .arg(Arg::new("cert").long("cert").takes_value(true).validator(check_does_file_exits).help("Path of TLS/SSL public key (certificate)"))
-                        Err("Parameter is not a file".to_owned())
+        .arg(Arg::new("key").long("key").takes_value(true).validator(check_does_file_exits).help("Path of TLS/SSL private key"))
-                    }
+        .subcommand(clap::App::new("doc")
-                }
+            .about("Open cargo doc via local server (Need cargo installation)")
-                Err(e) => Err(e.to_string()),
+            .arg(Arg::new("nocolor").long("nocolor").help("Disable cli colors"))
-            }
+            .arg(Arg::new("noopen").long("noopen").help("Do not open the page in the default browser"))
-        } "Path of TLS/SSL private key")
+            .arg(Arg::new("log").long("log").help("Enable access log output [default: disabled]"))
-        (@subcommand doc =>
+            .arg(Arg::new("quietall").long("quietall").help("Disable all output"))
-            (about: "Open cargo doc via local server (Need cargo installation)")
+            .arg(Arg::new("address").short('a').long("address").default_value("0.0.0.0").takes_value(true).validator(check_is_ip_addr).help("IP address to serve on"))
-            (@arg nocolor: --nocolor "Disable cli colors")
+            .arg(Arg::new("port").short('p').long("port").default_value("8000").takes_value(true).validator(check_is_port_num).help("Port to serve on"))
-            (@arg noopen: -no --noopen "Do not open the page in the default browser")
-            (@arg log: --log "Enable access log output [default: false]")
-            (@arg quietall: --quietall "Disable all output")
-            (@arg address: -a --address +takes_value default_value["0.0.0.0"] {
-                |s| match IpAddr::from_str(&s) {
-                    Ok(_) => Ok(()),
-                    Err(e) => Err(e.to_string()),
-                }
-            } "IP address to serve on")
-            (@arg port: -p --port +takes_value default_value["8000"] {
-                |s| match s.parse::<u16>() {
-                    Ok(_) => Ok(()),
-                    Err(e) => Err(e.to_string()),
-                }
-            } "Port to serve on")
         )
-    )
+        .get_matches();
-    .get_matches();
 
     set_var(
         "ROOT",
@@ -452,14 +430,11 @@ async fn main() -> std::io::Result<()> {
         set_var("RUST_LOG_STYLE", "never");
     }
 
-    match matches.value_of("auth") {
+    if let Some(s) = matches.value_of("auth") {
-        Some(s) => {
+        set_var("ENABLE_AUTH", matches.is_present("auth").to_string());
-            set_var("ENABLE_AUTH", matches.is_present("auth").to_string());
+        let parts = s.splitn(2, ':').collect::<Vec<&str>>();
-            let parts = s.splitn(2, ':').collect::<Vec<&str>>();
+        set_var("AUTH_USERNAME", parts[0]);
-            set_var("AUTH_USERNAME", parts[0]);
+        set_var("AUTH_PASSWORD", hash(parts[1]));
-            set_var("AUTH_PASSWORD", hash(parts[1]));
-        }
-        None => {}
     }
 
     if matches.is_present("cors") {
@@ -603,13 +578,13 @@ async fn main() -> std::io::Result<()> {
         .format(|buf, record| {
             let data = record.args().to_string();
             let mut style = buf.style();
-            let blue = style.set_color(Color::Rgb(52, 152, 219));
+            let blue = style.set_color(Color::Cyan);
             let mut style = buf.style();
-            let red = style.set_color(Color::Rgb(231, 76, 60));
+            let red = style.set_color(Color::Red);
             let mut style = buf.style();
-            let green = style.set_color(Color::Rgb(76, 175, 80));
+            let green = style.set_color(Color::Green);
             if record.target() == "actix_web::middleware::logger" {
-                let data: Vec<&str> = data.splitn(5, "^").collect();
+                let data: Vec<&str> = data.splitn(5, '^').collect();
                 let time = blue.value(
                     chrono::NaiveDateTime::from_str(data[0])
                         .unwrap()
@@ -623,7 +598,7 @@ async fn main() -> std::io::Result<()> {
                 } else {
                     red.value(status_code)
                 };
-                let process_time: Vec<&str> = data[3].splitn(2, ".").collect();
+                let process_time: Vec<&str> = data[3].splitn(2, '.').collect();
                 let process_time = process_time[0].to_string() + "ms";
                 let process_time = blue.value(if process_time.len() == 3 {
                     "  ".to_string() + &process_time
@@ -632,7 +607,11 @@ async fn main() -> std::io::Result<()> {
                 } else {
                     process_time
                 });
-                let content = blue.value(data[4]);
+                let content = blue.value(
+                    urlencoding::decode(data[4])
+                        .unwrap_or(std::borrow::Cow::Borrowed("[Parse URL Error]"))
+                        .into_owned(),
+                );
                 return writeln!(
                     buf,
                     "[{}] {} | {} | {} | {}",
@@ -657,7 +636,7 @@ async fn main() -> std::io::Result<()> {
                             .map_or("", |m| m.as_str());
                         let data = format!(
                             "[INFO] Serving {} on {}",
-                            var("ROOT").unwrap_or(".".to_string()),
+                            var("ROOT").unwrap_or_else(|_| ".".to_string()),
                             addr
                         );
                         return writeln!(buf, "\r{}", green.value(data));
@@ -676,14 +655,14 @@ async fn main() -> std::io::Result<()> {
         .init();
 
     let server = HttpServer::new(move || {
-        let compress = if var("COMPRESS").unwrap_or("false".to_string()) == "true" {
+        let compress = if var("COMPRESS").unwrap_or_else(|_| "false".to_string()) == "true" {
             http::header::ContentEncoding::Auto
         } else {
             http::header::ContentEncoding::Identity
         };
         let app = App::new()
             .wrap_fn(|req, srv| {
-                let paths = PathBuf::from_str(req.path()).unwrap_or(PathBuf::default());
+                let paths = PathBuf::from_str(req.path()).unwrap_or_default();
                 let mut isdotfile = false;
                 for path in paths.iter() {
                     if path.to_string_lossy().starts_with('.') {
@@ -693,20 +672,21 @@ async fn main() -> std::io::Result<()> {
                 let fut = srv.call(req);
                 async move {
                     Ok(fut.await?.map_body(|head, body| {
-                        if var("NOCACHE").unwrap_or("false".to_string()) == "true" {
+                        if var("NOCACHE").unwrap_or_else(|_| "false".to_string()) == "true" {
                             head.headers_mut().insert(
                                 http::header::CACHE_CONTROL,
                                 http::HeaderValue::from_static("no-store"),
                             );
                         }
-                        if var("ENABLE_CORS").unwrap_or("false".to_string()) == "true" {
+                        if var("ENABLE_CORS").unwrap_or_else(|_| "false".to_string()) == "true" {
-                            let cors = var("CORS").unwrap_or("*".to_string());
+                            let cors = var("CORS").unwrap_or_else(|_| "*".to_string());
                             let cors = http::HeaderValue::from_str(&cors)
-                                .unwrap_or(http::HeaderValue::from_static("*"));
+                                .unwrap_or_else(|_| http::HeaderValue::from_static("*"));
                             head.headers_mut()
                                 .insert(http::header::ACCESS_CONTROL_ALLOW_ORIGIN, cors);
                         }
-                        if isdotfile && !(var("DOTFILES").unwrap_or("false".to_string()) == "true")
+                        if isdotfile
+                            && var("DOTFILES").unwrap_or_else(|_| "false".to_string()) != "true"
                         {
                             head.status = http::StatusCode::FORBIDDEN;
                             *head.headers_mut() = http::HeaderMap::new();
@@ -718,11 +698,11 @@ async fn main() -> std::io::Result<()> {
             })
             .wrap(middleware::Compress::new(compress))
             .wrap(middleware::Condition::new(
-                var("ENABLE_AUTH").unwrap_or("false".to_string()) == "true",
+                var("ENABLE_AUTH").unwrap_or_else(|_| "false".to_string()) == "true",
                 actix_web_httpauth::middleware::HttpAuthentication::basic(validator),
             ))
             .wrap(middleware::Logger::new("%t^%a^%s^%D^%r"));
-        let files = fs::Files::new("/", var("ROOT").unwrap_or(".".to_string()))
+        let files = fs::Files::new("/", var("ROOT").unwrap_or_else(|_| ".".to_string()))
             .use_hidden_files()
             .prefer_utf8(true)
             .show_files_listing()
@@ -730,23 +710,23 @@ async fn main() -> std::io::Result<()> {
             .default_handler(|req: dev::ServiceRequest| {
                 let (http_req, _payload) = req.into_parts();
                 async {
-                    let path = var("ROOT").unwrap_or(".".to_string());
+                    let path = var("ROOT").unwrap_or_else(|_| ".".to_string());
                     let mut path = Path::new(&path).to_path_buf();
                     path.push("index.html");
                     if path.exists()
                         && path.is_file()
-                        && var("SPA").unwrap_or("false".to_string()) == "true"
+                        && var("SPA").unwrap_or_else(|_| "false".to_string()) == "true"
                     {
                         let res = fs::NamedFile::open(path)?.into_response(&http_req)?;
                         return Ok(ServiceResponse::new(http_req, res));
                     }
-                    return Ok(ServiceResponse::new(
+                    Ok(ServiceResponse::new(
                         http_req,
                         HttpResponse::NotFound().body(""),
-                    ));
+                    ))
                 }
             });
-        return app.service(files);
+        app.service(files)
     });
     let server = if enable_tls {
         let cert = &mut BufReader::new(