feature: support http static file server

Author: runningwater

Cargo.lock

@@ -9,6 +9,7 @@ license = "MIT"
 
 [dependencies]
 anyhow = "1.0.86"
+axum = { version = "0.7.5", features = ["http2", "query", "tracing"] }
 base64 = "0.22.1"
 blake3 = "1.5.1"
 clap = { version = "4.5.7", features = ["derive"] }
@@ -18,4 +19,7 @@ rand = "0.8.5"
 serde = { version = "1.0.203", features = ["derive"] }
 serde_json = "1.0.118"
 serde_yml = "0.0.10"
+tokio = { version = "1.38.0", features = ["fs", "macros", "net", "rt", "rt-multi-thread"] }
+tracing = "0.1.40"
+tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
 zxcvbn = "3.0.1" # zxcvbn is a password strength estimator based off of Dropbox’s zxcvbn library.

Cargo.toml

@@ -0,0 +1,18 @@
+use clap::Parser;
+use std::path::PathBuf;
+
+use super::verify_path;
+
+#[derive(Debug, Parser)]
+pub enum HttpSubCommand {
+    #[command(about = "Serve a directory over HTTP")]
+    Serve(HttpServeOpts),
+}
+
+#[derive(Debug, Parser)]
+pub struct HttpServeOpts {
+    #[arg(short, long, value_parser = verify_path, default_value = ".")]
+    pub dir: PathBuf,
+    #[arg(short, long, default_value_t = 8080)]
+    pub port: u16,
+}

src/cli/http.rs

@@ -7,12 +7,14 @@ use self::genpass::GenPassOpts;
 pub use self::{
     base64::{Base64Format, Base64SubCommand},
     csv::OutputFormat,
+    http::HttpSubCommand,
     text::{TextSignFormat, TextSubCommand},
 };
 
 mod base64;
 mod csv;
 mod genpass;
+mod http;
 mod text;
 
 #[derive(Debug, Parser)]
@@ -32,6 +34,8 @@ pub enum SubCommand {
     Base64(Base64SubCommand),
     #[command(subcommand, about = "Message Sign, or Verify")]
     Text(TextSubCommand),
+    #[command(subcommand, about = "Serve a directory over HTTP")]
+    Http(HttpSubCommand),
 }
 
 pub fn verify_file(filename: &str) -> Result<String, &'static str> {

src/cli/mod.rs

@@ -1,7 +1,10 @@
-pub use cli::{Base64Format, Base64SubCommand, Opts, SubCommand, TextSignFormat, TextSubCommand};
+pub use cli::{
+    Base64Format, Base64SubCommand, HttpSubCommand, Opts, SubCommand, TextSignFormat,
+    TextSubCommand,
+};
 pub use process::{
-    process_csv, process_decode, process_encode, process_genpass, process_text_generate,
-    process_text_sign, process_text_verify,
+    process_csv, process_decode, process_encode, process_genpass, process_http_serve,
+    process_text_generate, process_text_sign, process_text_verify,
 };
 pub use utils::*;
 

src/lib.rs

@@ -10,11 +10,14 @@ use clap::Parser;
 use zxcvbn::zxcvbn;
 
 use rcli::{
-    process_csv, process_decode, process_encode, process_genpass, process_text_generate,
-    process_text_sign, process_text_verify, Base64SubCommand, Opts, SubCommand, TextSubCommand,
+    process_csv, process_decode, process_encode, process_genpass, process_http_serve,
+    process_text_generate, process_text_sign, process_text_verify, Base64SubCommand,
+    HttpSubCommand, Opts, SubCommand, TextSubCommand,
 };
 
-fn main() -> anyhow::Result<()> {
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt::init();
     let opts = Opts::parse();
     match opts.cmd {
         SubCommand::Csv(opts) => {
@@ -73,6 +76,9 @@ fn main() -> anyhow::Result<()> {
                 }
             }
         },
+        SubCommand::Http(cmd) => match cmd {
+            HttpSubCommand::Serve(opts) => process_http_serve(opts.dir, opts.port).await?,
+        },
     }
     Ok(())
 }

src/main.rs

@@ -0,0 +1,55 @@
+use anyhow::Result;
+use axum::extract::{Path, State};
+use axum::http::StatusCode;
+use axum::routing::get;
+use axum::Router;
+use std::net::SocketAddr;
+use std::path::PathBuf;
+use std::sync::Arc;
+use tracing::{info, warn};
+
+#[derive(Debug)]
+struct HttpServeState {
+    path: PathBuf,
+}
+
+pub async fn process_http_serve(path: PathBuf, port: u16) -> Result<()> {
+    let addr = SocketAddr::from(([0, 0, 0, 0], port));
+    info!("Serving: {:?} on  {}", path.as_path(), addr);
+    let state = HttpServeState { path };
+    // axum router
+    let router = Router::new()
+        .route("/*path", get(file_handler))
+        .with_state(Arc::new(state));
+
+    // run our app with hyper, listening globally on port 3000
+    let listener = tokio::net::TcpListener::bind(addr).await?;
+
+    axum::serve(listener, router).await?;
+    Ok(())
+}
+
+async fn file_handler(
+    State(state): State<Arc<HttpServeState>>,
+    Path(path): Path<String>,
+) -> (StatusCode, String) {
+    let p = std::path::Path::new(&state.path).join(path);
+    info!("Reading file {:?}", p);
+    if !p.exists() {
+        (
+            StatusCode::NOT_FOUND,
+            format!("File {} Not Found", p.display()),
+        )
+    } else {
+        match tokio::fs::read_to_string(p).await {
+            Ok(content) => {
+                info!("Read {} bytes", content.len());
+                (StatusCode::OK, content)
+            }
+            Err(e) => {
+                warn!("Error reading file: {:?}", e);
+                (StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
+            }
+        }
+    }
+}

src/process/http_serve.rs

@@ -1,9 +1,11 @@
-mod b64;
-mod csv_convert;
-mod gen_pass;
-mod text;
-
 pub use b64::{process_decode, process_encode};
 pub use csv_convert::process_csv;
 pub use gen_pass::process_genpass;
+pub use http_serve::process_http_serve;
 pub use text::{process_text_generate, process_text_sign, process_text_verify};
+
+mod b64;
+mod csv_convert;
+mod gen_pass;
+mod http_serve;
+mod text;

src/process/mod.rs

@@ -0,0 +1,4 @@
+### GET request to example server
+GET http://localhost:8080/Cargo.toml
+
+###