chore(release): version v0.22.0

CHANGELOG.md

@@ -2,6 +2,26 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.22.0] - 2022-06-25
+
+### Features
+
+- Support hiding folders with --hidden ([#73](https://github.com/sigoden/dufs/issues/73))
+
+## [0.21.0] - 2022-06-23
+
+### Bug Fixes
+
+- Escape name contains html escape code ([#65](https://github.com/sigoden/dufs/issues/65))
+
+### Features
+
+- Use custom logger with timestamp in rfc3339 ([#67](https://github.com/sigoden/dufs/issues/67))
+
+### Refactor
+
+- Split css/js from index.html ([#68](https://github.com/sigoden/dufs/issues/68))
+
 ## [0.20.0] - 2022-06-20
 
 ### Bug Fixes

Cargo.lock

@@ -572,7 +572,7 @@ checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
 
 [[package]]
 name = "dufs"
-version = "0.20.0"
+version = "0.22.0"
 dependencies = [
  "assert_cmd",
  "assert_fs",
@@ -583,7 +583,6 @@ dependencies = [
  "chrono",
  "clap",
  "diqwest",
- "env_logger",
  "futures",
  "get_if_addrs",
  "headers",
@@ -629,16 +628,6 @@ dependencies = [
  "cfg-if",
 ]
 
-[[package]]
-name = "env_logger"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b2cf0344971ee6c64c31be0d530793fba457d322dfec2810c453d0ef228f9c3"
-dependencies = [
- "humantime",
- "log",
-]
-
 [[package]]
 name = "event-listener"
 version = "2.5.2"
@@ -1033,12 +1022,6 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
 
-[[package]]
-name = "humantime"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
-
 [[package]]
 name = "hyper"
 version = "0.14.19"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dufs"
-version = "0.20.0"
+version = "0.22.0"
 edition = "2021"
 authors = ["sigoden <sigoden@gmail.com>"]
 description = "Dufs is a distinctive utility file server"
@@ -34,7 +34,6 @@ lazy_static = "1.4"
 uuid = { version = "1.1", features = ["v4", "fast-rng"] }
 urlencoding = "2.1"
 xml-rs = "0.8"
-env_logger = { version = "0.9", default-features = false, features = ["humantime"] }
 log = "0.4"
 socket2 = "0.4"
 async-stream = "0.3"

README.md

@@ -1,4 +1,4 @@
-# Dufs (Old Name: Duf)
+# Dufs
 
 [![CI](https://github.com/sigoden/dufs/actions/workflows/ci.yaml/badge.svg)](https://github.com/sigoden/dufs/actions/workflows/ci.yaml)
 [![Crates](https://img.shields.io/crates/v/dufs.svg)](https://crates.io/crates/dufs)
@@ -52,6 +52,7 @@ OPTIONS:
     -b, --bind <addr>...         Specify bind address
     -p, --port <port>            Specify port to listen on [default: 5000]
         --path-prefix <path>     Specify an path prefix
+        --hidden <value>         Hide directories from directory listings, separated by `,`
     -a, --auth <rule>...         Add auth for path
         --auth-method <value>    Select auth method [default: digest] [possible values: basic, digest]
     -A, --allow-all              Allow all operations
@@ -61,7 +62,7 @@ OPTIONS:
         --allow-symlink          Allow symlink to files/folders outside root directory
         --enable-cors            Enable CORS, sets `Access-Control-Allow-Origin: *`
         --render-index           Serve index.html when requesting a directory, returns 404 if not found index.html
-        --render-try-index       Serve index.html when requesting a directory, returns file listing if not found index.html
+        --render-try-index       Serve index.html when requesting a directory, returns directory listing if not found index.html
         --render-spa             Serve SPA(Single Page Application)
         --tls-cert <path>        Path to an SSL/TLS certificate to serve with HTTPS
         --tls-key <path>         Path to the SSL/TLS certificate's private key
@@ -125,6 +126,12 @@ Listen on a specific port
 dufs -p 80
 ```
 
+Hide directories from directory listings
+
+```
+dufs --hidden .git,.DS_Store
+```
+
 Use https
 
 ```
@@ -161,23 +168,23 @@ curl -X DELETE http://127.0.0.1:5000/path-to-file
 Dufs supports path level access control. You can control who can do what on which path with `--auth`/`-a`.
 
 ```
-dufs -a <path>@<readwrite>[@<readonly>]
+dufs -a <path>@<readwrite>[@<readonly>|@*]
 ```
 
-- `<path>`: Path to protected
+- `<path>`: Protected url path
-- `<readwrite>`: Account with readwrite permission, required
+- `<readwrite>`: Account with upload/delete/view/download permission, required
-- `<readonly>`: Account with readonly permission, optional
+- `<readonly>`: Account with view/download permission, optional
 
-> `<readonly>` can be `*` means `<path>` is public, everyone can access/download it.
+> `*` means `<path>` is public, everyone can view/download it.
 
 For example:
 
 ```
 dufs -a /@admin:pass@* -a /ui@designer:pass1 -A
 ```
-- All files/folders are public to access/download.
+- All files/folders are public to view/download.
-- Account `admin:pass` can upload/delete/download any files/folders.
+- Account `admin:pass` can upload/delete/view/download any files/folders.
-- Account `designer:pass1` can upload/delete/download any files/folders in the `ui` folder.
+- Account `designer:pass1` can upload/delete/view/download any files/folders in the `ui` folder.
 
 ## License
 

assets/index.js

@@ -64,14 +64,16 @@ class Uploader {
 
   upload() {
     const { file, idx, name } = this;
-    let url = getUrl(name);
+    const url = getUrl(name);
+    const encodedUrl = encodedStr(url);
+    const encodedName = encodedStr(name);
     $uploadersTable.insertAdjacentHTML("beforeend", `
   <tr id="upload${idx}" class="uploader">
     <td class="path cell-icon">
       ${getSvg(file.path_type)}
     </td>
     <td class="path cell-name">
-      <a href="${url}">${name}</a>
+      <a href="${encodedUrl}">${encodedName}</a>
     </td>
     <td class="cell-status upload-status" id="uploadStatus${idx}"></td>
   </tr>`);
@@ -141,12 +143,14 @@ function addBreadcrumb(href, uri_prefix) {
       }
       path += encodeURI(name);
     }
+    const encodedPath = encodedStr(path);
+    const encodedName = encodedStr(name);
     if (i === 0) {
-      $breadcrumb.insertAdjacentHTML("beforeend", `<a href="${path}"><svg width="16" height="16" viewBox="0 0 16 16"><path d="M6.5 14.5v-3.505c0-.245.25-.495.5-.495h2c.25 0 .5.25.5.5v3.5a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5v-7a.5.5 0 0 0-.146-.354L13 5.793V2.5a.5.5 0 0 0-.5-.5h-1a.5.5 0 0 0-.5.5v1.293L8.354 1.146a.5.5 0 0 0-.708 0l-6 6A.5.5 0 0 0 1.5 7.5v7a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5z"/></svg></a>`);
+      $breadcrumb.insertAdjacentHTML("beforeend", `<a href="${encodedPath}"><svg width="16" height="16" viewBox="0 0 16 16"><path d="M6.5 14.5v-3.505c0-.245.25-.495.5-.495h2c.25 0 .5.25.5.5v3.5a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5v-7a.5.5 0 0 0-.146-.354L13 5.793V2.5a.5.5 0 0 0-.5-.5h-1a.5.5 0 0 0-.5.5v1.293L8.354 1.146a.5.5 0 0 0-.708 0l-6 6A.5.5 0 0 0 1.5 7.5v7a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5z"/></svg></a>`);
     } else if (i === len - 1) {
-      $breadcrumb.insertAdjacentHTML("beforeend", `<b>${name}</b>`);
+      $breadcrumb.insertAdjacentHTML("beforeend", `<b>${encodedName}</b>`);
     } else {
-      $breadcrumb.insertAdjacentHTML("beforeend", `<a href="${path}">${name}</a>`);
+      $breadcrumb.insertAdjacentHTML("beforeend", `<a href="${encodedPath}">${encodedName}</a>`);
     }
     if (i !== len - 1) {
       $breadcrumb.insertAdjacentHTML("beforeend", `<span class="separator">/</span>`);
@@ -160,28 +164,31 @@ function addBreadcrumb(href, uri_prefix) {
  * @param {number} index 
  */
 function addPath(file, index) {
+  const encodedName = encodedStr(file.name);
   let url = getUrl(file.name)
+  let encodedUrl = encodedStr(url);
   let actionDelete = "";
   let actionDownload = "";
   if (file.path_type.endsWith("Dir")) {
     url += "/";
+    encodedUrl += "/";
     actionDownload = `
     <div class="action-btn">
-      <a href="${url}?zip" title="Download folder as a .zip file">
+      <a href="${encodedUrl}?zip" title="Download folder as a .zip file">
         <svg width="16" height="16" viewBox="0 0 16 16"><path d="M.5 9.9a.5.5 0 0 1 .5.5v2.5a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-2.5a.5.5 0 0 1 1 0v2.5a2 2 0 0 1-2 2H2a2 2 0 0 1-2-2v-2.5a.5.5 0 0 1 .5-.5z"/><path d="M7.646 11.854a.5.5 0 0 0 .708 0l3-3a.5.5 0 0 0-.708-.708L8.5 10.293V1.5a.5.5 0 0 0-1 0v8.793L5.354 8.146a.5.5 0 1 0-.708.708l3 3z"/></svg>
       </a>
     </div>`;
   } else {
     actionDownload = `
     <div class="action-btn" >
-      <a href="${url}" title="Download file" download>
+      <a href="${encodedUrl}" title="Download file" download>
         <svg width="16" height="16" viewBox="0 0 16 16"><path d="M.5 9.9a.5.5 0 0 1 .5.5v2.5a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-2.5a.5.5 0 0 1 1 0v2.5a2 2 0 0 1-2 2H2a2 2 0 0 1-2-2v-2.5a.5.5 0 0 1 .5-.5z"/><path d="M7.646 11.854a.5.5 0 0 0 .708 0l3-3a.5.5 0 0 0-.708-.708L8.5 10.293V1.5a.5.5 0 0 0-1 0v8.793L5.354 8.146a.5.5 0 1 0-.708.708l3 3z"/></svg>
       </a>
     </div>`;
   }
   if (DATA.allow_delete) {
     actionDelete = `
-    <div onclick="deletePath(${index})" class="action-btn" id="deleteBtn${index}" title="Delete ${file.name}">
+    <div onclick="deletePath(${index})" class="action-btn" id="deleteBtn${index}" title="Delete ${encodedName}">
       <svg width="16" height="16" fill="currentColor"viewBox="0 0 16 16"><path d="M6.854 7.146a.5.5 0 1 0-.708.708L7.293 9l-1.147 1.146a.5.5 0 0 0 .708.708L8 9.707l1.146 1.147a.5.5 0 0 0 .708-.708L8.707 9l1.147-1.146a.5.5 0 0 0-.708-.708L8 8.293 6.854 7.146z"/><path d="M14 14V4.5L9.5 0H4a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2zM9.5 3A1.5 1.5 0 0 0 11 4.5h2V14a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V2a1 1 0 0 1 1-1h5.5v2z"/></svg>
     </div>`;
   }
@@ -197,7 +204,7 @@ function addPath(file, index) {
     ${getSvg(file.path_type)}
   </td>
   <td class="path cell-name">
-    <a href="${url}" title="${file.name}">${file.name}</a>
+    <a href="${encodedUrl}">${encodedName}</a>
   </td>
   <td class="cell-mtime">${formatMtime(file.mtime)}</td>
   <td class="cell-size">${formatSize(file.size).join(" ")}</td>
@@ -333,7 +340,14 @@ function formatPercent(precent) {
   }
 }
 
+function encodedStr(rawStr) {
+  return rawStr.replace(/[\u00A0-\u9999<>\&]/g, function(i) {
+    return '&#'+i.charCodeAt(0)+';';
+  });
+}
+
 function ready() {
+  document.title = `Index of ${DATA.href} - Dufs`;
   $pathsTable = document.querySelector(".paths-table")
   $pathsTableBody = document.querySelector(".paths-table tbody");
   $uploadersTable = document.querySelector(".uploaders-table");

src/args.rs

@@ -48,6 +48,12 @@ fn app() -> Command<'static> {
                 .value_name("path")
                 .help("Specify an path prefix"),
         )
+        .arg(
+            Arg::new("hidden")
+                .long("hidden")
+                .help("Hide directories from directory listings, separated by `,`")
+                .value_name("value"),
+        )
         .arg(
             Arg::new("auth")
                 .short('a')
@@ -104,7 +110,7 @@ fn app() -> Command<'static> {
         .arg(
             Arg::new("render-try-index")
                 .long("render-try-index")
-                .help("Serve index.html when requesting a directory, returns file listing if not found index.html"),
+                .help("Serve index.html when requesting a directory, returns directory listing if not found index.html"),
         )
         .arg(
             Arg::new("render-spa")
@@ -137,6 +143,7 @@ pub struct Args {
     pub path_is_file: bool,
     pub path_prefix: String,
     pub uri_prefix: String,
+    pub hidden: String,
     pub auth_method: AuthMethod,
     pub auth: AccessControl,
     pub allow_upload: bool,
@@ -173,6 +180,10 @@ impl Args {
         } else {
             format!("/{}/", &path_prefix)
         };
+        let hidden: String = matches
+            .value_of("hidden")
+            .map(|v| format!(",{},", v))
+            .unwrap_or_default();
         let enable_cors = matches.is_present("enable-cors");
         let auth: Vec<&str> = matches
             .values_of("auth")
@@ -206,6 +217,7 @@ impl Args {
             path_is_file,
             path_prefix,
             uri_prefix,
+            hidden,
             auth_method,
             auth,
             enable_cors,

src/logger.rs

@@ -0,0 +1,30 @@
+use chrono::{Local, SecondsFormat};
+use log::{Level, Metadata, Record};
+use log::{LevelFilter, SetLoggerError};
+
+struct SimpleLogger;
+
+impl log::Log for SimpleLogger {
+    fn enabled(&self, metadata: &Metadata) -> bool {
+        metadata.level() <= Level::Info
+    }
+
+    fn log(&self, record: &Record) {
+        if self.enabled(record.metadata()) {
+            let timestamp = Local::now().to_rfc3339_opts(SecondsFormat::Secs, true);
+            if record.level() < Level::Info {
+                eprintln!("{} {} - {}", timestamp, record.level(), record.args());
+            } else {
+                println!("{} {} - {}", timestamp, record.level(), record.args());
+            }
+        }
+    }
+
+    fn flush(&self) {}
+}
+
+static LOGGER: SimpleLogger = SimpleLogger;
+
+pub fn init() -> Result<(), SetLoggerError> {
+    log::set_logger(&LOGGER).map(|()| log::set_max_level(LevelFilter::Info))
+}

src/main.rs

@@ -1,5 +1,6 @@
 mod args;
 mod auth;
+mod logger;
 mod server;
 mod streamer;
 mod tls;
@@ -12,9 +13,8 @@ use crate::args::{matches, Args};
 use crate::server::{Request, Server};
 use crate::tls::{TlsAcceptor, TlsStream};
 
-use std::io::Write;
 use std::net::{IpAddr, SocketAddr, TcpListener as StdTcpListener};
-use std::{env, sync::Arc};
+use std::sync::Arc;
 
 use futures::future::join_all;
 use tokio::net::TcpListener;
@@ -32,16 +32,7 @@ async fn main() {
 }
 
 async fn run() -> BoxResult<()> {
-    if env::var("RUST_LOG").is_err() {
+    logger::init().map_err(|e| format!("Failed to init logger, {}", e))?;
-        env::set_var("RUST_LOG", "info")
-    }
-    env_logger::builder()
-        .format(|buf, record| {
-            let timestamp = buf.timestamp_millis();
-            writeln!(buf, "[{} {}] {}", timestamp, record.level(), record.args())
-        })
-        .init();
-
     let args = Args::parse(matches())?;
     let args = Arc::new(args);
     let handles = serve(args.clone())?;

src/server.rs

@@ -1,9 +1,9 @@
 use crate::streamer::Streamer;
-use crate::utils::{decode_uri, encode_uri};
+use crate::utils::{decode_uri, encode_uri, get_file_name, try_get_file_name};
 use crate::{Args, BoxResult};
+use async_walkdir::{Filtering, WalkDir};
 use xml::escape::escape_str_pcdata;
 
-use async_walkdir::WalkDir;
 use async_zip::write::{EntryOptions, ZipFileWriter};
 use async_zip::Compression;
 use chrono::{TimeZone, Utc};
@@ -44,11 +44,16 @@ const BUF_SIZE: usize = 65536;
 
 pub struct Server {
     args: Arc<Args>,
+    assets_prefix: String,
 }
 
 impl Server {
     pub fn new(args: Arc<Args>) -> Self {
-        Self { args }
+        let assets_prefix = format!("{}__dufs_v{}_", args.uri_prefix, env!("CARGO_PKG_VERSION"));
+        Self {
+            args,
+            assets_prefix,
+        }
     }
 
     pub async fn call(
@@ -58,12 +63,15 @@ impl Server {
     ) -> Result<Response, hyper::Error> {
         let method = req.method().clone();
         let uri = req.uri().clone();
+        let assets_prefix = self.assets_prefix.clone();
         let enable_cors = self.args.enable_cors;
 
         let mut res = match self.handle(req).await {
             Ok(res) => {
                 let status = res.status().as_u16();
+                if !uri.path().starts_with(&assets_prefix) {
                     info!(r#"{} "{} {}" - {}"#, addr.ip(), method, uri, status,);
+                }
                 res
             }
             Err(err) => {
@@ -89,8 +97,7 @@ impl Server {
         let headers = req.headers();
         let method = req.method().clone();
 
-        if req_path == "/favicon.ico" && method == Method::GET {
+        if method == Method::GET && self.handle_embed_assets(req_path, &mut res).await? {
-            self.handle_send_favicon(headers, &mut res).await?;
             return Ok(res);
         }
 
@@ -155,7 +162,8 @@ impl Server {
                         self.handle_zip_dir(path, head_only, &mut res).await?;
                     } else if allow_search && query.starts_with("q=") {
                         let q = decode_uri(&query[2..]).unwrap_or_default();
-                        self.handle_query_dir(path, &q, head_only, &mut res).await?;
+                        self.handle_search_dir(path, &q, head_only, &mut res)
+                            .await?;
                     } else {
                         self.handle_ls_dir(path, true, head_only, &mut res).await?;
                     }
@@ -315,28 +323,39 @@ impl Server {
         self.send_index(path, paths, exist, head_only, res)
     }
 
-    async fn handle_query_dir(
+    async fn handle_search_dir(
         &self,
         path: &Path,
-        query: &str,
+        search: &str,
         head_only: bool,
         res: &mut Response,
     ) -> BoxResult<()> {
         let mut paths: Vec<PathItem> = vec![];
-        let mut walkdir = WalkDir::new(path);
+        let hidden = self.args.hidden.to_string();
-        while let Some(entry) = walkdir.next().await {
+        let search = search.to_string();
-            if let Ok(entry) = entry {
+        let mut walkdir = WalkDir::new(path).filter(move |entry| {
-                if !entry
+            let hidden_cloned = hidden.clone();
-                    .file_name()
+            let search_cloned = search.clone();
-                    .to_string_lossy()
+            async move {
+                let entry_path = entry.path();
+                let base_name = get_file_name(&entry_path);
+                if is_hidden(&hidden_cloned, base_name) {
+                    return Filtering::IgnoreDir;
+                }
+                if !base_name
                     .to_lowercase()
-                    .contains(&query.to_lowercase())
+                    .contains(&search_cloned.to_lowercase())
                 {
-                    continue;
+                    return Filtering::Ignore;
                 }
                 if fs::symlink_metadata(entry.path()).await.is_err() {
-                    continue;
+                    return Filtering::Ignore;
                 }
+                Filtering::Continue
+            }
+        });
+        while let Some(entry) = walkdir.next().await {
+            if let Ok(entry) = entry {
                 if let Ok(Some(item)) = self.to_pathitem(entry.path(), path.to_path_buf()).await {
                     paths.push(item);
                 }
@@ -352,7 +371,7 @@ impl Server {
         res: &mut Response,
     ) -> BoxResult<()> {
         let (mut writer, reader) = tokio::io::duplex(BUF_SIZE);
-        let filename = get_file_name(path)?;
+        let filename = try_get_file_name(path)?;
         res.headers_mut().insert(
             CONTENT_DISPOSITION,
             HeaderValue::from_str(&format!(
@@ -367,8 +386,9 @@ impl Server {
             return Ok(());
         }
         let path = path.to_owned();
+        let hidden = self.args.hidden.clone();
         tokio::spawn(async move {
-            if let Err(e) = zip_dir(&mut writer, &path).await {
+            if let Err(e) = zip_dir(&mut writer, &path, &hidden).await {
                 error!("Failed to zip {}, {}", path.display(), e);
             }
         });
@@ -418,23 +438,38 @@ impl Server {
         Ok(())
     }
 
-    async fn handle_send_favicon(
+    async fn handle_embed_assets(&self, req_path: &str, res: &mut Response) -> BoxResult<bool> {
-        &self,
+        if let Some(name) = req_path.strip_prefix(&self.assets_prefix) {
-        headers: &HeaderMap<HeaderValue>,
+            match name {
-        res: &mut Response,
+                "index.js" => {
-    ) -> BoxResult<()> {
+                    *res.body_mut() = Body::from(INDEX_JS);
-        let path = self.args.path.join("favicon.ico");
+                    res.headers_mut().insert(
-        let meta = fs::metadata(&path).await.ok();
+                        "content-type",
-        let is_file = meta.map(|v| v.is_file()).unwrap_or_default();
+                        HeaderValue::from_static("application/javascript"),
-        if is_file {
+                    );
-            self.handle_send_file(path.as_path(), headers, false, res)
+                }
-                .await?;
+                "index.css" => {
-        } else {
+                    *res.body_mut() = Body::from(INDEX_CSS);
+                    res.headers_mut()
+                        .insert("content-type", HeaderValue::from_static("text/css"));
+                }
+                "favicon.ico" => {
                     *res.body_mut() = Body::from(FAVICON_ICO);
                     res.headers_mut()
                         .insert("content-type", HeaderValue::from_static("image/x-icon"));
                 }
-        Ok(())
+                _ => {
+                    return Ok(false);
+                }
+            }
+            res.headers_mut().insert(
+                "cache-control",
+                HeaderValue::from_static("max-age=2592000, public"),
+            );
+            Ok(true)
+        } else {
+            Ok(false)
+        }
     }
 
     async fn handle_send_file(
@@ -491,7 +526,7 @@ impl Server {
             );
         }
 
-        let filename = get_file_name(path)?;
+        let filename = try_get_file_name(path)?;
         res.headers_mut().insert(
             CONTENT_DISPOSITION,
             HeaderValue::from_str(&format!("inline; filename=\"{}\"", encode_uri(filename),))
@@ -692,7 +727,7 @@ impl Server {
         paths.sort_unstable();
         let href = format!("/{}", normalize_path(path.strip_prefix(&self.args.path)?));
         let data = IndexData {
-            href: href.clone(),
+            href,
             uri_prefix: self.args.uri_prefix.clone(),
             paths,
             allow_upload: self.args.allow_upload,
@@ -701,18 +736,21 @@ impl Server {
             dir_exists: exist,
         };
         let data = serde_json::to_string(&data).unwrap();
+        let asset_js = format!("{}index.js", self.assets_prefix);
+        let asset_css = format!("{}index.css", self.assets_prefix);
+        let asset_ico = format!("{}favicon.ico", self.assets_prefix);
         let output = INDEX_HTML.replace(
             "__SLOT__",
             &format!(
                 r#"
-<title>Index of {} - Dufs</title>
+<link rel="icon" type="image/x-icon" href="{}">
-<style>{}</style>
+<link rel="stylesheet" href="{}">
 <script>
-const DATA = 
+DATA = {}
-{}
+</script>
-{}</script>
+<script src="{}"></script>
 "#,
-                href, INDEX_CSS, data, INDEX_JS
+                asset_ico, asset_css, data, asset_js
             ),
         );
         res.headers_mut()
@@ -777,6 +815,10 @@ const DATA =
         let mut rd = fs::read_dir(entry_path).await?;
         while let Ok(Some(entry)) = rd.next_entry().await {
             let entry_path = entry.path();
+            let base_name = get_file_name(&entry_path);
+            if is_hidden(&self.args.hidden, base_name) {
+                continue;
+            }
             if let Ok(Some(item)) = self.to_pathitem(entry_path.as_path(), base_path).await {
                 paths.push(item);
             }
@@ -885,11 +927,8 @@ impl PathItem {
             ),
         }
     }
-    fn base_name(&self) -> &str {
+    pub fn base_name(&self) -> &str {
-        Path::new(&self.name)
+        self.name.split('/').last().unwrap_or_default()
-            .file_name()
-            .and_then(|v| v.to_str())
-            .unwrap_or_default()
     }
 }
 
@@ -953,19 +992,30 @@ fn res_multistatus(res: &mut Response, content: &str) {
     ));
 }
 
-async fn zip_dir<W: AsyncWrite + Unpin>(writer: &mut W, dir: &Path) -> BoxResult<()> {
+async fn zip_dir<W: AsyncWrite + Unpin>(writer: &mut W, dir: &Path, hidden: &str) -> BoxResult<()> {
     let mut writer = ZipFileWriter::new(writer);
-    let mut walkdir = WalkDir::new(dir);
+    let hidden = hidden.to_string();
+    let mut walkdir = WalkDir::new(dir).filter(move |entry| {
+        let hidden = hidden.clone();
+        async move {
+            let entry_path = entry.path();
+            let base_name = get_file_name(&entry_path);
+            if is_hidden(&hidden, base_name) {
+                return Filtering::IgnoreDir;
+            }
+            let meta = match fs::symlink_metadata(entry.path()).await {
+                Ok(meta) => meta,
+                Err(_) => return Filtering::Ignore,
+            };
+            if !meta.is_file() {
+                return Filtering::Ignore;
+            }
+            Filtering::Continue
+        }
+    });
     while let Some(entry) = walkdir.next().await {
         if let Ok(entry) = entry {
             let entry_path = entry.path();
-            let meta = match fs::symlink_metadata(entry.path()).await {
-                Ok(meta) => meta,
-                Err(_) => continue,
-            };
-            if !meta.is_file() {
-                continue;
-            }
             let filename = match entry_path.strip_prefix(dir).ok().and_then(|v| v.to_str()) {
                 Some(v) => v,
                 None => continue,
@@ -1036,10 +1086,8 @@ fn status_no_content(res: &mut Response) {
     *res.status_mut() = StatusCode::NO_CONTENT;
 }
 
-fn get_file_name(path: &Path) -> BoxResult<&str> {
+fn is_hidden(hidden: &str, file_name: &str) -> bool {
-    path.file_name()
+    hidden.contains(&format!(",{},", file_name))
-        .and_then(|v| v.to_str())
-        .ok_or_else(|| format!("Failed to get file name of `{}`", path.display()).into())
 }
 
 fn set_webdav_headers(res: &mut Response) {

src/utils.rs

@@ -1,4 +1,5 @@
-use std::borrow::Cow;
+use crate::BoxResult;
+use std::{borrow::Cow, path::Path};
 
 pub fn encode_uri(v: &str) -> String {
     let parts: Vec<_> = v.split('/').map(urlencoding::encode).collect();
@@ -10,3 +11,15 @@ pub fn decode_uri(v: &str) -> Option<Cow<str>> {
         .decode_utf8()
         .ok()
 }
+
+pub fn get_file_name(path: &Path) -> &str {
+    path.file_name()
+        .and_then(|v| v.to_str())
+        .unwrap_or_default()
+}
+
+pub fn try_get_file_name(path: &Path) -> BoxResult<&str> {
+    path.file_name()
+        .and_then(|v| v.to_str())
+        .ok_or_else(|| format!("Failed to get file name of `{}`", path.display()).into())
+}

tests/allow.rs

@@ -67,7 +67,7 @@ fn allow_search(#[with(&["--allow-search"])] server: TestServer) -> Result<(), E
     let paths = utils::retrive_index_paths(&resp.text()?);
     assert!(!paths.is_empty());
     for p in paths {
-        assert!(p.contains(&"test.html"));
+        assert!(p.contains("test.html"));
     }
     Ok(())
 }

tests/args.rs

@@ -10,7 +10,7 @@ use std::process::{Command, Stdio};
 #[rstest]
 fn path_prefix_index(#[with(&["--path-prefix", "xyz"])] server: TestServer) -> Result<(), Error> {
     let resp = reqwest::blocking::get(format!("{}{}", server.url(), "xyz"))?;
-    assert_index_resp!(resp);
+    assert_resp_paths!(resp);
     Ok(())
 }
 
@@ -36,7 +36,6 @@ fn path_prefix_propfind(
 #[case("index.html")]
 fn serve_single_file(tmpdir: TempDir, port: u16, #[case] file: &str) -> Result<(), Error> {
     let mut child = Command::cargo_bin("dufs")?
-        .env("RUST_LOG", "false")
         .arg(tmpdir.path().join(file))
         .arg("-p")
         .arg(port.to_string())

tests/assets.rs

@@ -0,0 +1,93 @@
+mod fixtures;
+mod utils;
+
+use fixtures::{server, Error, TestServer};
+use rstest::rstest;
+
+#[rstest]
+fn assets(server: TestServer) -> Result<(), Error> {
+    let ver = env!("CARGO_PKG_VERSION");
+    let resp = reqwest::blocking::get(server.url())?;
+    let index_js = format!("/__dufs_v{}_index.js", ver);
+    let index_css = format!("/__dufs_v{}_index.css", ver);
+    let favicon_ico = format!("/__dufs_v{}_favicon.ico", ver);
+    let text = resp.text()?;
+    assert!(text.contains(&format!(r#"href="{}""#, index_css)));
+    assert!(text.contains(&format!(r#"href="{}""#, favicon_ico)));
+    assert!(text.contains(&format!(r#"src="{}""#, index_js)));
+    Ok(())
+}
+
+#[rstest]
+fn asset_js(server: TestServer) -> Result<(), Error> {
+    let url = format!(
+        "{}__dufs_v{}_index.js",
+        server.url(),
+        env!("CARGO_PKG_VERSION")
+    );
+    let resp = reqwest::blocking::get(url)?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(
+        resp.headers().get("content-type").unwrap(),
+        "application/javascript"
+    );
+    Ok(())
+}
+
+#[rstest]
+fn asset_css(server: TestServer) -> Result<(), Error> {
+    let url = format!(
+        "{}__dufs_v{}_index.css",
+        server.url(),
+        env!("CARGO_PKG_VERSION")
+    );
+    let resp = reqwest::blocking::get(url)?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(resp.headers().get("content-type").unwrap(), "text/css");
+    Ok(())
+}
+
+#[rstest]
+fn asset_ico(server: TestServer) -> Result<(), Error> {
+    let url = format!(
+        "{}__dufs_v{}_favicon.ico",
+        server.url(),
+        env!("CARGO_PKG_VERSION")
+    );
+    let resp = reqwest::blocking::get(url)?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(resp.headers().get("content-type").unwrap(), "image/x-icon");
+    Ok(())
+}
+
+#[rstest]
+fn assets_with_prefix(#[with(&["--path-prefix", "xyz"])] server: TestServer) -> Result<(), Error> {
+    let ver = env!("CARGO_PKG_VERSION");
+    let resp = reqwest::blocking::get(format!("{}xyz/", server.url()))?;
+    let index_js = format!("/xyz/__dufs_v{}_index.js", ver);
+    let index_css = format!("/xyz/__dufs_v{}_index.css", ver);
+    let favicon_ico = format!("/xyz/__dufs_v{}_favicon.ico", ver);
+    let text = resp.text()?;
+    assert!(text.contains(&format!(r#"href="{}""#, index_css)));
+    assert!(text.contains(&format!(r#"href="{}""#, favicon_ico)));
+    assert!(text.contains(&format!(r#"src="{}""#, index_js)));
+    Ok(())
+}
+
+#[rstest]
+fn asset_js_with_prefix(
+    #[with(&["--path-prefix", "xyz"])] server: TestServer,
+) -> Result<(), Error> {
+    let url = format!(
+        "{}xyz/__dufs_v{}_index.js",
+        server.url(),
+        env!("CARGO_PKG_VERSION")
+    );
+    let resp = reqwest::blocking::get(url)?;
+    assert_eq!(resp.status(), 200);
+    assert_eq!(
+        resp.headers().get("content-type").unwrap(),
+        "application/javascript"
+    );
+    Ok(())
+}

tests/bind.rs

@@ -6,14 +6,13 @@ use assert_cmd::prelude::*;
 use assert_fs::fixture::TempDir;
 use regex::Regex;
 use rstest::rstest;
-use std::io::{BufRead, BufReader};
+use std::io::Read;
 use std::process::{Command, Stdio};
 
 #[rstest]
 #[case(&["-b", "20.205.243.166"])]
 fn bind_fails(tmpdir: TempDir, port: u16, #[case] args: &[&str]) -> Result<(), Error> {
     Command::cargo_bin("dufs")?
-        .env("RUST_LOG", "false")
         .arg(tmpdir.path())
         .arg("-p")
         .arg(port.to_string())
@@ -51,7 +50,6 @@ fn bind_ipv4_ipv6(
 #[case(&["--path-prefix", "/prefix"])]
 fn validate_printed_urls(tmpdir: TempDir, port: u16, #[case] args: &[&str]) -> Result<(), Error> {
     let mut child = Command::cargo_bin("dufs")?
-        .env("RUST_LOG", "false")
         .arg(tmpdir.path())
         .arg("-p")
         .arg(port.to_string())
@@ -61,22 +59,23 @@ fn validate_printed_urls(tmpdir: TempDir, port: u16, #[case] args: &[&str]) -> R
 
     wait_for_port(port);
 
-    // WARN assumes urls list is terminated by an empty line
+    let stdout = child.stdout.as_mut().expect("Failed to get stdout");
-    let url_lines = BufReader::new(child.stdout.take().unwrap())
+    let mut buf = [0; 1000];
+    let buf_len = stdout.read(&mut buf)?;
+    let output = std::str::from_utf8(&buf[0..buf_len])?;
+    let url_lines = output
         .lines()
-        .map(|line| line.expect("Error reading stdout"))
         .take_while(|line| !line.is_empty()) /* non-empty lines */
-        .collect::<Vec<_>>();
+        .collect::<Vec<_>>()
-    let url_lines = url_lines.join("\n");
+        .join("\n");
 
     let urls = Regex::new(r"http://[a-zA-Z0-9\.\[\]:/]+")
         .unwrap()
         .captures_iter(url_lines.as_str())
-        .map(|caps| caps.get(0).unwrap().as_str())
+        .filter_map(|caps| caps.get(0).map(|v| v.as_str()))
         .collect::<Vec<_>>();
 
     assert!(!urls.is_empty());
-
     for url in urls {
         reqwest::blocking::get(url)?.error_for_status()?;
     }

tests/favicon.rs

@@ -1,25 +0,0 @@
-mod fixtures;
-mod utils;
-
-use fixtures::{server, Error, TestServer};
-use rstest::rstest;
-
-#[rstest]
-fn default_favicon(server: TestServer) -> Result<(), Error> {
-    let resp = reqwest::blocking::get(format!("{}favicon.ico", server.url()))?;
-    assert_eq!(resp.status(), 200);
-    assert_eq!(resp.headers().get("content-type").unwrap(), "image/x-icon");
-    Ok(())
-}
-
-#[rstest]
-fn exist_favicon(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
-    let url = format!("{}favicon.ico", server.url());
-    let data = b"abc";
-    let resp = fetch!(b"PUT", &url).body(data.to_vec()).send()?;
-    assert_eq!(resp.status(), 201);
-    let resp = reqwest::blocking::get(url)?;
-    assert_eq!(resp.status(), 200);
-    assert_eq!(resp.bytes()?, data.to_vec());
-    Ok(())
-}

tests/fixtures.rs

@@ -13,21 +13,7 @@ pub type Error = Box<dyn std::error::Error>;
 
 /// File names for testing purpose
 #[allow(dead_code)]
-pub static FILES: &[&str] = &[
+pub static FILES: &[&str] = &["test.txt", "test.html", "index.html", "😀.bin"];
-    "test.txt",
-    "test.html",
-    "index.html",
-    "test.mkv",
-    #[cfg(not(windows))]
-    "test \" \' & < >.csv",
-    "😀.data",
-    "⎙.mp4",
-    "#[]{}()@!$&'`+,;= %20.test",
-    #[cfg(unix)]
-    ":?#[]{}<>()@!$&'`|*+,;= %20.test",
-    #[cfg(not(windows))]
-    "foo\\bar.test",
-];
 
 /// Directory names for testing diretory don't exist
 #[allow(dead_code)]
@@ -37,13 +23,13 @@ pub static DIR_NO_FOUND: &str = "dir-no-found/";
 #[allow(dead_code)]
 pub static DIR_NO_INDEX: &str = "dir-no-index/";
 
+/// Directory names for testing hidden
+#[allow(dead_code)]
+pub static DIR_GIT: &str = ".git/";
+
 /// Directory names for testing purpose
 #[allow(dead_code)]
-pub static DIRECTORIES: &[&str] = &["dira/", "dirb/", "dirc/", DIR_NO_INDEX];
+pub static DIRECTORIES: &[&str] = &["dira/", "dirb/", "dirc/", DIR_NO_INDEX, DIR_GIT];
-
-/// Name of a deeply nested file
-#[allow(dead_code)]
-pub static DEEPLY_NESTED_FILE: &str = "very/deeply/nested/test.rs";
 
 /// Test fixture which creates a temporary directory with a few files and directories inside.
 /// The directories also contain files.
@@ -69,10 +55,6 @@ pub fn tmpdir() -> TempDir {
         }
     }
 
-    tmpdir
-        .child(&DEEPLY_NESTED_FILE)
-        .write_str("File in a deeply nested directory.")
-        .expect("Couldn't write to file");
     tmpdir
 }
 
@@ -96,7 +78,6 @@ where
     let tmpdir = tmpdir();
     let child = Command::cargo_bin("dufs")
         .expect("Couldn't find test binary")
-        .env("RUST_LOG", "false")
         .arg(tmpdir.path())
         .arg("-p")
         .arg(port.to_string())
@@ -124,7 +105,6 @@ where
     let tmpdir = tmpdir();
     let child = Command::cargo_bin("dufs")
         .expect("Couldn't find test binary")
-        .env("RUST_LOG", "false")
         .arg(tmpdir.path())
         .arg("-p")
         .arg(port.to_string())

tests/hidden.rs

@@ -0,0 +1,42 @@
+mod fixtures;
+mod utils;
+
+use fixtures::{server, Error, TestServer};
+use rstest::rstest;
+
+#[rstest]
+#[case(server(&[] as &[&str]), true)]
+#[case(server(&["--hidden", ".git,index.html"]), false)]
+fn hidden_get_dir(#[case] server: TestServer, #[case] exist: bool) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(server.url())?;
+    assert_eq!(resp.status(), 200);
+    let paths = utils::retrive_index_paths(&resp.text()?);
+    assert_eq!(paths.contains(".git/"), exist);
+    assert_eq!(paths.contains("index.html"), exist);
+    Ok(())
+}
+
+#[rstest]
+#[case(server(&[] as &[&str]), true)]
+#[case(server(&["--hidden", ".git,index.html"]), false)]
+fn hidden_propfind_dir(#[case] server: TestServer, #[case] exist: bool) -> Result<(), Error> {
+    let resp = fetch!(b"PROPFIND", server.url()).send()?;
+    assert_eq!(resp.status(), 207);
+    let body = resp.text()?;
+    assert_eq!(body.contains("<D:href>/.git/</D:href>"), exist);
+    assert_eq!(body.contains("<D:href>/index.html</D:href>"), exist);
+    Ok(())
+}
+
+#[rstest]
+#[case(server(&["--allow-search"] as &[&str]), true)]
+#[case(server(&["--allow-search", "--hidden", ".git,test.html"]), false)]
+fn hidden_search_dir(#[case] server: TestServer, #[case] exist: bool) -> Result<(), Error> {
+    let resp = reqwest::blocking::get(format!("{}?q={}", server.url(), "test.html"))?;
+    assert_eq!(resp.status(), 200);
+    let paths = utils::retrive_index_paths(&resp.text()?);
+    for p in paths {
+        assert_eq!(p.contains("test.html"), exist);
+    }
+    Ok(())
+}

tests/http.rs

@@ -7,7 +7,7 @@ use rstest::rstest;
 #[rstest]
 fn get_dir(server: TestServer) -> Result<(), Error> {
     let resp = reqwest::blocking::get(server.url())?;
-    assert_index_resp!(resp);
+    assert_resp_paths!(resp);
     Ok(())
 }
 
@@ -69,19 +69,19 @@ fn get_dir_search(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
     let paths = utils::retrive_index_paths(&resp.text()?);
     assert!(!paths.is_empty());
     for p in paths {
-        assert!(p.contains(&"test.html"));
+        assert!(p.contains("test.html"));
     }
     Ok(())
 }
 
 #[rstest]
 fn get_dir_search2(#[with(&["-A"])] server: TestServer) -> Result<(), Error> {
-    let resp = reqwest::blocking::get(format!("{}?q={}", server.url(), "😀.data"))?;
+    let resp = reqwest::blocking::get(format!("{}?q={}", server.url(), "😀.bin"))?;
     assert_eq!(resp.status(), 200);
     let paths = utils::retrive_index_paths(&resp.text()?);
     assert!(!paths.is_empty());
     for p in paths {
-        assert!(p.contains(&"😀.data"));
+        assert!(p.contains("😀.bin"));
     }
     Ok(())
 }

tests/render.rs

@@ -1,7 +1,7 @@
 mod fixtures;
 mod utils;
 
-use fixtures::{server, Error, TestServer, DIR_NO_FOUND, DIR_NO_INDEX};
+use fixtures::{server, Error, TestServer, DIR_NO_FOUND, DIR_NO_INDEX, FILES};
 use rstest::rstest;
 
 #[rstest]
@@ -30,12 +30,12 @@ fn render_try_index(#[with(&["--render-try-index"])] server: TestServer) -> Resu
 #[rstest]
 fn render_try_index2(#[with(&["--render-try-index"])] server: TestServer) -> Result<(), Error> {
     let resp = reqwest::blocking::get(format!("{}{}", server.url(), DIR_NO_INDEX))?;
-    let files: Vec<&str> = self::fixtures::FILES
+    let files: Vec<&str> = FILES
         .iter()
         .filter(|v| **v != "index.html")
         .cloned()
         .collect();
-    assert_index_resp!(resp, files);
+    assert_resp_paths!(resp, files);
     Ok(())
 }
 

tests/tls.rs

@@ -22,7 +22,7 @@ fn tls_works(#[case] server: TestServer) -> Result<(), Error> {
         .danger_accept_invalid_certs(true)
         .build()?;
     let resp = client.get(server.url()).send()?.error_for_status()?;
-    assert_index_resp!(resp);
+    assert_resp_paths!(resp);
     Ok(())
 }
 

tests/utils.rs

@@ -2,9 +2,9 @@ use serde_json::Value;
 use std::collections::HashSet;
 
 #[macro_export]
-macro_rules! assert_index_resp {
+macro_rules! assert_resp_paths {
     ($resp:ident) => {
-        assert_index_resp!($resp, self::fixtures::FILES)
+        assert_resp_paths!($resp, self::fixtures::FILES)
     };
     ($resp:ident, $files:expr) => {
         assert_eq!($resp.status(), 200);
@@ -37,12 +37,8 @@ pub fn encode_uri(v: &str) -> String {
 
 fn retrive_index_paths_impl(index: &str) -> Option<HashSet<String>> {
     let lines: Vec<&str> = index.lines().collect();
-    let (i, _) = lines
+    let line = lines.iter().find(|v| v.contains("DATA ="))?;
-        .iter()
+    let value: Value = line[7..].parse().ok()?;
-        .enumerate()
-        .find(|(_, v)| v.contains("const DATA"))?;
-    let line = lines.get(i + 1)?;
-    let value: Value = line.parse().ok()?;
     let paths = value
         .get("paths")?
         .as_array()?