Add fill command to overwrite SD card

Cargo.toml

@@ -56,6 +56,9 @@ version = "0.1"
 [dependencies.nitrokey]
 version = "0.7.1"
 
+[dependencies.progressing]
+version = "3.0.2"
+
 [dependencies.serde]
 version = "1.0"
 features = ["derive"]

src/commands.rs

@@ -22,6 +22,7 @@ use nitrokey::GetPasswordSafe;
 
 use crate::args;
 use crate::config;
+use crate::output;
 use crate::pinentry;
 use crate::Context;
 
@@ -474,22 +475,20 @@ pub fn fill(ctx: &mut Context<'_>) -> anyhow::Result<()> {
       device.fill_sd_card(&pin).context("Failed to fill SD card")
     })?;
 
-    let mut last_progress = 0;
-    loop {
+    let mut progress_bar = output::ProgressBar::new();
+    progress_bar.draw(ctx)?;
+    while !progress_bar.is_finished() {
       use nitrokey::OperationStatus;
 
+      thread::sleep(time::Duration::from_secs(1));
       let status = device
         .get_operation_status()
         .context("Failed to query operation status")?;
       match status {
-        OperationStatus::Ongoing(progress) => {
-          if last_progress != progress {
-            println!(ctx, "{}/100", progress)?;
-          }
-          last_progress = progress;
-        }
-        OperationStatus::Idle => break,
+        OperationStatus::Ongoing(progress) => progress_bar.update(progress)?,
+        OperationStatus::Idle => progress_bar.finish(),
       };
+      progress_bar.draw(ctx)?;
     }
 
     Ok(())

src/main.rs

@@ -56,6 +56,7 @@ mod arg_util;
 mod args;
 mod commands;
 mod config;
+mod output;
 mod pinentry;
 #[cfg(test)]
 mod tests;

src/output.rs

@@ -0,0 +1,82 @@
+// commands.rs
+
+// Copyright (C) 2020 The Nitrocli Developers
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+use crate::Context;
+
+/// A progress bar that can be printed to an interactive output.
+pub struct ProgressBar {
+  redraw: bool,
+  progress: u8,
+  toggle: bool,
+  finished: bool,
+}
+
+impl ProgressBar {
+  pub fn new() -> ProgressBar {
+    ProgressBar {
+      redraw: true,
+      progress: 0,
+      toggle: false,
+      finished: false,
+    }
+  }
+
+  pub fn is_finished(&self) -> bool {
+    self.finished
+  }
+
+  pub fn update(&mut self, progress: u8) -> anyhow::Result<()> {
+    anyhow::ensure!(!self.finished, "Tried to update finished progress bar");
+    anyhow::ensure!(
+      progress <= 100,
+      "Progress bar value out of range: {}",
+      progress
+    );
+    if progress != self.progress {
+      self.redraw = true;
+      self.progress = progress;
+    }
+    self.toggle = !self.toggle;
+    Ok(())
+  }
+
+  pub fn finish(&mut self) {
+    self.finished = true;
+    self.redraw = true;
+    self.progress = 100;
+  }
+
+  pub fn draw(&self, ctx: &mut Context<'_>) -> anyhow::Result<()> {
+    use crossterm::{cursor, terminal};
+
+    if !ctx.is_tty {
+      return Ok(());
+    }
+
+    let progress_char = if self.toggle && !self.finished {
+      "."
+    } else {
+      " "
+    };
+    if self.redraw {
+      use progressing::Baring;
+
+      let mut progress_bar = progressing::mapping::Bar::with_range(0, 100);
+      progress_bar.set(self.progress);
+
+      print!(ctx, "{}", terminal::Clear(terminal::ClearType::CurrentLine))?;
+      print!(ctx, "{}", cursor::MoveToColumn(0))?;
+      print!(ctx, " {} {}", progress_char, progress_bar)?;
+      if self.finished {
+        println!(ctx)?;
+      }
+    } else {
+      print!(ctx, "{}{}", cursor::MoveToColumn(1), progress_char)?;
+    }
+
+    ctx.stdout.flush()?;
+    Ok(())
+  }
+}

src/redefine.rs

@@ -14,6 +14,12 @@ macro_rules! println {
   };
 }
 
+macro_rules! print {
+  ($ctx:expr, $($arg:tt)*) => {
+    write!($ctx.stdout, $($arg)*)
+  };
+}
+
 macro_rules! eprintln {
   ($ctx:expr) => {
     writeln!($ctx.stderr, "")