Merge branch 'initial-pbar' into 'main'

progress bar improvements

Closes #77 and #76

See merge request larswirzenius/obnam!97

4 files changed, 84 insertions, 31 deletions

diff --git a/client.yaml b/client.yaml
index a1a63e7..4386b90 100644
--- a/client.yaml
+++ b/client.yaml
@@ -1,5 +1,5 @@
 server_url: https://localhost:8888
 verify_tls_cert: false
 roots:
-  - x
+  - /home/liw/pers/debian-ansible
 log: obnam.log
diff --git a/src/backup_progress.rs b/src/backup_progress.rs
index 6c1d3e6..c6d16d9 100644
--- a/src/backup_progress.rs
+++ b/src/backup_progress.rs
@@ -6,13 +6,33 @@ pub struct BackupProgress {
 }
 
 impl BackupProgress {
-    pub fn new() -> Self {
+    pub fn initial() -> Self {
         let progress = if true {
             ProgressBar::new(0)
         } else {
             ProgressBar::hidden()
         };
         let parts = vec![
+            "initial backup",
+            "elapsed: {elapsed}",
+            "files: {pos}",
+            "current: {wide_msg}",
+            "{spinner}",
+        ];
+        progress.set_style(ProgressStyle::default_bar().template(&parts.join("\n")));
+        progress.enable_steady_tick(100);
+
+        Self { progress }
+    }
+
+    pub fn incremental() -> Self {
+        let progress = if true {
+            ProgressBar::new(0)
+        } else {
+            ProgressBar::hidden()
+        };
+        let parts = vec![
+            "incremental backup",
             "{wide_bar}",
             "elapsed: {elapsed}",
             "files: {pos}/{len}",
@@ -35,6 +55,9 @@ impl BackupProgress {
 
     pub fn found_live_file(&self, filename: &Path) {
         self.progress.inc(1);
+        if self.progress.length() < self.progress.position() {
+            self.progress.set_length(self.progress.position());
+        }
         self.progress
             .set_message(&format!("{}", filename.display()));
     }
diff --git a/src/backup_run.rs b/src/backup_run.rs
index 7bb4440..024f486 100644
--- a/src/backup_run.rs
+++ b/src/backup_run.rs
@@ -9,8 +9,14 @@ use crate::policy::BackupPolicy;
 use log::{info, warn};
 use std::path::Path;
 
-pub struct BackupRun {
-    client: BackupClient,
+pub struct InitialBackup<'a> {
+    client: &'a BackupClient,
+    buffer_size: usize,
+    progress: BackupProgress,
+}
+
+pub struct IncrementalBackup<'a> {
+    client: &'a BackupClient,
     policy: BackupPolicy,
     buffer_size: usize,
     progress: BackupProgress,
@@ -30,28 +36,21 @@ pub enum BackupError {
 
 pub type BackupResult<T> = Result<T, BackupError>;
 
-impl BackupRun {
-    pub fn new(config: &ClientConfig) -> BackupResult<Self> {
-        let client = BackupClient::new(config)?;
-        let policy = BackupPolicy::new();
-        let progress = BackupProgress::new();
+impl<'a> InitialBackup<'a> {
+    pub fn new(config: &ClientConfig, client: &'a BackupClient) -> BackupResult<Self> {
+        let progress = BackupProgress::initial();
         Ok(Self {
             client,
-            policy,
             buffer_size: config.chunk_size,
             progress,
         })
     }
 
-    pub fn client(&self) -> &BackupClient {
-        &self.client
-    }
-
     pub fn progress(&self) -> &BackupProgress {
         &self.progress
     }
 
-    pub fn backup_file_initially(
+    pub fn backup(
         &self,
         entry: FsIterResult<FilesystemEntry>,
     ) -> BackupResult<(FilesystemEntry, Vec<ChunkId>, Reason)> {
@@ -65,8 +64,29 @@ impl BackupRun {
             }
         }
     }
+}
+
+impl<'a> IncrementalBackup<'a> {
+    pub fn new(config: &ClientConfig, client: &'a BackupClient) -> BackupResult<Self> {
+        let policy = BackupPolicy::new();
+        let progress = BackupProgress::incremental();
+        Ok(Self {
+            client,
+            policy,
+            buffer_size: config.chunk_size,
+            progress,
+        })
+    }
+
+    pub fn client(&self) -> &BackupClient {
+        self.client
+    }
+
+    pub fn progress(&self) -> &BackupProgress {
+        &self.progress
+    }
 
-    pub fn backup_file_incrementally(
+    pub fn backup(
         &self,
         entry: FsIterResult<FilesystemEntry>,
         old: &LocalGeneration,
diff --git a/src/cmd/backup.rs b/src/cmd/backup.rs
index cb2e9af..16d3f69 100644
--- a/src/cmd/backup.rs
+++ b/src/cmd/backup.rs
@@ -1,6 +1,6 @@
-use crate::backup_run::BackupRun;
+use crate::backup_run::{IncrementalBackup, InitialBackup};
 use crate::chunkid::ChunkId;
-use crate::client::ClientConfig;
+use crate::client::{BackupClient, ClientConfig};
 use crate::error::ObnamError;
 use crate::fsiter::FsIterator;
 use crate::generation::NascentGeneration;
@@ -14,8 +14,6 @@ const SQLITE_CHUNK_SIZE: usize = 1024 * 1024;
 pub fn backup(config: &ClientConfig) -> Result<(), ObnamError> {
     let runtime = SystemTime::now();
 
-    let run = BackupRun::new(config)?;
-
     // Create a named temporary file. We don't meed the open file
     // handle, so we discard that.
     let oldname = {
@@ -32,18 +30,26 @@ pub fn backup(config: &ClientConfig) -> Result<(), ObnamError> {
         dbname
     };
 
-    let genlist = run.client().list_generations()?;
+    let client = BackupClient::new(config)?;
+    let genlist = client.list_generations()?;
     let file_count = match genlist.resolve("latest") {
-        Err(_) => initial_backup(&config.roots, &newname, &run)?,
-        Ok(old) => incremental_backup(&old, &config.roots, &newname, &oldname, &run)?,
+        Err(_) => {
+            let run = InitialBackup::new(config, &client)?;
+            let count = initial_backup(&config.roots, &newname, &run)?;
+            run.progress().finish();
+            count
+        }
+        Ok(old) => {
+            let run = IncrementalBackup::new(config, &client)?;
+            let count = incremental_backup(&old, &config.roots, &newname, &oldname, &run)?;
+            run.progress().finish();
+            count
+        }
     };
-    run.progress().finish();
 
     // Upload the SQLite file, i.e., the named temporary file, which
     // still exists, since we persisted it above.
-    let gen_id = run
-        .client()
-        .upload_generation(&newname, SQLITE_CHUNK_SIZE)?;
+    let gen_id = client.upload_generation(&newname, SQLITE_CHUNK_SIZE)?;
 
     // Delete the temporary file.q
     std::fs::remove_file(&newname)?;
@@ -62,13 +68,17 @@ fn report_stats(runtime: &SystemTime, file_count: i64, gen_id: &ChunkId) -> Resu
     Ok(())
 }
 
-fn initial_backup(roots: &[PathBuf], newname: &Path, run: &BackupRun) -> Result<i64, ObnamError> {
+fn initial_backup(
+    roots: &[PathBuf],
+    newname: &Path,
+    run: &InitialBackup,
+) -> Result<i64, ObnamError> {
     info!("fresh backup without a previous generation");
 
     let mut new = NascentGeneration::create(&newname)?;
     for root in roots {
         let iter = FsIterator::new(root);
-        new.insert_iter(iter.map(|entry| run.backup_file_initially(entry)))?;
+        new.insert_iter(iter.map(|entry| run.backup(entry)))?;
     }
     Ok(new.file_count())
 }
@@ -78,7 +88,7 @@ fn incremental_backup(
     roots: &[PathBuf],
     newname: &Path,
     oldname: &Path,
-    run: &BackupRun,
+    run: &IncrementalBackup,
 ) -> Result<i64, ObnamError> {
     info!("incremental backup based on {}", old);
 
@@ -88,7 +98,7 @@ fn incremental_backup(
         let iter = FsIterator::new(root);
         run.progress()
             .files_in_previous_generation(old.file_count()? as u64);
-        new.insert_iter(iter.map(|entry| run.backup_file_incrementally(entry, &old)))?;
+        new.insert_iter(iter.map(|entry| run.backup(entry, &old)))?;
     }
     Ok(new.file_count())
 }