Fix clippy warnings and cargo fmt formatting

- Fix dead_code warnings: allow unused Warn variant and warn() method
- Fix useless .into() conversion in logging JSON output
- Fix manual Range::contains in fetch status check
- Fix unit let-binding in command execution
- Fix lines().flatten() -> lines().map_while(Result::ok)
- Apply cargo fmt to all source files

Author: mikkeldamsgaard

src/cmd/exec.rs

@@ -4,7 +4,11 @@ pub fn run(log: &Logger, args: &[String], workdir: &str) -> Result<(), String> {
         return Err("command is required after \"--\"".into());
     }
     log.info("executing command", &[("command", &args[0])]);
-    let dir = if workdir.is_empty() { None } else { Some(workdir) };
+    let dir = if workdir.is_empty() {
+        None
+    } else {
+        Some(workdir)
+    };
     let exit_code = super::run_command_in_dir(log, args, dir)?;
     if exit_code != 0 {
         return Err(format!("command exited with code {}", exit_code));

src/cmd/fetch.rs

@@ -16,8 +16,12 @@ pub struct Config {
 }
 impl Config {
     pub fn validate(&self) -> Result<(), String> {
-        if self.url.is_empty() { return Err("--url is required".into()); }
-        if self.output.is_empty() { return Err("--output is required".into()); }
+        if self.url.is_empty() {
+            return Err("--url is required".into());
+        }
+        if self.output.is_empty() {
+            return Err("--output is required".into());
+        }
         if self.allow_cross_site_redirects && !self.follow_redirects {
             return Err("--allow-cross-site-redirects requires --follow-redirects".into());
         }
@@ -36,7 +40,14 @@ pub fn run(log: &Logger, cfg: &Config, retry_cfg: &retry::Config) -> Result<(),
         log.error("fetch failed", &[("url", &cfg.url), ("error", &e)]);
         return Err(format!("fetch {} failed: {}", cfg.url, e));
     }
-    log.info("fetch completed", &[("url", &cfg.url), ("output", &cfg.output), ("attempts", &format!("{}", result.attempt + 1))]);
+    log.info(
+        "fetch completed",
+        &[
+            ("url", &cfg.url),
+            ("output", &cfg.output),
+            ("attempts", &format!("{}", result.attempt + 1)),
+        ],
+    );
     Ok(())
 }
 fn do_fetch(cfg: &Config) -> Result<(), String> {
@@ -45,7 +56,8 @@ fn do_fetch(cfg: &Config) -> Result<(), String> {
         use std::sync::Arc;
         let crypto_provider = rustls::crypto::ring::default_provider();
         let tls_config = rustls::ClientConfig::builder_with_provider(Arc::new(crypto_provider))
-            .with_safe_default_protocol_versions().unwrap()
+            .with_safe_default_protocol_versions()
+            .unwrap()
             .dangerous()
             .with_custom_certificate_verifier(Arc::new(super::wait_for::NoVerifier))
             .with_no_client_auth();
@@ -65,17 +77,23 @@ fn do_fetch(cfg: &Config) -> Result<(), String> {
         let auth_val = std::env::var(&cfg.auth_env)
             .map_err(|_| format!("auth env var {:?} is empty or not set", cfg.auth_env))?;
         if auth_val.is_empty() {
-            return Err(format!("auth env var {:?} is empty or not set", cfg.auth_env));
+            return Err(format!(
+                "auth env var {:?} is empty or not set",
+                cfg.auth_env
+            ));
         }
         req = req.set("Authorization", &auth_val);
     }
-    let resp = req.call().map_err(|e| format!("HTTP request to {}: {}", cfg.url, e))?;
+    let resp = req
+        .call()
+        .map_err(|e| format!("HTTP request to {}: {}", cfg.url, e))?;
     let status = resp.status();
-    if status < 200 || status >= 300 {
+    if !(200..300).contains(&status) {
         return Err(format!("HTTP {} returned status {}", cfg.url, status));
     }
     let mut body = Vec::new();
-    resp.into_reader().read_to_end(&mut body)
+    resp.into_reader()
+        .read_to_end(&mut body)
         .map_err(|e| format!("reading response body: {}", e))?;
     if let Some(parent) = out_path.parent() {
         fs::create_dir_all(parent).map_err(|e| format!("creating output directory: {}", e))?;

src/cmd/migrate.rs

@@ -8,7 +8,10 @@ pub fn run(log: &Logger, args: &[String], workdir: &str, lock_file: &str) -> Res
     if !lock_file.is_empty() {
         let lock_path = safety::validate_file_path(workdir, lock_file)?;
         if lock_path.exists() {
-            log.info("lock file exists, skipping migration", &[("lock-file", lock_path.to_str().unwrap_or(""))]);
+            log.info(
+                "lock file exists, skipping migration",
+                &[("lock-file", lock_path.to_str().unwrap_or(""))],
+            );
             return Ok(());
         }
     }
@@ -20,8 +23,12 @@ pub fn run(log: &Logger, args: &[String], workdir: &str, lock_file: &str) -> Res
     if !lock_file.is_empty() {
         let lock_path = safety::validate_file_path(workdir, lock_file)?;
         fs::create_dir_all(workdir).map_err(|e| format!("creating workdir {}: {}", workdir, e))?;
-        fs::write(&lock_path, "migrated\n").map_err(|e| format!("writing lock file {:?}: {}", lock_path, e))?;
-        log.info("lock file created", &[("lock-file", lock_path.to_str().unwrap_or(""))]);
+        fs::write(&lock_path, "migrated\n")
+            .map_err(|e| format!("writing lock file {:?}: {}", lock_path, e))?;
+        log.info(
+            "lock file created",
+            &[("lock-file", lock_path.to_str().unwrap_or(""))],
+        );
     }
     log.info("migration completed successfully", &[]);
     Ok(())

src/cmd/mod.rs

@@ -1,12 +1,12 @@
-pub mod wait_for;
+pub mod exec;
+pub mod fetch;
 pub mod migrate;
-pub mod seed;
 pub mod render;
-pub mod fetch;
-pub mod exec;
+pub mod seed;
+pub mod wait_for;
+use crate::logging::Logger;
 use std::io::{BufRead, BufReader, Read};
 use std::process::Command;
-use crate::logging::Logger;
 pub fn run_command(log: &Logger, args: &[String]) -> Result<i32, String> {
     run_command_in_dir(log, args, None)
 }
@@ -19,28 +19,33 @@ pub fn run_command_in_dir(log: &Logger, args: &[String], dir: Option<&str>) -> R
     cmd.stdin(std::process::Stdio::null());
     cmd.stdout(std::process::Stdio::piped());
     cmd.stderr(std::process::Stdio::piped());
-    let mut child = cmd.spawn().map_err(|e| format!("starting command {:?}: {}", args[0], e))?;
+    let mut child = cmd
+        .spawn()
+        .map_err(|e| format!("starting command {:?}: {}", args[0], e))?;
     let stdout = child.stdout.take();
     let stderr = child.stderr.take();
-    let log_stdout = std::thread::scope(|s| {
+    std::thread::scope(|s| {
         let h1 = s.spawn(|| {
-            if let Some(r) = stdout { stream_lines(log, r, "stdout"); }
+            if let Some(r) = stdout {
+                stream_lines(log, r, "stdout");
+            }
         });
         let h2 = s.spawn(|| {
-            if let Some(r) = stderr { stream_lines(log, r, "stderr"); }
+            if let Some(r) = stderr {
+                stream_lines(log, r, "stderr");
+            }
         });
         h1.join().ok();
         h2.join().ok();
     });
-    let _ = log_stdout;
-    let status = child.wait().map_err(|e| format!("waiting for command: {}", e))?;
+    let status = child
+        .wait()
+        .map_err(|e| format!("waiting for command: {}", e))?;
     Ok(status.code().unwrap_or(-1))
 }
 fn stream_lines<R: Read>(log: &Logger, reader: R, stream: &str) {
     let buf = BufReader::new(reader);
-    for line in buf.lines() {
-        if let Ok(l) = line {
-            log.info(&l, &[("stream", stream)]);
-        }
+    for l in buf.lines().map_while(Result::ok) {
+        log.info(&l, &[("stream", stream)]);
     }
 }

src/cmd/render.rs

@@ -1,23 +1,40 @@
 use crate::logging::Logger;
-use crate::safety;
 use crate::render as render_lib;
+use crate::safety;
 use std::fs;
 
-pub fn run(log: &Logger, template: &str, output: &str, workdir: &str, mode: &str) -> Result<(), String> {
+pub fn run(
+    log: &Logger,
+    template: &str,
+    output: &str,
+    workdir: &str,
+    mode: &str,
+) -> Result<(), String> {
     if template.is_empty() {
         return Err("--template is required".into());
     }
     if output.is_empty() {
         return Err("--output is required".into());
     }
     if mode != "envsubst" && mode != "gotemplate" {
-        return Err(format!("--mode must be envsubst or gotemplate, got {:?}", mode));
+        return Err(format!(
+            "--mode must be envsubst or gotemplate, got {:?}",
+            mode
+        ));
     }
 
     let out_path = safety::validate_file_path(workdir, output)?;
-    let data = fs::read_to_string(template).map_err(|e| format!("reading template {}: {}", template, e))?;
+    let data = fs::read_to_string(template)
+        .map_err(|e| format!("reading template {}: {}", template, e))?;
 
-    log.info("rendering template", &[("template", template), ("output", out_path.to_str().unwrap_or("")), ("mode", mode)]);
+    log.info(
+        "rendering template",
+        &[
+            ("template", template),
+            ("output", out_path.to_str().unwrap_or("")),
+            ("mode", mode),
+        ],
+    );
 
     let result = match mode {
         "envsubst" => render_lib::envsubst(&data),
@@ -29,6 +46,9 @@ pub fn run(log: &Logger, template: &str, output: &str, workdir: &str, mode: &str
         fs::create_dir_all(parent).map_err(|e| format!("creating output directory: {}", e))?;
     }
     fs::write(&out_path, result).map_err(|e| format!("writing output {:?}: {}", out_path, e))?;
-    log.info("render completed", &[("output", out_path.to_str().unwrap_or(""))]);
+    log.info(
+        "render completed",
+        &[("output", out_path.to_str().unwrap_or(""))],
+    );
     Ok(())
 }

src/cmd/wait_for.rs

@@ -2,39 +2,63 @@ use crate::logging::Logger;
 use crate::retry;
 use std::net::TcpStream;
 use std::time::{Duration, Instant};
-pub fn run(log: &Logger, targets: &[String], cfg: &retry::Config, timeout: Duration,
-           http_status: u16, insecure_tls: bool) -> Result<(), String> {
+pub fn run(
+    log: &Logger,
+    targets: &[String],
+    cfg: &retry::Config,
+    timeout: Duration,
+    http_status: u16,
+    insecure_tls: bool,
+) -> Result<(), String> {
     if targets.is_empty() {
         return Err("at least one --target is required".into());
     }
     let deadline = Instant::now() + timeout;
     for target in targets {
         log.info("waiting for target", &[("target", target)]);
         let result = retry::do_retry(cfg, Some(deadline), |attempt| {
-            log.debug("attempt", &[("target", target), ("attempt", &format!("{}", attempt + 1))]);
+            log.debug(
+                "attempt",
+                &[("target", target), ("attempt", &format!("{}", attempt + 1))],
+            );
             check_target(target, http_status, insecure_tls, timeout)
         });
         if let Some(e) = result.err {
             log.error("target not reachable", &[("target", target), ("error", &e)]);
             return Err(format!("target {} not reachable: {}", target, e));
         }
-        log.info("target is reachable", &[("target", target), ("attempts", &format!("{}", result.attempt + 1))]);
+        log.info(
+            "target is reachable",
+            &[
+                ("target", target),
+                ("attempts", &format!("{}", result.attempt + 1)),
+            ],
+        );
     }
     log.info("all targets reachable", &[]);
     Ok(())
 }
-fn check_target(target: &str, expected_status: u16, insecure_tls: bool, timeout: Duration) -> Result<(), String> {
+fn check_target(
+    target: &str,
+    expected_status: u16,
+    insecure_tls: bool,
+    timeout: Duration,
+) -> Result<(), String> {
     if let Some(addr) = target.strip_prefix("tcp://") {
         check_tcp(addr, timeout)
     } else if target.starts_with("http://") || target.starts_with("https://") {
         check_http(target, expected_status, insecure_tls, timeout)
     } else {
-        Err(format!("unsupported target scheme in {:?}; use tcp://, http://, or https://", target))
+        Err(format!(
+            "unsupported target scheme in {:?}; use tcp://, http://, or https://",
+            target
+        ))
     }
 }
 fn check_tcp(addr: &str, timeout: Duration) -> Result<(), String> {
     let per_req = timeout.min(Duration::from_secs(5));
-    let addrs: Vec<std::net::SocketAddr> = addr.to_socket_addrs_safe()
+    let addrs: Vec<std::net::SocketAddr> = addr
+        .to_socket_addrs_safe()
         .map_err(|e| format!("resolving {}: {}", addr, e))?;
     if addrs.is_empty() {
         return Err(format!("could not resolve {}", addr));
@@ -43,13 +67,19 @@ fn check_tcp(addr: &str, timeout: Duration) -> Result<(), String> {
         .map_err(|e| format!("tcp dial {}: {}", addr, e))?;
     Ok(())
 }
-fn check_http(url: &str, expected_status: u16, insecure_tls: bool, timeout: Duration) -> Result<(), String> {
+fn check_http(
+    url: &str,
+    expected_status: u16,
+    insecure_tls: bool,
+    timeout: Duration,
+) -> Result<(), String> {
     let per_req = timeout.min(Duration::from_secs(5));
     let agent = if insecure_tls {
         use std::sync::Arc;
         let crypto_provider = rustls::crypto::ring::default_provider();
         let tls_config = rustls::ClientConfig::builder_with_provider(Arc::new(crypto_provider))
-            .with_safe_default_protocol_versions().unwrap()
+            .with_safe_default_protocol_versions()
+            .unwrap()
             .dangerous()
             .with_custom_certificate_verifier(Arc::new(NoVerifier))
             .with_no_client_auth();
@@ -60,11 +90,16 @@ fn check_http(url: &str, expected_status: u16, insecure_tls: bool, timeout: Dura
     } else {
         ureq::AgentBuilder::new().timeout(per_req).build()
     };
-    let resp = agent.get(url).call()
+    let resp = agent
+        .get(url)
+        .call()
         .map_err(|e| format!("http request to {}: {}", url, e))?;
     let status = resp.status();
     if status != expected_status {
-        return Err(format!("http {} returned status {}, expected {}", url, status, expected_status));
+        return Err(format!(
+            "http {} returned status {}, expected {}",
+            url, status, expected_status
+        ));
     }
     Ok(())
 }
@@ -81,25 +116,34 @@ impl ToSocketAddrs for str {
 pub struct NoVerifier;
 impl rustls::client::danger::ServerCertVerifier for NoVerifier {
     fn verify_server_cert(
-        &self, _: &rustls::pki_types::CertificateDer<'_>, _: &[rustls::pki_types::CertificateDer<'_>],
-        _: &rustls::pki_types::ServerName<'_>, _: &[u8], _: rustls::pki_types::UnixTime,
+        &self,
+        _: &rustls::pki_types::CertificateDer<'_>,
+        _: &[rustls::pki_types::CertificateDer<'_>],
+        _: &rustls::pki_types::ServerName<'_>,
+        _: &[u8],
+        _: rustls::pki_types::UnixTime,
     ) -> Result<rustls::client::danger::ServerCertVerified, rustls::Error> {
         Ok(rustls::client::danger::ServerCertVerified::assertion())
     }
     fn verify_tls12_signature(
-        &self, _: &[u8], _: &rustls::pki_types::CertificateDer<'_>,
+        &self,
+        _: &[u8],
+        _: &rustls::pki_types::CertificateDer<'_>,
         _: &rustls::DigitallySignedStruct,
     ) -> Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
         Ok(rustls::client::danger::HandshakeSignatureValid::assertion())
     }
     fn verify_tls13_signature(
-        &self, _: &[u8], _: &rustls::pki_types::CertificateDer<'_>,
+        &self,
+        _: &[u8],
+        _: &rustls::pki_types::CertificateDer<'_>,
         _: &rustls::DigitallySignedStruct,
     ) -> Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
         Ok(rustls::client::danger::HandshakeSignatureValid::assertion())
     }
     fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
         rustls::crypto::ring::default_provider()
-            .signature_verification_algorithms.supported_schemes()
+            .signature_verification_algorithms
+            .supported_schemes()
     }
 }