Use tracing

Cargo.toml

@@ -2,7 +2,7 @@
 name = "bunbun"
 version = "0.8.0"
 authors = ["Edward Shen <code@eddie.sh>"]
-edition = "2018"
+edition = "2021"
 description = "Re-implementation of bunny1 in Rust"
 license = "AGPL-3.0"
 readme = "README.md"
@@ -10,20 +10,25 @@ repository = "https://github.com/edward-shen/bunbun"
 exclude = ["/aux/"]
 
 [dependencies]
-actix-web = "3"
+anyhow = "1"
-clap = { version = "3.0.0-beta.2", features = ["wrap_help"] }
+arc-swap = "1"
-dirs = "3"
+tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
-handlebars = "3"
+axum = "0.5"
+clap = { version = "3", features = ["wrap_help", "derive", "cargo"] }
+dirs = "4"
+handlebars = "4"
 hotwatch = "0.4"
-log = "0.4"
 percent-encoding = "2"
-serde = "1"
+serde = { version = "1", features = ["derive"] }
 serde_yaml = "0.8"
 serde_json = "1"
-simple_logger = "1"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 
 [dev-dependencies]
 tempfile = "3"
 
 [profile.release]
 lto = true
+codegen-units = 1
+strip = true

rustfmt.toml

@@ -1,3 +0,0 @@
-tab_spaces = 2
-use_field_init_shorthand = true
-max_width = 80

src/cli.rs

@@ -1,19 +1,17 @@
-use clap::{crate_authors, crate_version, Clap};
+use clap::{crate_authors, crate_version, Parser};
 use std::path::PathBuf;
+use tracing_subscriber::filter::Directive;
 
-#[derive(Clap)]
+#[derive(Parser)]
 #[clap(version = crate_version!(), author = crate_authors!())]
 pub struct Opts {
-  /// Increases the log level to info, debug, and trace, respectively.
+    /// Set the logging directives
-  #[clap(short, long, parse(from_occurrences), conflicts_with("quiet"))]
+    #[clap(long, default_value = "info")]
-  pub verbose: u8,
+    pub log: Vec<Directive>,
-  /// Decreases the log level to error or no logging at all, respectively.
+    /// Specify the location of the config file to read from. Needs read/write permissions.
-  #[clap(short, long, parse(from_occurrences), conflicts_with("verbose"))]
+    #[clap(short, long)]
-  pub quiet: u8,
+    pub config: Option<PathBuf>,
-  /// Specify the location of the config file to read from. Needs read/write permissions.
+    /// Allow config sizes larger than 100MB.
-  #[clap(short, long)]
+    #[clap(long)]
-  pub config: Option<PathBuf>,
+    pub large_config: bool,
-  /// Allow config sizes larger than 100MB.
-  #[clap(long)]
-  pub large_config: bool,
 }

src/config.rs

@@ -1,16 +1,15 @@
 use crate::BunBunError;
 use dirs::{config_dir, home_dir};
-use log::{debug, info, trace};
 use serde::{
-  de::{self, Deserializer, MapAccess, Unexpected, Visitor},
+    de::{self, Deserializer, MapAccess, Unexpected, Visitor},
-  Deserialize, Serialize,
+    Deserialize, Serialize,
 };
 use std::collections::HashMap;
 use std::fmt;
 use std::fs::{File, OpenOptions};
 use std::io::{Read, Write};
 use std::path::PathBuf;
-use std::str::FromStr;
+use tracing::{debug, info, trace};
 
 const CONFIG_FILENAME: &str = "bunbun.yaml";
 const DEFAULT_CONFIG: &[u8] = include_bytes!("../bunbun.default.yaml");
@@ -21,43 +20,55 @@ const LARGE_FILE_SIZE_THRESHOLD: u64 = 1_000_000;
 
 #[derive(Deserialize, Debug, PartialEq)]
 pub struct Config {
-  pub bind_address: String,
+    pub bind_address: String,
-  pub public_address: String,
+    pub public_address: String,
-  pub default_route: Option<String>,
+    pub default_route: Option<String>,
-  pub groups: Vec<RouteGroup>,
+    pub groups: Vec<RouteGroup>,
 }
 
 #[derive(Deserialize, Serialize, Debug, PartialEq, Clone)]
 pub struct RouteGroup {
-  pub name: String,
+    pub name: String,
-  pub description: Option<String>,
+    pub description: Option<String>,
-  #[serde(default)]
+    #[serde(default)]
-  pub hidden: bool,
+    pub hidden: bool,
-  pub routes: HashMap<String, Route>,
+    pub routes: HashMap<String, Route>,
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize)]
 pub struct Route {
-  pub route_type: RouteType,
+    pub route_type: RouteType,
-  pub path: String,
+    pub path: String,
-  pub hidden: bool,
+    pub hidden: bool,
-  pub description: Option<String>,
+    pub description: Option<String>,
-  pub min_args: Option<usize>,
+    pub min_args: Option<usize>,
-  pub max_args: Option<usize>,
+    pub max_args: Option<usize>,
 }
 
-impl FromStr for Route {
+impl From<String> for Route {
-  type Err = std::convert::Infallible;
+    fn from(s: String) -> Self {
-  fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self {
-    Ok(Self {
+            route_type: get_route_type(&s),
-      route_type: get_route_type(s),
+            path: s,
-      path: s.to_string(),
+            hidden: false,
-      hidden: false,
+            description: None,
-      description: None,
+            min_args: None,
-      min_args: None,
+            max_args: None,
-      max_args: None,
+        }
-    })
+    }
-  }
+}
+
+impl From<&'static str> for Route {
+    fn from(s: &'static str) -> Self {
+        Self {
+            route_type: get_route_type(s),
+            path: s.to_string(),
+            hidden: false,
+            description: None,
+            min_args: None,
+            max_args: None,
+        }
+    }
 }
 
 /// Deserialization of the route string into the enum requires us to figure out
