Use log crate for all errors and warnings

Cargo.toml

@@ -43,6 +43,7 @@ zeroize = "1"
 dialoguer = { version = "0.4", optional = true }
 dirs = { version = "2", optional = true }
 gumdrop = { version = "0.6", optional = true }
+log = { version = "0.4", optional = true }
 
 # rage and rage-keygen dependencies
 chrono = { version = "0.4", optional = true }
@@ -53,7 +54,6 @@ minreq = { version = "1.4", features = ["https"], optional = true }
 env_logger = { version = "0.7", optional = true }
 fuse_mt = { version = "0.5", optional = true }
 libc = { version = "0.2", optional = true }
-log = { version = "0.4", optional = true }
 tar = { version = "0.4", optional = true }
 time = { version = "0.1", optional = true }
 zip = { version = "0.5", optional = true }
@@ -63,9 +63,9 @@ man = "0.3"
 
 [features]
 default = ["cli"]
-cli-common = ["dialoguer", "dirs", "gumdrop"]
+cli-common = ["dialoguer", "dirs", "gumdrop", "log"]
 cli = ["cli-common", "chrono", "console", "env_logger", "minreq"]
-mount = ["cli-common", "env_logger", "fuse_mt", "libc", "log", "tar", "time", "zip"]
+mount = ["cli-common", "env_logger", "fuse_mt", "libc", "tar", "time", "zip"]
 
 [[bin]]
 name = "rage-mount"

src/bin/rage-keygen/main.rs

@@ -1,6 +1,6 @@
 use age::cli_common::file_io;
 use gumdrop::Options;
-use std::env;
+use log::error;
 use std::io::Write;
 
 #[derive(Debug, Options)]
@@ -13,16 +13,14 @@ struct AgeOptions {
 }
 
 fn main() {
-    if env::var("RUST_LOG").is_ok() {
+    env_logger::builder().format_timestamp(None).init();
-        env_logger::builder().format_timestamp(None).init();
-    }
 
     let opts = AgeOptions::parse_args_default_or_exit();
 
     let mut output = match file_io::OutputWriter::new(opts.output, false) {
         Ok(output) => output,
         Err(e) => {
-            eprintln!("Failed to open output: {}", e);
+            error!("Failed to open output: {}", e);
             return;
         }
     };
@@ -38,6 +36,6 @@ fn main() {
         writeln!(output, "# {}", sk.to_public().to_str())?;
         writeln!(output, "{}", sk.to_str())
     })() {
-        eprintln!("Failed to write to output: {}", e);
+        error!("Failed to write to output: {}", e);
     }
 }

src/bin/rage-mount/main.rs

