v0.25.5

src/main/bootstrap.rs

@@ -8,6 +8,12 @@ use hyper_util::{
     client::legacy::{connect::HttpConnector, Client},
     rt::TokioExecutor,
 };
+use rust_proxy::{
+    auth,
+    config::{self, Config, Envelope, ValidationPolicy},
+    db::Store,
+    runtime::App,
+};
 use rustls::{
     client::{
         danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier},
@@ -16,12 +22,6 @@ use rustls::{
     pki_types::{CertificateDer, ServerName, UnixTime},
     ClientConfig, DigitallySignedStruct, RootCertStore, SignatureScheme,
 };
-use rust_proxy::{
-    auth,
-    config::{self, Config, Envelope, ValidationPolicy},
-    db::Store,
-    runtime::App,
-};
 use sha2::{Digest, Sha256};
 use std::io::{self, BufRead, IsTerminal, Read, Write};
 use std::{
@@ -34,14 +34,14 @@ use tokio::{
     net::{TcpListener, UdpSocket},
     task::JoinSet,
 };
-use zeroize::Zeroizing;
 use tracing_subscriber::prelude::*;
+use zeroize::Zeroizing;
 
 #[derive(Parser)]
 #[command(
     name = "rust-proxy",
     version,
-    about = "RustProxy - independent Rust reverse proxy and static Web Server 0.25.4"
+    about = "RustProxy - independent Rust reverse proxy and static Web Server 0.25.5"
 )]
 struct Cli {
     #[arg(
@@ -142,9 +142,7 @@ enum BackupCommand {
         output: Option<PathBuf>,
     },
     /// Restore an encrypted full backup atomically. Stop the RustProxy service first.
-    Restore {
-        archive: PathBuf,
-    },
+    Restore { archive: PathBuf },
 }
 
 #[derive(Subcommand)]
@@ -241,11 +239,21 @@ fn main() -> Result<()> {
 }
 
 fn installed_data_dir_candidates() -> &'static [&'static str] {
-    #[cfg(any(target_os = "freebsd", target_os = "openbsd", target_os = "netbsd", target_os = "dragonfly"))]
+    #[cfg(any(
+        target_os = "freebsd",
+        target_os = "openbsd",
+        target_os = "netbsd",
+        target_os = "dragonfly"
+    ))]
     {
         return &["/var/db/rustproxy", "/var/lib/rustproxy"];
     }
-    #[cfg(not(any(target_os = "freebsd", target_os = "openbsd", target_os = "netbsd", target_os = "dragonfly")))]
+    #[cfg(not(any(
+        target_os = "freebsd",
+        target_os = "openbsd",
+        target_os = "netbsd",
+        target_os = "dragonfly"
+    )))]
     {
         &["/var/lib/rustproxy", "/var/db/rustproxy"]
     }
@@ -302,11 +310,16 @@ async fn application() -> Result<()> {
     let cli = Cli::from_arg_matches(&matches)?;
     let data_dir_explicit = explicit(&matches, "data_dir");
     if cli.livelogs {
-        ensure!(cli.command.is_none(), "--livelogs cannot be combined with a subcommand");
+        ensure!(
+            cli.command.is_none(),
+            "--livelogs cannot be combined with a subcommand"
+        );
         let data_dir = resolve_installed_data_dir(cli.data_dir, data_dir_explicit);
         return live_logs_command(data_dir, cli.admin_listen).await;
     }
-    let command = cli.command.context("a subcommand is required (or use --livelogs)")?;
+    let command = cli
+        .command
+        .context("a subcommand is required (or use --livelogs)")?;
     match command {
         Command::Token => {
             admin_command(
@@ -316,7 +329,11 @@ async fn application() -> Result<()> {
             .await
         }
         Command::Admin { action } => {
-            admin_command(resolve_installed_data_dir(cli.data_dir, data_dir_explicit), action).await
+            admin_command(
+                resolve_installed_data_dir(cli.data_dir, data_dir_explicit),
+                action,
+            )
+            .await
         }
         Command::Tls { action } => {
             tls_command(
@@ -368,15 +385,19 @@ async fn backup_command(data_dir: PathBuf, action: BackupCommand) -> Result<()>
             });
             let mut generated = false;
             let password = if io::stdin().is_terminal() {
-                let value = Zeroizing::new(
-                    rpassword::prompt_password("Backup password (leave empty to generate): ")?
-                );
+                let value = Zeroizing::new(rpassword::prompt_password(
+                    "Backup password (leave empty to generate): ",
+                )?);
                 if value.is_empty() {
                     generated = true;
                     Zeroizing::new(rust_proxy::backup::generated_password())
                 } else {
-                    let confirmation = Zeroizing::new(rpassword::prompt_password("Confirm backup password: ")?);
-                    ensure!(value.as_str() == confirmation.as_str(), "backup passwords do not match");
+                    let confirmation =
+                        Zeroizing::new(rpassword::prompt_password("Confirm backup password: ")?);
+                    ensure!(
+                        value.as_str() == confirmation.as_str(),
+                        "backup passwords do not match"
+                    );
                     value
                 }
             } else {
@@ -386,10 +407,15 @@ async fn backup_command(data_dir: PathBuf, action: BackupCommand) -> Result<()>
             let summary = rust_proxy::backup::create(&data_dir, &output, password.as_str()).await?;
             println!(
                 "Encrypted backup created: {} ({} files, configuration revision {})",
-                summary.path.display(), summary.files, summary.configuration_revision
+                summary.path.display(),
+                summary.files,
+                summary.configuration_revision
             );
             if generated {
-                println!("Generated backup password (shown once): {}", password.as_str());
+                println!(
+                    "Generated backup password (shown once): {}",
+                    password.as_str()
+                );
                 println!("Store this password securely; restore is impossible without it.");
             }
             Ok(())
@@ -401,10 +427,13 @@ async fn backup_command(data_dir: PathBuf, action: BackupCommand) -> Result<()>
             );
             let password = Zeroizing::new(rpassword::prompt_password("Backup password: ")?);
             ensure!(!password.is_empty(), "backup password cannot be empty");
-            let summary = rust_proxy::backup::restore(&archive, &data_dir, password.as_str()).await?;
+            let summary =
+                rust_proxy::backup::restore(&archive, &data_dir, password.as_str()).await?;
             println!(
                 "Backup restored to {} ({} files, configuration revision {})",
-                data_dir.display(), summary.files, summary.configuration_revision
+                data_dir.display(),
+                summary.files,
+                summary.configuration_revision
             );
             Ok(())
         }