@@ -66,353 +77,350 @@ impl FromStr for Route {
 /// web path. This incurs a disk check operation, but since users shouldn't be
 /// updating the config that frequently, it should be fine.
 impl<'de> Deserialize<'de> for Route {
-  fn deserialize<D>(deserializer: D) -> Result<Route, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-  where
+    where
-    D: Deserializer<'de>,
+        D: Deserializer<'de>,
-  {
+    {
-    #[derive(Deserialize)]
+        #[derive(Deserialize)]
-    #[serde(field_identifier, rename_all = "snake_case")]
+        #[serde(field_identifier, rename_all = "snake_case")]
-    enum Field {
+        enum Field {
-      Path,
+            Path,
-      Hidden,
+            Hidden,
-      Description,
+            Description,
-      MinArgs,
+            MinArgs,
-      MaxArgs,
+            MaxArgs,
-    }
-
-    struct RouteVisitor;
-
-    impl<'de> Visitor<'de> for RouteVisitor {
-      type Value = Route;
-
-      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("string")
-      }
-
-      fn visit_str<E>(self, path: &str) -> Result<Self::Value, E>
-      where
-        E: serde::de::Error,
-      {
-        // This is infallible
-        Ok(Self::Value::from_str(path).unwrap())
-      }
-
-      fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
-      where
-        M: MapAccess<'de>,
-      {
-        let mut path = None;
-        let mut hidden = None;
-        let mut description = None;
-        let mut min_args = None;
-        let mut max_args = None;
-
-        while let Some(key) = map.next_key()? {
-          match key {
-            Field::Path => {
-              if path.is_some() {
-                return Err(de::Error::duplicate_field("path"));
-              }
-              path = Some(map.next_value::<String>()?);
-            }
-            Field::Hidden => {
-              if hidden.is_some() {
-                return Err(de::Error::duplicate_field("hidden"));
-              }
-              hidden = map.next_value()?;
-            }
-            Field::Description => {
-              if description.is_some() {
-                return Err(de::Error::duplicate_field("description"));
-              }
-              description = Some(map.next_value()?);
-            }
-            Field::MinArgs => {
-              if min_args.is_some() {
-                return Err(de::Error::duplicate_field("min_args"));
-              }
-              min_args = Some(map.next_value()?);
-            }
-            Field::MaxArgs => {
-              if max_args.is_some() {
-                return Err(de::Error::duplicate_field("max_args"));
-              }
-              max_args = Some(map.next_value()?);
-            }
-          }
         }
 
-        if let (Some(min_args), Some(max_args)) = (min_args, max_args) {
+        struct RouteVisitor;
-          if min_args > max_args {
+
+        impl<'de> Visitor<'de> for RouteVisitor {
+            type Value = Route;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("string")
+            }
+
+            fn visit_str<E>(self, path: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
             {
-              return Err(de::Error::invalid_value(
+                Ok(Self::Value::from(path.to_owned()))
-                Unexpected::Other(&format!(
+            }
-                  "argument count range {} to {}",
+
-                  min_args, max_args
+            fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
-                )),
+            where
-                &"a valid argument count range",
+                M: MapAccess<'de>,
-              ));
+            {
+                let mut path = None;
+                let mut hidden = None;
+                let mut description = None;
+                let mut min_args = None;
+                let mut max_args = None;
+
+                while let Some(key) = map.next_key()? {
+                    match key {
+                        Field::Path => {
+                            if path.is_some() {
+                                return Err(de::Error::duplicate_field("path"));
+                            }
+                            path = Some(map.next_value::<String>()?);
+                        }
+                        Field::Hidden => {
+                            if hidden.is_some() {
+                                return Err(de::Error::duplicate_field("hidden"));
+                            }
+                            hidden = map.next_value()?;
+                        }
+                        Field::Description => {
+                            if description.is_some() {
+                                return Err(de::Error::duplicate_field("description"));
+                            }
+                            description = Some(map.next_value()?);
+                        }
+                        Field::MinArgs => {
+                            if min_args.is_some() {
+                                return Err(de::Error::duplicate_field("min_args"));
+                            }
+                            min_args = Some(map.next_value()?);
+                        }
+                        Field::MaxArgs => {
+                            if max_args.is_some() {
+                                return Err(de::Error::duplicate_field("max_args"));
+                            }
+                            max_args = Some(map.next_value()?);
+                        }
+                    }
+                }
+
+                if let (Some(min_args), Some(max_args)) = (min_args, max_args) {
+                    if min_args > max_args {
+                        {
+                            return Err(de::Error::invalid_value(
+                                Unexpected::Other(&format!(
+                                    "argument count range {min_args} to {max_args}",
+                                )),
+                                &"a valid argument count range",
+                            ));
+                        }
+                    }
+                }
+
+                let path = path.ok_or_else(|| de::Error::missing_field("path"))?;
+                Ok(Route {
+                    route_type: get_route_type(&path),
+                    path,
+                    hidden: hidden.unwrap_or_default(),
+                    description,
+                    min_args,
+                    max_args,
+                })
             }
-          }
         }
 
-        let path = path.ok_or_else(|| de::Error::missing_field("path"))?;
+        deserializer.deserialize_any(RouteVisitor)
-        Ok(Route {
-          route_type: get_route_type(&path),
-          path,
-          hidden: hidden.unwrap_or_default(),
-          description,
-          min_args,
-          max_args,
-        })
-      }
     }
-
-    deserializer.deserialize_any(RouteVisitor)
-  }
 }
 
 impl std::fmt::Display for Route {
-  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    match self {
+        match self {
-      Self {
+            Self {
-        route_type: RouteType::External,
+                route_type: RouteType::External,
-        path,
+                path,
-        ..
+                ..
-      } => write!(f, "raw ({})", path),
+            } => write!(f, "raw ({path})"),
-      Self {
+            Self {
-        route_type: RouteType::Internal,
+                route_type: RouteType::Internal,
-        path,
+                path,
-        ..
+                ..
-      } => write!(f, "file ({})", path),
+            } => write!(f, "file ({path})"),
+        }
     }
-  }
 }
 
 /// Classifies the path depending on if the there exists a local file.
 fn get_route_type(path: &str) -> RouteType {
-  if std::path::Path::new(path).exists() {
+    if std::path::Path::new(path).exists() {
-    debug!("Parsed {} as a valid local path.", path);
+        debug!("Parsed {path} as a valid local path.");
-    RouteType::Internal
+        RouteType::Internal
-  } else {
+    } else {
-    debug!("{} does not exist on disk, assuming web path.", path);
+        debug!("{path} does not exist on disk, assuming web path.");
-    RouteType::External
+        RouteType::External
-  }
+    }
 }
 
 /// There exists two route types: an external path (e.g. a URL) or an internal
 /// path (to a file).
 #[derive(Debug, PartialEq, Clone, Serialize)]
 pub enum RouteType {
-  External,
+    External,
-  Internal,
+    Internal,
 }
 
-pub struct ConfigData {
+pub struct FileData {
-  pub path: PathBuf,
+    pub path: PathBuf,
-  pub file: File,
+    pub file: File,
 }
 
 /// If a provided config path isn't found, this function checks known good
 /// locations for a place to write a config file to. In order, it checks the
 /// system-wide config location (`/etc/`, in Linux), followed by the config
 /// folder, followed by the user's home folder.
-pub fn get_config_data() -> Result<ConfigData, BunBunError> {
+pub fn get_config_data() -> Result<FileData, BunBunError> {
-  // Locations to check, with highest priority first
+    // Locations to check, with highest priority first
-  let locations: Vec<_> = {
+    let locations: Vec<_> = {
-    let mut folders = vec![PathBuf::from("/etc/")];
+        let mut folders = vec![PathBuf::from("/etc/")];
 
-    // Config folder
+        // Config folder
-    if let Some(folder) = config_dir() {
+        if let Some(folder) = config_dir() {
-      folders.push(folder)
+            folders.push(folder);
+        }
+
+        // Home folder
+        if let Some(folder) = home_dir() {
+            folders.push(folder);
+        }
+
+        folders
+            .iter_mut()
+            .for_each(|folder| folder.push(CONFIG_FILENAME));
+
+        folders
+    };
+
+    debug!("Checking locations for config file: {:?}", &locations);
+
+    for location in &locations {
+        let file = OpenOptions::new().read(true).open(location);
+        match file {
+            Ok(file) => {
+                debug!("Found file at {location:?}.");
+                return Ok(FileData {
+                    path: location.clone(),
+                    file,
+                });
+            }
+            Err(e) => {
+                debug!("Tried to read '{location:?}' but failed due to error: {e}");
+            }
+        }
     }
 
-    // Home folder
+    debug!("Failed to find any config. Now trying to find first writable path");
-    if let Some(folder) = home_dir() {
+
-      folders.push(folder)
+    // If we got here, we failed to read any file paths, meaning no config exists
+    // yet. In that case, try to return the first location that we can write to,
+    // after writing the default config
+    for location in locations {
+        let file = OpenOptions::new()
+            .write(true)
+            .create_new(true)
+            .open(location.clone());
+        match file {
+            Ok(mut file) => {
+                info!("Creating new config file at {location:?}.");
+                file.write_all(DEFAULT_CONFIG)?;
+
+                let file = OpenOptions::new().read(true).open(location.clone())?;
+                return Ok(FileData {
+                    path: location,
+                    file,
+                });
+            }
+            Err(e) => {
+                debug!("Tried to open a new file at '{location:?}' but failed due to error: {e}",)
+            }
+        }
     }
 
-    folders
+    Err(BunBunError::NoValidConfigPath)
-      .iter_mut()
-      .for_each(|folder| folder.push(CONFIG_FILENAME));
-
-    folders
-  };
-
-  debug!("Checking locations for config file: {:?}", &locations);
-
-  for location in &locations {
-    let file = OpenOptions::new().read(true).open(location.clone());
-    match file {
-      Ok(file) => {
-        debug!("Found file at {:?}.", location);
-        return Ok(ConfigData {
-          path: location.clone(),
-          file,
-        });
-      }
-      Err(e) => debug!(
-        "Tried to read '{:?}' but failed due to error: {}",
-        location, e
-      ),
-    }
-  }
-
-  debug!("Failed to find any config. Now trying to find first writable path");
-
-  // If we got here, we failed to read any file paths, meaning no config exists
-  // yet. In that case, try to return the first location that we can write to,
-  // after writing the default config
-  for location in locations {
-    let file = OpenOptions::new()
-      .write(true)
-      .create_new(true)
-      .open(location.clone());
-    match file {
-      Ok(mut file) => {
-        info!("Creating new config file at {:?}.", location);
-        file.write_all(DEFAULT_CONFIG)?;
-
-        let file = OpenOptions::new().read(true).open(location.clone())?;
-        return Ok(ConfigData {
-          path: location,
-          file,
-        });
-      }
-      Err(e) => debug!(
-        "Tried to open a new file at '{:?}' but failed due to error: {}",
-        location, e
-      ),
-    }
-  }
-
-  Err(BunBunError::NoValidConfigPath)
 }
 
 /// Assumes that the user knows what they're talking about and will only try
 /// to load the config at the given path.
-pub fn load_custom_path_config(
+pub fn load_custom_file(path: impl Into<PathBuf>) -> Result<FileData, BunBunError> {
-  path: impl Into<PathBuf>,
+    let path = path.into();
-) -> Result<ConfigData, BunBunError> {
+    let file = OpenOptions::new()
-  let path = path.into();
+        .read(true)
-  let file = OpenOptions::new()
+        .open(&path)
-    .read(true)
+        .map_err(|e| BunBunError::InvalidConfigPath(path.clone(), e))?;
-    .open(&path)
-    .map_err(|e| BunBunError::InvalidConfigPath(path.clone(), e))?;
 
-  Ok(ConfigData { file, path })
+    Ok(FileData { path, file })
 }
 
-pub fn read_config(
+pub fn load_file(mut config_file: File, large_config: bool) -> Result<Config, BunBunError> {
-  mut config_file: File,
+    trace!("Loading config file.");
-  large_config: bool,
+    let file_size = config_file.metadata()?.len();
-) -> Result<Config, BunBunError> {
-  trace!("Loading config file.");
-  let file_size = config_file.metadata()?.len();
 
-  // 100 MB
+    // 100 MB
-  if file_size > LARGE_FILE_SIZE_THRESHOLD && !large_config {
+    if file_size > LARGE_FILE_SIZE_THRESHOLD && !large_config {
-    return Err(BunBunError::ConfigTooLarge(file_size));
+        return Err(BunBunError::ConfigTooLarge(file_size));
-  }
+    }
 
-  if file_size == 0 {
+    if file_size == 0 {
-    return Err(BunBunError::ZeroByteConfig);
+        return Err(BunBunError::ZeroByteConfig);
-  }
+    }
 
-  let mut config_data = String::new();
+    let mut config_data = String::new();
-  config_file.read_to_string(&mut config_data)?;
+    config_file.read_to_string(&mut config_data)?;
-  // Reading from memory is faster than reading directly from a reader for some
+    // Reading from memory is faster than reading directly from a reader for some
-  // reason; see https://github.com/serde-rs/json/issues/160
+    // reason; see https://github.com/serde-rs/json/issues/160
-  Ok(serde_yaml::from_str(&config_data)?)
+    Ok(serde_yaml::from_str(&config_data)?)
 }
 
 #[cfg(test)]
 mod route {
-  use super::*;
+    use super::*;
-  use serde_yaml::{from_str, to_string};
+    use anyhow::{Context, Result};
-  use tempfile::NamedTempFile;
+    use serde_yaml::{from_str, to_string};
+    use std::path::Path;
+    use tempfile::NamedTempFile;
 
-  #[test]
+    #[test]
-  fn deserialize_relative_path() {
+    fn deserialize_relative_path() -> Result<()> {
-    let tmpfile = NamedTempFile::new_in(".").unwrap();
+        let tmpfile = NamedTempFile::new_in(".")?;
-    let path = format!("{}", tmpfile.path().display());
+        let path = tmpfile.path().display().to_string();
-    let path = path.get(path.rfind(".").unwrap()..).unwrap();
+        let path = path
-    let path = std::path::Path::new(path);
+            .get(path.rfind(".").context("While finding .")?..)
-    assert!(path.is_relative());
+            .context("While getting the path")?;
-    let path = path.to_str().unwrap();
+        let path = Path::new(path);
-    assert_eq!(
+        assert!(path.is_relative());
-      from_str::<Route>(path).unwrap(),
+        let path = path.to_str().context("While stringifying path")?;
-      Route::from_str(path).unwrap()
+        assert_eq!(from_str::<Route>(path)?, Route::from(path.to_owned()));
-    );
+        Ok(())
-  }
+    }
 
-  #[test]
+    #[test]
-  fn deserialize_absolute_path() {
+    fn deserialize_absolute_path() -> Result<()> {
-    let tmpfile = NamedTempFile::new().unwrap();
+        let tmpfile = NamedTempFile::new()?;
-    let path = format!("{}", tmpfile.path().display());
+        let path = format!("{}", tmpfile.path().display());
-    assert!(tmpfile.path().is_absolute());
+        assert!(tmpfile.path().is_absolute());
-    assert_eq!(
+        assert_eq!(from_str::<Route>(&path)?, Route::from(path));
-      from_str::<Route>(&path).unwrap(),
-      Route::from_str(&path).unwrap()
-    );
-  }
 
-  #[test]
+        Ok(())
-  fn deserialize_http_path() {
+    }
-    assert_eq!(
-      from_str::<Route>("http://google.com").unwrap(),
-      Route::from_str("http://google.com").unwrap()
-    );
-  }
 
-  #[test]
+    #[test]
-  fn deserialize_https_path() {
+    fn deserialize_http_path() -> Result<()> {
-    assert_eq!(
+        assert_eq!(
-      from_str::<Route>("https://google.com").unwrap(),
+            from_str::<Route>("http://google.com")?,
-      Route::from_str("https://google.com").unwrap()
+            Route::from("http://google.com")
-    );
+        );
-  }
+        Ok(())
+    }
 
-  #[test]
+    #[test]
-  fn serialize() {
+    fn deserialize_https_path() -> Result<()> {
-    assert_eq!(
+        assert_eq!(
-      &to_string(&Route::from_str("hello world").unwrap()).unwrap(),
+            from_str::<Route>("https://google.com")?,
-      "---\nroute_type: External\npath: hello world\nhidden: false\ndescription: ~\nmin_args: ~\nmax_args: ~\n"
+            Route::from("https://google.com")
-    );
+        );
-  }
+        Ok(())
+    }
+
+    #[test]
+    fn serialize() -> Result<()> {
+        assert_eq!(
+            &to_string(&Route::from("hello world"))?,
+            "---\nroute_type: External\npath: hello world\nhidden: false\ndescription: ~\nmin_args: ~\nmax_args: ~\n"
+        );
+        Ok(())
+    }
 }
 
 #[cfg(test)]
 mod read_config {
-  use super::*;
+    use super::*;
+    use anyhow::Result;
 
-  #[test]
+    #[test]
-  fn empty_file() {
+    fn empty_file() -> Result<()> {
-    let config_file = tempfile::tempfile().unwrap();
+        let config_file = tempfile::tempfile()?;
-    assert!(matches!(
+        assert!(matches!(
-      read_config(config_file, false),
+            load_file(config_file, false),
-      Err(BunBunError::ZeroByteConfig)
+            Err(BunBunError::ZeroByteConfig)
-    ));
+        ));
-  }
+        Ok(())
-
-  #[test]
-  fn config_too_large() {
-    let mut config_file = tempfile::tempfile().unwrap();
-    let size_to_write = (LARGE_FILE_SIZE_THRESHOLD + 1) as usize;
-    config_file.write(&[0].repeat(size_to_write)).unwrap();
-    match read_config(config_file, false) {
-      Err(BunBunError::ConfigTooLarge(size))
-        if size as usize == size_to_write => {}
-      Err(BunBunError::ConfigTooLarge(size)) => {
-        panic!("Mismatched size: {} != {}", size, size_to_write)
-      }
-      res => panic!("Wrong result, got {:#?}", res),
     }
-  }
 
-  #[test]
+    #[test]
-  fn valid_config() {
+    fn config_too_large() -> Result<()> {
-    let config_file = File::open("bunbun.default.yaml").unwrap();
+        let mut config_file = tempfile::tempfile()?;
-    assert!(read_config(config_file, false).is_ok());
+        let size_to_write = (LARGE_FILE_SIZE_THRESHOLD + 1) as usize;
-  }
+        config_file.write(&[0].repeat(size_to_write))?;
+        match load_file(config_file, false) {
+            Err(BunBunError::ConfigTooLarge(size)) if size as usize == size_to_write => {}
+            Err(BunBunError::ConfigTooLarge(size)) => {
+                panic!("Mismatched size: {size} != {size_to_write}")
+            }
+            res => panic!("Wrong result, got {res:#?}"),
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn valid_config() -> Result<()> {
+        assert!(load_file(File::open("bunbun.default.yaml")?, false).is_ok());
+        Ok(())
+    }
 }

src/error.rs

@@ -2,54 +2,52 @@ use std::error::Error;
 use std::fmt;
 
 #[derive(Debug)]
+#[allow(clippy::module_name_repetitions)]
 pub enum BunBunError {
-  Io(std::io::Error),
+    Io(std::io::Error),
-  Parse(serde_yaml::Error),
+    Parse(serde_yaml::Error),
-  Watch(hotwatch::Error),
+    Watch(hotwatch::Error),
-  LoggerInit(log::SetLoggerError),
+    CustomProgram(String),
-  CustomProgram(String),
+    NoValidConfigPath,
-  NoValidConfigPath,
+    InvalidConfigPath(std::path::PathBuf, std::io::Error),
-  InvalidConfigPath(std::path::PathBuf, std::io::Error),
+    ConfigTooLarge(u64),
-  ConfigTooLarge(u64),
+    ZeroByteConfig,
-  ZeroByteConfig,
+    JsonParse(serde_json::Error),
-  JsonParse(serde_json::Error),
 }
 
 impl Error for BunBunError {}
 
 impl fmt::Display for BunBunError {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    match self {
+        match self {
-      Self::Io(e) => e.fmt(f),
+            Self::Io(e) => e.fmt(f),
-      Self::Parse(e) => e.fmt(f),
+            Self::Parse(e) => e.fmt(f),
-      Self::Watch(e) => e.fmt(f),
+            Self::Watch(e) => e.fmt(f),
-      Self::LoggerInit(e) => e.fmt(f),
+            Self::CustomProgram(msg) => msg.fmt(f),
-      Self::CustomProgram(msg) => write!(f, "{}", msg),
+            Self::NoValidConfigPath => write!(f, "No valid config path was found!"),
-      Self::NoValidConfigPath => write!(f, "No valid config path was found!"),
+            Self::InvalidConfigPath(path, reason) => {
-      Self::InvalidConfigPath(path, reason) => {
+                write!(f, "Failed to access {path:?}: {reason}")
-        write!(f, "Failed to access {:?}: {}", path, reason)
+            }
-      }
+            Self::ConfigTooLarge(size) => write!(f, "The config file was too large ({size} bytes)! Pass in --large-config to bypass this check."),
-      Self::ConfigTooLarge(size) => write!(f, "The config file was too large ({} bytes)! Pass in --large-config to bypass this check.", size),
+            Self::ZeroByteConfig => write!(f, "The config provided reported a size of 0 bytes. Please check your config path!"),
-      Self::ZeroByteConfig => write!(f, "The config provided reported a size of 0 bytes. Please check your config path!"),
+            Self::JsonParse(e) => e.fmt(f),
-      Self::JsonParse(e) => e.fmt(f),
+        }
     }
-  }
 }
 
 /// Generates a from implementation from the specified type to the provided
 /// bunbun error.
 macro_rules! from_error {
-  ($from:ty, $to:ident) => {
+    ($from:ty, $to:ident) => {
-    impl From<$from> for BunBunError {
+        impl From<$from> for BunBunError {
-      fn from(e: $from) -> Self {
+            fn from(e: $from) -> Self {
-        Self::$to(e)
+                Self::$to(e)
-      }
+            }
-    }
+        }
-  };
+    };
 }
 
 from_error!(std::io::Error, Io);
 from_error!(serde_yaml::Error, Parse);
 from_error!(hotwatch::Error, Watch);
-from_error!(log::SetLoggerError, LoggerInit);
 from_error!(serde_json::Error, JsonParse);

src/main.rs

@@ -1,25 +1,26 @@
 #![forbid(unsafe_code)]
 #![deny(missing_docs)]
+#![warn(clippy::nursery, clippy::pedantic)]
 
 //! Bunbun is a pure-Rust implementation of bunny1 that provides a customizable
 //! search engine and quick-jump tool in one small binary. For information on
 //! usage, please take a look at the readme.
 
-use crate::config::{
+use crate::config::{get_config_data, load_custom_file, load_file, FileData, Route, RouteGroup};
-  get_config_data, load_custom_path_config, read_config, ConfigData, Route,
+use anyhow::Result;
-  RouteGroup,
+use arc_swap::ArcSwap;
-};
+use axum::routing::get;
-use actix_web::{middleware::Logger, App, HttpServer};
+use axum::{Extension, Router};
-use clap::Clap;
+use clap::Parser;
 use error::BunBunError;
-use handlebars::{Handlebars, TemplateError};
+use handlebars::Handlebars;
 use hotwatch::{Event, Hotwatch};
-use log::{debug, error, info, trace, warn};
-use simple_logger::SimpleLogger;
-use std::cmp::min;
 use std::collections::HashMap;
-use std::sync::{Arc, RwLock};
+use std::sync::Arc;
 use std::time::Duration;
+use tracing::{debug, info, trace, warn};
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::util::SubscriberInitExt;
 
 mod cli;
 mod config;
@@ -32,123 +33,93 @@ mod template_args;
 /// Dynamic variables that either need to be present at runtime, or can be
 /// changed during runtime.
 pub struct State {
-  public_address: String,
+    public_address: String,
-  default_route: Option<String>,
+    default_route: Option<String>,
-  groups: Vec<RouteGroup>,
+    groups: Vec<RouteGroup>,
-  /// Cached, flattened mapping of all routes and their destinations.
+    /// Cached, flattened mapping of all routes and their destinations.
-  routes: HashMap<String, Route>,
+    routes: HashMap<String, Route>,
 }
 
-#[actix_web::main]
+#[tokio::main]
 #[cfg(not(tarpaulin_include))]
-async fn main() {
+async fn main() -> Result<()> {
-  std::process::exit(match run().await {
+    use tracing_subscriber::EnvFilter;
-    Ok(_) => 0,
+
-    Err(e) => {
+    let opts = cli::Opts::parse();
-      error!("{}", e);
+
-      1
+    let mut env_filter = EnvFilter::from_default_env();
+    for directive in opts.log {
+        env_filter = env_filter.add_directive(directive);
     }
-  })
-}
 
-#[cfg(not(tarpaulin_include))]
+    tracing_subscriber::registry()
-async fn run() -> Result<(), BunBunError> {
+        .with(tracing_subscriber::fmt::layer())
-  let opts = cli::Opts::parse();
+        .with(env_filter)
+        .init();
 
-  init_logger(opts.verbose, opts.quiet)?;
+    let conf_data = match opts.config {
+        Some(file_name) => load_custom_file(file_name),
+        None => get_config_data(),
+    }?;
 
-  let conf_data = match opts.config {
+    let conf = load_file(conf_data.file.try_clone()?, opts.large_config)?;
-    Some(file_name) => load_custom_path_config(file_name),
+    let state = Arc::from(ArcSwap::from_pointee(State {
-    None => get_config_data(),
+        public_address: conf.public_address,
-  }?;
+        default_route: conf.default_route,
+        routes: cache_routes(conf.groups.clone()),
+        groups: conf.groups,
+    }));
 
-  let conf = read_config(conf_data.file.try_clone()?, opts.large_config)?;
+    // Cannot be named _ or Rust will immediately drop it.
-  let state = Arc::from(RwLock::new(State {
+    let _watch = start_watch(Arc::clone(&state), conf_data, opts.large_config);
-    public_address: conf.public_address,
-    default_route: conf.default_route,
-    routes: cache_routes(&conf.groups),
-    groups: conf.groups,
-  }));
 
-  // Cannot be named _ or Rust will immediately drop it.
+    let app = Router::new()
-  let _watch = start_watch(Arc::clone(&state), conf_data, opts.large_config)?;
+        .route("/", get(routes::index))
+        .route("/bunbunsearch.xml", get(routes::opensearch))
+        .route("/ls", get(routes::list))
+        .route("/hop", get(routes::hop))
+        .layer(Extension(compile_templates()?))
+        .layer(Extension(state));
 
-  HttpServer::new(move || {
+    let bind_addr = conf.bind_address.parse()?;
-    let templates = match compile_templates() {
-      Ok(templates) => templates,
-      // This implies a template error, which should be a compile time error. If
-      // we reach here then the release is very broken.
-      Err(e) => unreachable!("Failed to compile templates: {}", e),
-    };
-    App::new()
-      .data(Arc::clone(&state))
-      .app_data(templates)
-      .wrap(Logger::default())
-      .service(routes::hop)
-      .service(routes::list)
-      .service(routes::index)
-      .service(routes::opensearch)
-  })
-  .bind(&conf.bind_address)?
-  .run()
-  .await?;
 
-  Ok(())
+    info!("Starting server at {bind_addr}");
-}
 
-/// Initializes the logger based on the number of quiet and verbose flags passed
+    axum::Server::bind(&bind_addr)
-/// in. Usually, these values are mutually exclusive, that is, if the number of
+        .serve(app.into_make_service())
-/// verbose flags is non-zero then the quiet flag is zero, and vice versa.
+        .await?;
-#[cfg(not(tarpaulin_include))]
-fn init_logger(
-  num_verbose_flags: u8,
-  num_quiet_flags: u8,
-) -> Result<(), BunBunError> {
-  let log_level =
-    match min(num_verbose_flags, 3) as i8 - min(num_quiet_flags, 2) as i8 {
-      -2 => None,
-      -1 => Some(log::LevelFilter::Error),
-      0 => Some(log::LevelFilter::Warn),
-      1 => Some(log::LevelFilter::Info),
-      2 => Some(log::LevelFilter::Debug),
-      3 => Some(log::LevelFilter::Trace),
-      _ => unreachable!(), // values are clamped to [0, 3] - [0, 2]
-    };
 
-  if let Some(level) = log_level {
+    Ok(())
-    SimpleLogger::new().with_level(level).init()?;
-  }
-
-  Ok(())
 }
 
 /// Generates a hashmap of routes from the data structure created by the config
 /// file. This should improve runtime performance and is a better solution than
 /// just iterating over the config object for every hop resolution.
-fn cache_routes(groups: &[RouteGroup]) -> HashMap<String, Route> {
+fn cache_routes(groups: Vec<RouteGroup>) -> HashMap<String, Route> {
-  let mut mapping = HashMap::new();
+    let mut mapping = HashMap::new();
-  for group in groups {
+    for group in groups {
-    for (kw, dest) in &group.routes {
+        for (kw, dest) in group.routes {
-      match mapping.insert(kw.clone(), dest.clone()) {
+            // This function isn't called often enough to not be a performance issue.
-        None => trace!("Inserting {} into mapping.", kw),
+            match mapping.insert(kw.clone(), dest.clone()) {
-        Some(old_value) => {
+                None => trace!("Inserting {kw} into mapping."),
-          trace!("Overriding {} route from {} to {}.", kw, old_value, dest)
+                Some(old_value) => {
+                    trace!("Overriding {kw} route from {old_value} to {dest}.");
+                }
+            }
         }
-      }
     }
-  }
+    mapping
-  mapping
 }
 
 /// Returns an instance with all pre-generated templates included into the
 /// binary. This allows for users to have a portable binary without needed the
 /// templates at runtime.
-fn compile_templates() -> Result<Handlebars<'static>, TemplateError> {
+fn compile_templates() -> Result<Handlebars<'static>> {
-  let mut handlebars = Handlebars::new();
+    let mut handlebars = Handlebars::new();
-  handlebars.set_strict_mode(true);
+    handlebars.set_strict_mode(true);
-  handlebars.register_partial("bunbun_version", env!("CARGO_PKG_VERSION"))?;
+    handlebars.register_partial("bunbun_version", env!("CARGO_PKG_VERSION"))?;
-  handlebars.register_partial("bunbun_src", env!("CARGO_PKG_REPOSITORY"))?;
+    handlebars.register_partial("bunbun_src", env!("CARGO_PKG_REPOSITORY"))?;
-  macro_rules! register_template {
+    macro_rules! register_template {
     [ $( $template:expr ),* ] => {
       $(
         handlebars
@@ -161,8 +132,8 @@ fn compile_templates() -> Result<Handlebars<'static>, TemplateError> {
       )*
     };
   }
-  register_template!["index", "list", "opensearch"];
+    register_template!["index", "list", "opensearch"];
-  Ok(handlebars)
+    Ok(handlebars)
 }
 
 /// Starts the watch on a file, if possible. This will only return an Error if
@@ -176,180 +147,137 @@ fn compile_templates() -> Result<Handlebars<'static>, TemplateError> {
 /// watches.
 #[cfg(not(tarpaulin_include))]
 fn start_watch(
-  state: Arc<RwLock<State>>,
+    state: Arc<ArcSwap<State>>,
-  config_data: ConfigData,
+    config_data: FileData,
-  large_config: bool,
+    large_config: bool,
-) -> Result<Hotwatch, BunBunError> {
+) -> Result<Hotwatch> {
-  let mut watch = Hotwatch::new_with_custom_delay(Duration::from_millis(500))?;
+    let mut watch = Hotwatch::new_with_custom_delay(Duration::from_millis(500))?;
-  let ConfigData { path, mut file } = config_data;
+    let FileData { path, mut file } = config_data;
-  let watch_result = watch.watch(&path, move |e: Event| {
+    let watch_result = watch.watch(&path, move |e: Event| {
-    if let Event::Create(ref path) = e {
+        if let Event::Create(ref path) = e {
-      file = load_custom_path_config(path)
+            file = load_custom_file(path).expect("file to exist at path").file;
-        .expect("file to exist at path")
+            trace!("Getting new file handler as file was recreated.");
-        .file;
+        }
-      trace!("Getting new file handler as file was recreated.");
+
-    }
+        match e {
-
+            Event::Write(_) | Event::Create(_) => {
-    match e {
+                trace!("Grabbing writer lock on state...");
-      Event::Write(_) | Event::Create(_) => {
+                trace!("Obtained writer lock on state!");
-        trace!("Grabbing writer lock on state...");
+                match load_file(
-        let mut state =
+                    file.try_clone().expect("Failed to clone file handle"),
-          state.write().expect("Failed to get write lock on state");
+                    large_config,
-        trace!("Obtained writer lock on state!");
+                ) {
-        match read_config(
+                    Ok(conf) => {
-          file.try_clone().expect("Failed to clone file handle"),
+                        state.store(Arc::new(State {
-          large_config,
+                            public_address: conf.public_address,
-        ) {
+                            default_route: conf.default_route,
-          Ok(conf) => {
+                            routes: cache_routes(conf.groups.clone()),
-            state.public_address = conf.public_address;
+                            groups: conf.groups,
-            state.default_route = conf.default_route;
+                        }));
-            state.routes = cache_routes(&conf.groups);
+                        info!("Successfully updated active state");
-            state.groups = conf.groups;
+                    }
-            info!("Successfully updated active state");
+                    Err(e) => warn!("Failed to update config file: {e}"),
-          }
+                }
-          Err(e) => warn!("Failed to update config file: {}", e),
+            }
+            _ => debug!("Saw event {e:#?} but ignored it"),
+        }
+    });
+
+    match watch_result {
+        Ok(_) => info!("Watcher is now watching {path:?}"),
+        Err(e) => {
+            warn!("Couldn't watch {path:?}: {e}. Changes to this file won't be seen!");
         }
-      }
-      _ => debug!("Saw event {:#?} but ignored it", e),
     }
-  });
 
-  match watch_result {
+    Ok(watch)
-    Ok(_) => info!("Watcher is now watching {:?}", &path),
-    Err(e) => warn!(
-      "Couldn't watch {:?}: {}. Changes to this file won't be seen!",
-      &path, e
-    ),
-  }
-
-  Ok(watch)
-}
-
-#[cfg(test)]
-mod init_logger {
-  use super::*;
-
-  #[test]
-  fn defaults_to_warn() -> Result<(), BunBunError> {
-    init_logger(0, 0)?;
-    assert_eq!(log::max_level(), log::Level::Warn);
-    Ok(())
-  }
-
-  // The following tests work but because the log crate is global, initializing
-  // the logger more than once (read: testing it more than once) leads to a
-  // panic. These ignored tests must be manually tested.
-
-  #[test]
-  #[ignore]
-  fn caps_to_2_when_log_level_is_lt_2() -> Result<(), BunBunError> {
-    init_logger(0, 3)?;
-    assert_eq!(log::max_level(), log::LevelFilter::Off);
-    Ok(())
-  }
-
-  #[test]
-  #[ignore]
-  fn caps_to_3_when_log_level_is_gt_3() -> Result<(), BunBunError> {
-    init_logger(4, 0)?;
-    assert_eq!(log::max_level(), log::Level::Trace);
-    Ok(())
-  }
 }
 
 #[cfg(test)]
 mod cache_routes {
-  use super::*;
+    use super::*;
-  use std::iter::FromIterator;
+    use std::iter::FromIterator;
-  use std::str::FromStr;
 
-  fn generate_external_routes(
+    fn generate_external_routes(routes: &[(&'static str, &'static str)]) -> HashMap<String, Route> {
-    routes: &[(&str, &str)],
+        HashMap::from_iter(
-  ) -> HashMap<String, Route> {
+            routes
-    HashMap::from_iter(
+                .into_iter()
-      routes
+                .map(|(key, value)| ((*key).to_owned(), Route::from(*value))),
-        .into_iter()
+        )
-        .map(|kv| (kv.0.into(), Route::from_str(kv.1).unwrap())),
+    }
-    )
-  }
 
-  #[test]
+    #[test]
-  fn empty_groups_yield_empty_routes() {
+    fn empty_groups_yield_empty_routes() {
-    assert_eq!(cache_routes(&[]), HashMap::new());
+        assert_eq!(cache_routes(Vec::new()), HashMap::new());
-  }
+    }
 
-  #[test]
+    #[test]
-  fn disjoint_groups_yield_summed_routes() {
+    fn disjoint_groups_yield_summed_routes() {
-    let group1 = RouteGroup {
+        let group1 = RouteGroup {
-      name: String::from("x"),
+            name: String::from("x"),
-      description: Some(String::from("y")),
+            description: Some(String::from("y")),
-      routes: generate_external_routes(&[("a", "b"), ("c", "d")]),
+            routes: generate_external_routes(&[("a", "b"), ("c", "d")]),
-      hidden: false,
+            hidden: false,
-    };
+        };
 
-    let group2 = RouteGroup {
+        let group2 = RouteGroup {
-      name: String::from("5"),
+            name: String::from("5"),
-      description: Some(String::from("6")),
+            description: Some(String::from("6")),
-      routes: generate_external_routes(&[("1", "2"), ("3", "4")]),
+            routes: generate_external_routes(&[("1", "2"), ("3", "4")]),
-      hidden: false,
+            hidden: false,
-    };
+        };
 
-    assert_eq!(
+        assert_eq!(
-      cache_routes(&[group1, group2]),
+            cache_routes(vec![group1, group2]),
-      generate_external_routes(&[
+            generate_external_routes(&[("a", "b"), ("c", "d"), ("1", "2"), ("3", "4")])
-        ("a", "b"),
+        );
-        ("c", "d"),
+    }
-        ("1", "2"),
-        ("3", "4")
-      ])
-    );
-  }
 
-  #[test]
+    #[test]
-  fn overlapping_groups_use_latter_routes() {
+    fn overlapping_groups_use_latter_routes() {
-    let group1 = RouteGroup {
+        let group1 = RouteGroup {
-      name: String::from("x"),
+            name: String::from("x"),
-      description: Some(String::from("y")),
+            description: Some(String::from("y")),
-      routes: generate_external_routes(&[("a", "b"), ("c", "d")]),
+            routes: generate_external_routes(&[("a", "b"), ("c", "d")]),
-      hidden: false,
+            hidden: false,
-    };
+        };
 
-    let group2 = RouteGroup {
+        let group2 = RouteGroup {
-      name: String::from("5"),
+            name: String::from("5"),
-      description: Some(String::from("6")),
+            description: Some(String::from("6")),
-      routes: generate_external_routes(&[("a", "1"), ("c", "2")]),
+            routes: generate_external_routes(&[("a", "1"), ("c", "2")]),
-      hidden: false,
+            hidden: false,
-    };
+        };
 
-    assert_eq!(
+        assert_eq!(
-      cache_routes(&[group1.clone(), group2]),
+            cache_routes(vec![group1.clone(), group2]),
-      generate_external_routes(&[("a", "1"), ("c", "2")])
+            generate_external_routes(&[("a", "1"), ("c", "2")])
-    );
+        );
 
-    let group3 = RouteGroup {
+        let group3 = RouteGroup {
-      name: String::from("5"),
+            name: String::from("5"),
-      description: Some(String::from("6")),
+            description: Some(String::from("6")),
-      routes: generate_external_routes(&[("a", "1"), ("b", "2")]),
+            routes: generate_external_routes(&[("a", "1"), ("b", "2")]),
-      hidden: false,
+            hidden: false,
-    };
+        };
 
-    assert_eq!(
+        assert_eq!(
-      cache_routes(&[group1, group3]),
+            cache_routes(vec![group1, group3]),
-      generate_external_routes(&[("a", "1"), ("b", "2"), ("c", "d")])
+            generate_external_routes(&[("a", "1"), ("b", "2"), ("c", "d")])
-    );
+        );
-  }
+    }
 }
 
 #[cfg(test)]
 mod compile_templates {
-  use super::compile_templates;
+    use super::compile_templates;
 
-  /// Successful compilation of the binary guarantees that the templates will be
+    /// Successful compilation of the binary guarantees that the templates will be
-  /// present to be registered to. Thus, we only really need to see that
+    /// present to be registered to. Thus, we only really need to see that
-  /// compilation of the templates don't panic, which is just making sure that
+    /// compilation of the templates don't panic, which is just making sure that
-  /// the function can be successfully called.
+    /// the function can be successfully called.
-  #[test]
+    #[test]
-  fn templates_compile() {
+    fn templates_compile() {
-    let _ = compile_templates();
+        let _ = compile_templates();
-  }
+    }
 }

src/routes.rs

@@ -1,140 +1,143 @@
 use crate::config::{Route as ConfigRoute, RouteType};
 use crate::{template_args, BunBunError, Route, State};
-use actix_web::web::{Data, Query};
+use arc_swap::ArcSwap;
-use actix_web::{get, http::header};
+use axum::body::{boxed, Bytes, Full};
-use actix_web::{HttpRequest, HttpResponse, Responder};
+use axum::extract::Query;
+use axum::http::{header, StatusCode};
+use axum::response::{Html, IntoResponse, Response};
+use axum::Extension;
 use handlebars::Handlebars;
-use log::{debug, error};
 use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};
 use serde::Deserialize;
 use std::collections::HashMap;
-use std::path::PathBuf;
+use std::path::Path;
 use std::process::Command;
-use std::sync::{Arc, RwLock};
+use std::sync::Arc;
+use tracing::{debug, error};
 
-/// https://url.spec.whatwg.org/#fragment-percent-encode-set
+// https://url.spec.whatwg.org/#fragment-percent-encode-set
 const FRAGMENT_ENCODE_SET: &AsciiSet = &CONTROLS
-  .add(b' ')
+    .add(b' ')
-  .add(b'"')
+    .add(b'"')
-  .add(b'<')
+    .add(b'<')
-  .add(b'>')
+    .add(b'>')
-  .add(b'`')
+    .add(b'`')
-  .add(b'+')
+    .add(b'+')
-  .add(b'&') // Interpreted as a GET query
+    .add(b'&') // Interpreted as a GET query
-  .add(b'#'); // Interpreted as a hyperlink section target
+    .add(b'#') // Interpreted as a hyperlink section target
+    .add(b'\'');
 
-type StateData = Data<Arc<RwLock<State>>>;
+#[allow(clippy::unused_async)]
-
+pub async fn index(
-#[get("/")]
+    Extension(data): Extension<Arc<ArcSwap<State>>>,
-pub async fn index(data: StateData, req: HttpRequest) -> impl Responder {
+    Extension(handlebars): Extension<Handlebars<'static>>,
-  let data = data.read().unwrap();
+) -> impl IntoResponse {
-  HttpResponse::Ok()
+    handlebars
-    .set_header(header::CONTENT_TYPE, "text/html; charset=utf-8")
-    .body(
-      req
-        .app_data::<Handlebars>()
-        .unwrap()
         .render(
-          "index",
+            "index",
-          &template_args::hostname(data.public_address.clone()),
+            &template_args::hostname(&data.load().public_address),
         )
-        .unwrap(),
+        .map(Html)
-    )
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
 }
 
-#[get("/bunbunsearch.xml")]
+#[allow(clippy::unused_async)]
-pub async fn opensearch(data: StateData, req: HttpRequest) -> impl Responder {
+pub async fn opensearch(
-  let data = data.read().unwrap();
+    Extension(data): Extension<Arc<ArcSwap<State>>>,
-  HttpResponse::Ok()
+    Extension(handlebars): Extension<Handlebars<'static>>,
-    .header(
+) -> impl IntoResponse {
-      header::CONTENT_TYPE,
+    handlebars
-      "application/opensearchdescription+xml",
-    )
-    .body(
-      req
-        .app_data::<Handlebars>()
-        .unwrap()
         .render(
-          "opensearch",
+            "opensearch",
-          &template_args::hostname(data.public_address.clone()),
+            &template_args::hostname(&data.load().public_address),
         )
-        .unwrap(),
+        .map(|body| {
-    )
+            (
+                StatusCode::OK,
+                [(
+                    header::CONTENT_TYPE,
+                    "application/opensearchdescription+xml",
+                )],
+                body,
+            )
+        })
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
 }
 
-#[get("/ls")]
+#[allow(clippy::unused_async)]
-pub async fn list(data: StateData, req: HttpRequest) -> impl Responder {
+pub async fn list(
-  let data = data.read().unwrap();
+    Extension(data): Extension<Arc<ArcSwap<State>>>,
-  HttpResponse::Ok()
+    Extension(handlebars): Extension<Handlebars<'static>>,
-    .set_header(header::CONTENT_TYPE, "text/html; charset=utf-8")
+) -> impl IntoResponse {
-    .body(
+    handlebars
-      req
+        .render("list", &data.load().groups)
-        .app_data::<Handlebars>()
+        .map(Html)
-        .unwrap()
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
-        .render("list", &data.groups)
-        .unwrap(),
-    )
 }
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Debug)]
 pub struct SearchQuery {
-  to: String,
+    to: String,
 }
 
-#[get("/hop")]
+#[allow(clippy::unused_async)]
 pub async fn hop(
-  data: StateData,
+    Extension(data): Extension<Arc<ArcSwap<State>>>,
-  req: HttpRequest,
+    Extension(handlebars): Extension<Handlebars<'static>>,
-  query: Query<SearchQuery>,
+    Query(query): Query<SearchQuery>,
-) -> impl Responder {
+) -> impl IntoResponse {
-  let data = data.read().unwrap();
+    let data = data.load();
 
-  match resolve_hop(&query.to, &data.routes, &data.default_route) {
+    match resolve_hop(&query.to, &data.routes, &data.default_route) {
-    RouteResolution::Resolved { route: path, args } => {
+        RouteResolution::Resolved { route: path, args } => {
-      let resolved_template = match path {
+            let resolved_template = match path {
-        ConfigRoute {
+                ConfigRoute {
-          route_type: RouteType::Internal,
+                    route_type: RouteType::Internal,
-          path,
+                    path,
-          ..
+                    ..
-        } => resolve_path(PathBuf::from(path), &args),
+                } => resolve_path(Path::new(path), &args),
-        ConfigRoute {
+                ConfigRoute {
-          route_type: RouteType::External,
+                    route_type: RouteType::External,
-          path,
+                    path,
-          ..
+                    ..
-        } => Ok(HopAction::Redirect(path.clone())),
+                } => Ok(HopAction::Redirect(path.clone())),
-      };
+            };
 
-      match resolved_template {
+            match resolved_template {
-        Ok(HopAction::Redirect(path)) => HttpResponse::Found()
+                Ok(HopAction::Redirect(path)) => {
-          .header(
+                    let rendered = handlebars
-            header::LOCATION,
+                        .render_template(
-            req
+                            &path,
-              .app_data::<Handlebars>()
+                            &template_args::query(utf8_percent_encode(&args, FRAGMENT_ENCODE_SET)),
-              .unwrap()
+                        )
-              .render_template(
+                        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
-                std::str::from_utf8(path.as_bytes()).unwrap(),
+                    Response::builder()
-                &template_args::query(
+                        .status(StatusCode::FOUND)
-                  utf8_percent_encode(&args, FRAGMENT_ENCODE_SET).to_string(),
+                        .header(header::LOCATION, &path)
-                ),
+                        .body(boxed(Full::from(rendered)))
-              )
+                }
-              .unwrap(),
+                Ok(HopAction::Body(body)) => Response::builder()
-          )
+                    .status(StatusCode::OK)
-          .finish(),
+                    .body(boxed(Full::new(Bytes::from(body)))),
-        Ok(HopAction::Body(body)) => HttpResponse::Ok().body(body),
+                Err(e) => {
-        Err(e) => {
+                    error!("Failed to redirect user for {path}: {e}");
-          error!("Failed to redirect user for {}: {}", path, e);
+                    Response::builder()
-          HttpResponse::InternalServerError().body("Something went wrong :(\n")
+                        .status(StatusCode::INTERNAL_SERVER_ERROR)
+                        .body(boxed(Full::from("Something went wrong :(\n")))
+                }
+            }
         }
-      }
+        RouteResolution::Unresolved => Response::builder()
+            .status(StatusCode::NOT_FOUND)
+            .body(boxed(Full::from("not found\n"))),
     }
-    RouteResolution::Unresolved => HttpResponse::NotFound().body("not found"),
+    .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
-  }
 }
 
 #[derive(Debug, PartialEq)]
 enum RouteResolution<'a> {
-  Resolved { route: &'a Route, args: String },
+    Resolved { route: &'a Route, args: String },
-  Unresolved,
+    Unresolved,
 }
 
 /// Attempts to resolve the provided string into its route and its arguments.
@@ -144,287 +147,272 @@ enum RouteResolution<'a> {
 /// The first element in the tuple describes the route, while the second element
 /// returns the remaining arguments. If none remain, an empty string is given.
 fn resolve_hop<'a>(
-  query: &str,
+    query: &str,
-  routes: &'a HashMap<String, Route>,
+    routes: &'a HashMap<String, Route>,
-  default_route: &Option<String>,
+    default_route: &Option<String>,
 ) -> RouteResolution<'a> {
-  let mut split_args = query.split_ascii_whitespace().peekable();
+    let mut split_args = query.split_ascii_whitespace().peekable();
-  let maybe_route = {
+    let maybe_route = {
-    match split_args.peek() {
+        match split_args.peek() {
-      Some(command) => routes.get(*command),
+            Some(command) => routes.get(*command),
-      None => {
+            None => {
-        debug!("Found empty query, returning no route.");
+                debug!("Found empty query, returning no route.");
-        return RouteResolution::Unresolved;
+                return RouteResolution::Unresolved;
-      }
+            }
+        }
+    };
+
+    let args = split_args.collect::<Vec<_>>();
+    let arg_count = args.len();
+
+    // Try resolving with a matched command
+    if let Some(route) = maybe_route {
+        let args = if args.is_empty() { &[] } else { &args[1..] }.join(" ");
+        let arg_count = arg_count - 1;
+        if check_route(route, arg_count) {
+            debug!("Resolved {route} with args {args}");
+            return RouteResolution::Resolved { route, args };
+        }
     }
-  };
 
-  let args = split_args.collect::<Vec<_>>();
+    // Try resolving with the default route, if it exists
-  let arg_count = args.len();
+    if let Some(route) = default_route {
-
+        if let Some(route) = routes.get(route) {
-  // Try resolving with a matched command
+            if check_route(route, arg_count) {
-  if let Some(route) = maybe_route {
+                let args = args.join(" ");
-    let args = if args.is_empty() { &[] } else { &args[1..] }.join(" ");
+                debug!("Using default route {route} with args {args}");
-    let arg_count = arg_count - 1;
+                return RouteResolution::Resolved { route, args };
-    if check_route(route, arg_count) {
+            }
-      debug!("Resolved {} with args {}", route, args);
+        }
-      return RouteResolution::Resolved { route, args };
     }
-  }
 
-  // Try resolving with the default route, if it exists
+    RouteResolution::Unresolved
-  if let Some(route) = default_route {
-    if let Some(route) = routes.get(route) {
-      if check_route(route, arg_count) {
-        let args = args.join(" ");
-        debug!("Using default route {} with args {}", route, args);
-        return RouteResolution::Resolved { route, args };
-      }
-    }
-  }
-
-  RouteResolution::Unresolved
 }
 
 /// Checks if the user provided string has the correct properties required by
 /// the route to be successfully matched.
-fn check_route(route: &Route, arg_count: usize) -> bool {
+const fn check_route(route: &Route, arg_count: usize) -> bool {
-  if let Some(min_args) = route.min_args {
+    if let Some(min_args) = route.min_args {
-    if arg_count < min_args {
+        if arg_count < min_args {
-      return false;
+            return false;
+        }
     }
-  }
 
-  if let Some(max_args) = route.max_args {
+    if let Some(max_args) = route.max_args {
-    if arg_count > max_args {
+        if arg_count > max_args {
-      return false;
+            return false;
+        }
     }
-  }
 
-  true
+    true
 }
 
 #[derive(Deserialize, Debug, PartialEq, Eq)]
 #[serde(rename_all = "snake_case")]
 enum HopAction {
-  Redirect(String),
+    Redirect(String),
-  Body(String),
+    Body(String),
 }
 
 /// Runs the executable with the user's input as a single argument. Returns Ok
 /// so long as the executable was successfully executed. Returns an Error if the
 /// file doesn't exist or bunbun did not have permission to read and execute the
 /// file.
-fn resolve_path(path: PathBuf, args: &str) -> Result<HopAction, BunBunError> {
+fn resolve_path(path: &Path, args: &str) -> Result<HopAction, BunBunError> {
-  let output = Command::new(path.canonicalize()?)
+    let output = Command::new(path.canonicalize()?)
-    .args(args.split(' '))
+        .args(args.split(' '))
-    .output()?;
+        .output()?;
 
-  if output.status.success() {
+    if output.status.success() {
-    Ok(serde_json::from_slice(&output.stdout[..])?)
+        Ok(serde_json::from_slice(&output.stdout[..])?)
-  } else {
+    } else {
-    error!(
+        error!(
-      "Program exit code for {} was not 0! Dumping standard error!",
+            "Program exit code for {} was not 0! Dumping standard error!",
-      path.display(),
+            path.display(),
-    );
+        );
-    let error = String::from_utf8_lossy(&output.stderr);
+        let error = String::from_utf8_lossy(&output.stderr);
-    Err(BunBunError::CustomProgram(error.to_string()))
+        Err(BunBunError::CustomProgram(error.to_string()))
-  }
+    }
 }
 
 #[cfg(test)]
 mod resolve_hop {
-  use super::*;
+    use super::*;
-  use std::str::FromStr;
+    use anyhow::Result;
 
-  fn generate_route_result<'a>(
+    fn generate_route_result<'a>(keyword: &'a Route, args: &str) -> RouteResolution<'a> {
-    keyword: &'a Route,
+        RouteResolution::Resolved {
-    args: &str,
+            route: keyword,
-  ) -> RouteResolution<'a> {
+            args: String::from(args),
-    RouteResolution::Resolved {
+        }
-      route: keyword,
-      args: String::from(args),
     }
-  }
 
-  #[test]
+    #[test]
-  fn empty_routes_no_default_yields_failed_hop() {
+    fn empty_routes_no_default_yields_failed_hop() {
-    assert_eq!(
+        assert_eq!(
-      resolve_hop("hello world", &HashMap::new(), &None),
+            resolve_hop("hello world", &HashMap::new(), &None),
-      RouteResolution::Unresolved
+            RouteResolution::Unresolved
-    );
+        );
-  }
+    }
 
-  #[test]
+    #[test]
-  fn empty_routes_some_default_yields_failed_hop() {
+    fn empty_routes_some_default_yields_failed_hop() {
-    assert_eq!(
+        assert_eq!(
-      resolve_hop(
+            resolve_hop(
-        "hello world",
+                "hello world",
-        &HashMap::new(),
+                &HashMap::new(),
-        &Some(String::from("google"))
+                &Some(String::from("google"))
-      ),
+            ),
-      RouteResolution::Unresolved
+            RouteResolution::Unresolved
-    );
+        );
-  }
+    }
 
-  #[test]
+    #[test]
-  fn only_default_routes_some_default_yields_default_hop() {
+    fn only_default_routes_some_default_yields_default_hop() -> Result<()> {
-    let mut map: HashMap<String, Route> = HashMap::new();
+        let mut map: HashMap<String, Route> = HashMap::new();
-    map.insert(
+        map.insert("google".into(), Route::from("https://example.com"));
-      "google".into(),
+        assert_eq!(
-      Route::from_str("https://example.com").unwrap(),
+            resolve_hop("hello world", &map, &Some(String::from("google"))),
-    );
+            generate_route_result(&Route::from("https://example.com"), "hello world"),
-    assert_eq!(
+        );
-      resolve_hop("hello world", &map, &Some(String::from("google"))),
+        Ok(())
-      generate_route_result(
+    }
-        &Route::from_str("https://example.com").unwrap(),
-        "hello world"
-      ),
-    );
-  }
 
-  #[test]
+    #[test]
-  fn non_default_routes_some_default_yields_non_default_hop() {
+    fn non_default_routes_some_default_yields_non_default_hop() -> Result<()> {
-    let mut map: HashMap<String, Route> = HashMap::new();
+        let mut map: HashMap<String, Route> = HashMap::new();
-    map.insert(
+        map.insert("google".into(), Route::from("https://example.com"));
-      "google".into(),
+        assert_eq!(
-      Route::from_str("https://example.com").unwrap(),
+            resolve_hop("google hello world", &map, &Some(String::from("a"))),
-    );
+            generate_route_result(&Route::from("https://example.com"), "hello world"),
-    assert_eq!(
+        );
-      resolve_hop("google hello world", &map, &Some(String::from("a"))),
+        Ok(())
-      generate_route_result(
+    }
-        &Route::from_str("https://example.com").unwrap(),
-        "hello world"
-      ),
-    );
-  }
 
-  #[test]
+    #[test]
-  fn non_default_routes_no_default_yields_non_default_hop() {
+    fn non_default_routes_no_default_yields_non_default_hop() -> Result<()> {
-    let mut map: HashMap<String, Route> = HashMap::new();
+        let mut map: HashMap<String, Route> = HashMap::new();
-    map.insert(
+        map.insert("google".into(), Route::from("https://example.com"));
-      "google".into(),
+        assert_eq!(
-      Route::from_str("https://example.com").unwrap(),
+            resolve_hop("google hello world", &map, &None),
-    );
+            generate_route_result(&Route::from("https://example.com"), "hello world"),
-    assert_eq!(
+        );
-      resolve_hop("google hello world", &map, &None),
+        Ok(())
-      generate_route_result(
+    }
-        &Route::from_str("https://example.com").unwrap(),
-        "hello world"
-      ),
-    );
-  }
 }
 
 #[cfg(test)]
 mod check_route {
-  use super::*;
+    use super::*;
 
-  fn create_route(
+    fn create_route(
-    min_args: impl Into<Option<usize>>,
+        min_args: impl Into<Option<usize>>,
-    max_args: impl Into<Option<usize>>,
+        max_args: impl Into<Option<usize>>,
-  ) -> Route {
+    ) -> Route {
-    Route {
+        Route {
-      description: None,
+            description: None,
-      hidden: false,
+            hidden: false,
-      max_args: max_args.into(),
+            max_args: max_args.into(),
-      min_args: min_args.into(),
+            min_args: min_args.into(),
-      path: String::new(),
+            path: String::new(),
-      route_type: RouteType::External,
+            route_type: RouteType::External,
+        }
     }
-  }
 
-  #[test]
+    #[test]
-  fn no_min_arg_no_max_arg_counts() {
+    fn no_min_arg_no_max_arg_counts() {
-    assert!(check_route(&create_route(None, None), 0));
+        assert!(check_route(&create_route(None, None), 0));
-    assert!(check_route(&create_route(None, None), usize::MAX));
+        assert!(check_route(&create_route(None, None), usize::MAX));
-  }
+    }
 
-  #[test]
+    #[test]
-  fn min_arg_no_max_arg_counts() {
+    fn min_arg_no_max_arg_counts() {
-    assert!(!check_route(&create_route(3, None), 0));
+        assert!(!check_route(&create_route(3, None), 0));
-    assert!(!check_route(&create_route(3, None), 2));
+        assert!(!check_route(&create_route(3, None), 2));
-    assert!(check_route(&create_route(3, None), 3));
+        assert!(check_route(&create_route(3, None), 3));
-    assert!(check_route(&create_route(3, None), 4));
+        assert!(check_route(&create_route(3, None), 4));
-    assert!(check_route(&create_route(3, None), usize::MAX));
+        assert!(check_route(&create_route(3, None), usize::MAX));
-  }
+    }
 
-  #[test]
+    #[test]
-  fn no_min_arg_max_arg_counts() {
+    fn no_min_arg_max_arg_counts() {
-    assert!(check_route(&create_route(None, 3), 0));
+        assert!(check_route(&create_route(None, 3), 0));
-    assert!(check_route(&create_route(None, 3), 2));
+        assert!(check_route(&create_route(None, 3), 2));
-    assert!(check_route(&create_route(None, 3), 3));
+        assert!(check_route(&create_route(None, 3), 3));
-    assert!(!check_route(&create_route(None, 3), 4));
+        assert!(!check_route(&create_route(None, 3), 4));
-    assert!(!check_route(&create_route(None, 3), usize::MAX));
+        assert!(!check_route(&create_route(None, 3), usize::MAX));
-  }
+    }
 
-  #[test]
+    #[test]
-  fn min_arg_max_arg_counts() {
+    fn min_arg_max_arg_counts() {
-    assert!(!check_route(&create_route(2, 3), 1));
+        assert!(!check_route(&create_route(2, 3), 1));
-    assert!(check_route(&create_route(2, 3), 2));
+        assert!(check_route(&create_route(2, 3), 2));
-    assert!(check_route(&create_route(2, 3), 3));
+        assert!(check_route(&create_route(2, 3), 3));
-    assert!(!check_route(&create_route(2, 3), 4));
+        assert!(!check_route(&create_route(2, 3), 4));
-  }
+    }
 }
 
 #[cfg(test)]
 mod resolve_path {
-  use super::{resolve_path, HopAction};
+    use crate::error::BunBunError;
-  use std::env::current_dir;
-  use std::path::PathBuf;
 
-  #[test]
+    use super::{resolve_path, HopAction};
-  fn invalid_path_returns_err() {
+    use anyhow::Result;
-    assert!(resolve_path(PathBuf::from("/bin/aaaa"), "aaaa").is_err());
+    use std::env::current_dir;
-  }
+    use std::io::ErrorKind;
+    use std::path::{Path, PathBuf};
 
-  #[test]
+    #[test]
-  fn valid_path_returns_ok() {
+    fn invalid_path_returns_err() {
-    assert!(
+        assert!(resolve_path(&Path::new("/bin/aaaa"), "aaaa").is_err());
-      resolve_path(PathBuf::from("/bin/echo"), r#"{"body": "a"}"#).is_ok()
+    }
-    );
-  }
 
-  #[test]
+    #[test]
-  fn relative_path_returns_ok() {
+    fn valid_path_returns_ok() {
-    // How many ".." needed to get to /
+        assert!(resolve_path(&Path::new("/bin/echo"), r#"{"body": "a"}"#).is_ok());
-    let nest_level = current_dir().unwrap().ancestors().count() - 1;
+    }
-    let mut rel_path = PathBuf::from("../".repeat(nest_level));
-    rel_path.push("./bin/echo");
-    assert!(resolve_path(rel_path, r#"{"body": "a"}"#).is_ok());
-  }
 
-  #[test]
+    #[test]
-  fn no_permissions_returns_err() {
+    fn relative_path_returns_ok() -> Result<()> {
-    assert!(
+        // How many ".." needed to get to /
-      // Trying to run a command without permission
+        let nest_level = current_dir()?.ancestors().count() - 1;
-      format!(
+        let mut rel_path = PathBuf::from("../".repeat(nest_level));
-        "{}",
+        rel_path.push("./bin/echo");
-        resolve_path(PathBuf::from("/root/some_exec"), "").unwrap_err()
+        assert!(resolve_path(&rel_path, r#"{"body": "a"}"#).is_ok());
-      )
+        Ok(())
-      .contains("Permission denied")
+    }
-    );
-  }
 
-  #[test]
+    #[test]
-  fn non_success_exit_code_yields_err() {
+    fn no_permissions_returns_err() {
-    // cat-ing a folder always returns exit code 1
+        let result = match resolve_path(&Path::new("/root/some_exec"), "") {
-    assert!(resolve_path(PathBuf::from("/bin/cat"), "/").is_err());
+            Err(BunBunError::Io(e)) => e.kind() == ErrorKind::PermissionDenied,
-  }
+            _ => false,
+        };
+        assert!(result);
+    }
 
-  #[test]
+    #[test]
-  fn return_body() {
+    fn non_success_exit_code_yields_err() {
-    assert_eq!(
+        // cat-ing a folder always returns exit code 1
-      resolve_path(PathBuf::from("/bin/echo"), r#"{"body": "a"}"#).unwrap(),
+        assert!(resolve_path(&Path::new("/bin/cat"), "/").is_err());
-      HopAction::Body("a".to_string())
+    }
-    );
-  }
 
-  #[test]
+    #[test]
-  fn return_redirect() {
+    fn return_body() -> Result<()> {
-    assert_eq!(
+        assert_eq!(
-      resolve_path(PathBuf::from("/bin/echo"), r#"{"redirect": "a"}"#).unwrap(),
+            resolve_path(&Path::new("/bin/echo"), r#"{"body": "a"}"#)?,
-      HopAction::Redirect("a".to_string())
+            HopAction::Body("a".to_string())
-    );
+        );
-  }
+
+        Ok(())
+    }
+
+    #[test]
+    fn return_redirect() -> Result<()> {
+        assert_eq!(
+            resolve_path(&Path::new("/bin/echo"), r#"{"redirect": "a"}"#)?,
+            HopAction::Redirect("a".to_string())
+        );
+        Ok(())
+    }
 }

src/template_args.rs

@@ -1,17 +1,22 @@
+use std::borrow::Cow;
+
+use percent_encoding::PercentEncode;
 use serde::Serialize;
 
-pub fn query(query: String) -> impl Serialize {
+pub fn query(query: PercentEncode<'_>) -> impl Serialize + '_ {
-  #[derive(Serialize)]
+    #[derive(Serialize)]
-  struct TemplateArgs {
+    struct TemplateArgs<'a> {
-    query: String,
+        query: Cow<'a, str>,
-  }
+    }
-  TemplateArgs { query }
+    TemplateArgs {
+        query: query.into(),
+    }
 }
 
-pub fn hostname(hostname: String) -> impl Serialize {
+pub fn hostname(hostname: &'_ str) -> impl Serialize + '_ {
-  #[derive(Serialize)]
+    #[derive(Serialize)]
-  pub struct TemplateArgs {
+    pub struct TemplateArgs<'a> {
-    pub hostname: String,
+        pub hostname: &'a str,
-  }
+    }
-  TemplateArgs { hostname }
+    TemplateArgs { hostname }
 }