@@ -50,26 +50,26 @@ where
 }
 
 fn main() {
-    env_logger::init();
+    env_logger::builder().format_timestamp(None).init();
 
     let opts = AgeMountOptions::parse_args_default_or_exit();
 
     if opts.filename.is_empty() {
-        error!("Error: Missing filename");
+        error!("Missing filename");
         return;
     }
     if opts.mountpoint.is_empty() {
-        error!("Error: Missing mountpoint");
+        error!("Missing mountpoint");
         return;
     }
     if opts.types.is_empty() {
-        error!("Error: Missing -t/--types");
+        error!("Missing -t/--types");
         return;
     }
 
     let decryptor = if opts.passphrase {
         if !opts.identity.is_empty() {
-            eprintln!("Error: -i/--identity can't be used with -p/--passphrase");
+            error!("-i/--identity can't be used with -p/--passphrase");
             return;
         }
 
@@ -79,8 +79,8 @@ fn main() {
         }
     } else {
         if opts.identity.is_empty() {
-            eprintln!("Error: missing identities.");
+            error!("Missing identities.");
-            eprintln!("Did you forget to specify -i/--identity?");
+            error!("Did you forget to specify -i/--identity?");
             return;
         }
 
@@ -89,19 +89,19 @@ fn main() {
                 // Check for unsupported keys and alert the user
                 for identity in &identities {
                     if let age::IdentityKey::Unsupported(k) = identity.key() {
-                        eprintln!(
+                        error!(
                             "Unsupported key: {}",
                             identity.filename().unwrap_or_default()
                         );
-                        eprintln!();
+                        error!("");
-                        eprintln!("{}", k);
+                        error!("{}", k);
                         return;
                     }
                 }
                 age::Decryptor::Keys(identities)
             }
             Err(e) => {
-                eprintln!("Error while reading identities: {}", e);
+                error!("Failed to read identities: {}", e);
                 return;
             }
         }
@@ -111,7 +111,7 @@ fn main() {
     let file = match File::open(opts.filename) {
         Ok(f) => f,
         Err(e) => {
-            eprintln!("Failed to open file: {}", e);
+            error!("Failed to open file: {}", e);
             return;
         }
     };
@@ -121,7 +121,7 @@ fn main() {
     {
         Ok(stream) => stream,
         Err(e) => {
-            eprintln!("Failed to decrypt file: {}", e);
+            error!("Failed to decrypt file: {}", e);
             return;
         }
     };

src/bin/rage/main.rs

@@ -1,7 +1,7 @@
 use age::cli_common::{file_io, get_config_dir, read_identities, read_passphrase};
 use gumdrop::Options;
+use log::{error, warn};
 use std::collections::HashMap;
-use std::env;
 use std::fs::{read_to_string, File};
 use std::io::{self, BufRead, BufReader, Write};
 
@@ -54,7 +54,7 @@ fn read_recipients_list<R: BufRead>(filename: &str, buf: R) -> io::Result<Vec<ag
                 Ok(key) => recipients.push(key),
                 Err(<age::RecipientKey as std::str::FromStr>::Err::Ignore) => (),
                 Err(e) => {
-                    eprintln!("{:?}", e);
+                    error!("{:?}", e);
                     return Err(io::Error::new(
                         io::ErrorKind::InvalidData,
                         format!("recipients file {} contains non-recipient data", filename),
@@ -97,7 +97,7 @@ fn read_recipients(
             recipients.push(pk);
         } else if arg.starts_with(ALIAS_PREFIX) {
             if seen_aliases.contains(&arg) {
-                eprintln!("Warning: duplicate {}", arg);
+                warn!("Duplicate {}", arg);
             } else {
                 // Replace the alias in the arguments list with its expansion
                 arguments.extend(aliases.remove(&arg[ALIAS_PREFIX.len()..]).ok_or_else(|| {
@@ -180,21 +180,19 @@ struct AgeOptions {
 
 fn encrypt(opts: AgeOptions) {
     if !opts.identity.is_empty() {
-        eprintln!("Error: -i/--identity can't be used in encryption mode.");
+        error!("-i/--identity can't be used in encryption mode.");
-        eprintln!("Did you forget to specify -d/--decrypt?");
+        error!("Did you forget to specify -d/--decrypt?");
         return;
     }
 
     let encryptor = if opts.passphrase {
         if !opts.recipient.is_empty() {
-            eprintln!("Error: -r/--recipient can't be used with -p/--passphrase");
+            error!("-r/--recipient can't be used with -p/--passphrase");
             return;
         }
 
         if opts.input.is_none() {
-            eprintln!(
+            error!("File to encrypt must be passed as an argument when using -p/--passphrase");
-                "Error: file to encrypt must be passed as an argument when using -p/--passphrase"
-            );
             return;
         }
 
@@ -204,15 +202,15 @@ fn encrypt(opts: AgeOptions) {
         }
     } else {
         if opts.recipient.is_empty() {
-            eprintln!("Error: missing recipients.");
+            error!("Missing recipients.");
-            eprintln!("Did you forget to specify -r/--recipient?");
+            error!("Did you forget to specify -r/--recipient?");
             return;
         }
 
         match read_recipients(opts.recipient, opts.aliases) {
             Ok(recipients) => age::Encryptor::Keys(recipients),
             Err(e) => {
-                eprintln!("Error while reading recipients: {}", e);
+                error!("Error while reading recipients: {}", e);
                 return;
             }
         }
@@ -221,7 +219,7 @@ fn encrypt(opts: AgeOptions) {
     let mut input = match file_io::InputReader::new(opts.input) {
         Ok(input) => input,
         Err(e) => {
-            eprintln!("Failed to open input: {}", e);
+            error!("Failed to open input: {}", e);
             return;
         }
     };
@@ -229,7 +227,7 @@ fn encrypt(opts: AgeOptions) {
     let output = match file_io::OutputWriter::new(opts.output, true) {
         Ok(output) => output,
         Err(e) => {
-            eprintln!("Failed to open output: {}", e);
+            error!("Failed to open output: {}", e);
             return;
         }
     };
@@ -237,43 +235,41 @@ fn encrypt(opts: AgeOptions) {
     match encryptor.wrap_output(output, opts.armor) {
         Ok(mut w) => {
             if let Err(e) = io::copy(&mut input, &mut w) {
-                eprintln!("Error while encrypting: {}", e);
+                error!("Error while encrypting: {}", e);
                 return;
             }
             if let Err(e) = w.flush() {
-                eprintln!("Error while encrypting: {}", e);
+                error!("Error while encrypting: {}", e);
                 return;
             }
         }
         Err(e) => {
-            eprintln!("Failed to encrypt: {}", e);
+            error!("Failed to encrypt: {}", e);
         }
     }
 }
 
 fn decrypt(opts: AgeOptions) {
     if opts.armor {
-        eprintln!("Error: -a/--armor can't be used with -d/--decrypt.");
+        error!("-a/--armor can't be used with -d/--decrypt.");
-        eprintln!("Note that armored files are detected automatically.");
+        error!("Note that armored files are detected automatically.");
         return;
     }
 
     if !opts.recipient.is_empty() {
-        eprintln!("Error: -r/--recipient can't be used with -d/--decrypt.");
+        error!("-r/--recipient can't be used with -d/--decrypt.");
-        eprintln!("Did you mean to use -i/--identity to specify a private key?");
+        error!("Did you mean to use -i/--identity to specify a private key?");
         return;
     }
 
     let decryptor = if opts.passphrase {
         if !opts.identity.is_empty() {
-            eprintln!("Error: -i/--identity can't be used with -p/--passphrase");
+            error!("-i/--identity can't be used with -p/--passphrase");
             return;
         }
 
         if opts.input.is_none() {
-            eprintln!(
+            error!("File to decrypt must be passed as an argument when using -p/--passphrase");
-                "Error: file to decrypt must be passed as an argument when using -p/--passphrase"
-            );
             return;
         }
 
@@ -283,8 +279,8 @@ fn decrypt(opts: AgeOptions) {
         }
     } else {
         if opts.identity.is_empty() {
-            eprintln!("Error: missing identities.");
+            error!("Missing identities.");
-            eprintln!("Did you forget to specify -i/--identity?");
+            error!("Did you forget to specify -i/--identity?");
             return;
         }
 
@@ -293,19 +289,19 @@ fn decrypt(opts: AgeOptions) {
                 // Check for unsupported keys and alert the user
                 for identity in &identities {
                     if let age::IdentityKey::Unsupported(k) = identity.key() {
-                        eprintln!(
+                        error!(
                             "Unsupported key: {}",
                             identity.filename().unwrap_or_default()
                         );
-                        eprintln!();
+                        error!("");
-                        eprintln!("{}", k);
+                        error!("{}", k);
                         return;
                     }
                 }
                 age::Decryptor::Keys(identities)
             }
             Err(e) => {
-                eprintln!("Error while reading identities: {}", e);
+                error!("Error while reading identities: {}", e);
                 return;
             }
         }
@@ -314,7 +310,7 @@ fn decrypt(opts: AgeOptions) {
     let input = match file_io::InputReader::new(opts.input) {
         Ok(input) => input,
         Err(e) => {
-            eprintln!("Failed to open input: {}", e);
+            error!("Failed to open input: {}", e);
             return;
         }
     };
@@ -322,7 +318,7 @@ fn decrypt(opts: AgeOptions) {
     let mut output = match file_io::OutputWriter::new(opts.output, false) {
         Ok(output) => output,
         Err(e) => {
-            eprintln!("Failed to open output: {}", e);
+            error!("Failed to open output: {}", e);
             return;
         }
     };
@@ -333,17 +329,15 @@ fn decrypt(opts: AgeOptions) {
     match maybe_decrypted {
         Ok(mut r) => {
             if let Err(e) = io::copy(&mut r, &mut output) {
-                eprintln!("Error while decrypting: {}", e);
+                error!("Error while decrypting: {}", e);
             }
         }
-        Err(e) => eprintln!("Failed to decrypt: {}", e),
+        Err(e) => error!("Failed to decrypt: {}", e),
     }
 }
 
 fn main() {
-    if env::var("RUST_LOG").is_ok() {
+    env_logger::builder().format_timestamp(None).init();
-        env_logger::builder().format_timestamp(None).init();
-    }
 
     let opts = AgeOptions::parse_args_default_or_exit();