put ProgressBars into Repository struct

crates/rustic_core/examples/check.rs

@@ -1,5 +1,5 @@
 //! `check` example
-use rustic_core::{CheckOpts, NoProgressBars, Repository, RepositoryOptions};
+use rustic_core::{CheckOpts, Repository, RepositoryOptions};
 
 fn main() {
     let mut repo_opts = RepositoryOptions::default();
@@ -8,6 +8,5 @@ fn main() {
     let repo = Repository::new(&repo_opts).unwrap().open().unwrap();
 
     let opts = CheckOpts::default();
-    let progress = NoProgressBars {};
-    repo.check(opts, &progress).unwrap()
+    repo.check(opts).unwrap()
 }

crates/rustic_core/src/commands/cat.rs

@@ -8,31 +8,30 @@ use crate::{
     Tree,
 };
 
-pub fn cat_file(repo: &OpenRepository, tpe: FileType, id: &str) -> RusticResult<Bytes> {
+pub fn cat_file<P>(repo: &OpenRepository<P>, tpe: FileType, id: &str) -> RusticResult<Bytes> {
     let id = repo.dbe.find_id(tpe, id)?;
     let data = repo.dbe.read_encrypted_full(tpe, &id)?;
     Ok(data)
 }
 
-pub fn cat_blob(repo: &IndexedRepository, tpe: BlobType, id: &str) -> RusticResult<Bytes> {
+pub fn cat_blob<P>(repo: &IndexedRepository<P>, tpe: BlobType, id: &str) -> RusticResult<Bytes> {
     let id = Id::from_hex(id)?;
     let data = repo.index.blob_from_backend(tpe, &id)?;
 
     Ok(data)
 }
 
-pub fn cat_tree(
-    repo: &IndexedRepository,
+pub fn cat_tree<P: ProgressBars>(
+    repo: &IndexedRepository<P>,
     snap: &str,
     sn_filter: impl FnMut(&SnapshotFile) -> bool + Send + Sync,
-    pb: &impl ProgressBars,
 ) -> RusticResult<Bytes> {
     let (id, path) = snap.split_once(':').unwrap_or((snap, ""));
     let snap = SnapshotFile::from_str(
         &repo.repo.dbe,
         id,
         sn_filter,
-        &pb.progress_counter("getting snapshot..."),
+        &repo.repo.pb.progress_counter("getting snapshot..."),
     )?;
     let node = Tree::node_from_path(&repo.index, snap.tree, Path::new(path))?;
     let id = node

crates/rustic_core/src/commands/check.rs

@@ -28,11 +28,12 @@ pub struct CheckOpts {
 }
 
 impl CheckOpts {
-    pub fn run(self, repo: &OpenRepository, pb: &impl ProgressBars) -> RusticResult<()> {
+    pub fn run<P: ProgressBars>(self, repo: &OpenRepository<P>) -> RusticResult<()> {
         let be = &repo.dbe;
         let cache = &repo.cache;
         let hot_be = &repo.be_hot;
         let raw_be = &repo.be;
+        let pb = &repo.pb;
         if !self.trust_cache {
             if let Some(cache) = &cache {
                 for file_type in [FileType::Snapshot, FileType::Index] {

crates/rustic_core/src/repository.rs

@@ -34,7 +34,7 @@ use crate::{
     error::RepositoryErrorKind,
     index::IndexEntry,
     repofile::{configfile::ConfigFile, indexfile::IndexPack, keyfile::find_key_in_backend},
-    BlobType, IndexBackend, ProgressBars, RusticResult, SnapshotFile,
+    BlobType, IndexBackend, NoProgressBars, ProgressBars, RusticResult, SnapshotFile,
 };
 
 pub(super) mod constants {
@@ -196,15 +196,22 @@ pub(crate) fn read_password_from_reader(file: &mut impl BufRead) -> RusticResult
 }
 
 #[derive(Debug)]
-pub struct Repository {
+pub struct Repository<P> {
     name: String,
     pub be: HotColdBackend<ChooseBackend>,
     pub be_hot: Option<ChooseBackend>,
     opts: RepositoryOptions,
+    pb: P,
 }
 
-impl Repository {
+impl Repository<NoProgressBars> {
     pub fn new(opts: &RepositoryOptions) -> RusticResult<Self> {
+        Self::new_with_progress(opts, NoProgressBars {})
+    }
+}
+
+impl<P> Repository<P> {
+    pub fn new_with_progress(opts: &RepositoryOptions, pb: P) -> RusticResult<Self> {
         let be = match &opts.repository {
             Some(repo) => ChooseBackend::from_url(repo)?,
             None => return Err(RepositoryErrorKind::NoRepositoryGiven.into()),
@@ -238,6 +245,7 @@ impl Repository {
             be,
             be_hot,
             opts: opts.clone(),
+            pb,
         })
     }
 
@@ -276,7 +284,7 @@ impl Repository {
         }
     }
 
-    pub fn open(self) -> RusticResult<OpenRepository> {
+    pub fn open(self) -> RusticResult<OpenRepository<P>> {
         let config_ids = match self.be.list(FileType::Config) {
             Ok(val) => val,
             Err(_e) => return Err(RepositoryErrorKind::ListingRepositoryConfigFileFailed.into()),
@@ -329,6 +337,7 @@ impl Repository {
             be_hot: self.be_hot,
             config,
             opts: self.opts,
+            pb: self.pb,
         })
     }
 }
@@ -357,7 +366,7 @@ pub(crate) fn get_key(be: &impl ReadBackend, password: Option<String>) -> Rustic
 }
 
 #[derive(Debug)]
-pub struct OpenRepository {
+pub struct OpenRepository<P> {
     pub name: String,
     pub be: HotColdBackend<ChooseBackend>,
     pub be_hot: Option<ChooseBackend>,
@@ -366,40 +375,40 @@ pub struct OpenRepository {
     pub dbe: DecryptBackend<CachedBackend<HotColdBackend<ChooseBackend>>, Key>,
     pub config: ConfigFile,
     pub opts: RepositoryOptions,
+    pub(crate) pb: P,
 }
 
-impl OpenRepository {
+impl<P: ProgressBars> OpenRepository<P> {
     pub fn cat_file(&self, tpe: FileType, id: &str) -> RusticResult<Bytes> {
         commands::cat::cat_file(self, tpe, id)
     }
 
-    pub fn check(&self, opts: CheckOpts, pb: &impl ProgressBars) -> RusticResult<()> {
-        opts.run(self, pb)
+    pub fn check(&self, opts: CheckOpts) -> RusticResult<()> {
+        opts.run(self)
     }
 
-    pub fn to_indexed(self, pb: &impl ProgressBars) -> RusticResult<IndexedRepository> {
-        let index = IndexBackend::new(&self.dbe, &pb.progress_counter(""))?;
+    pub fn to_indexed(self) -> RusticResult<IndexedRepository<P>> {
+        let index = IndexBackend::new(&self.dbe, &self.pb.progress_counter(""))?;
         Ok(IndexedRepository { repo: self, index })
     }
 }
 
 #[derive(Debug)]
-pub struct IndexedRepository {
-    pub(crate) repo: OpenRepository,
+pub struct IndexedRepository<P> {
+    pub(crate) repo: OpenRepository<P>,
     pub(crate) index:
         IndexBackend<DecryptBackend<CachedBackend<HotColdBackend<ChooseBackend>>, Key>>,
 }
 
-impl IndexedRepository {
+impl<P: ProgressBars> IndexedRepository<P> {
     pub fn cat_blob(&self, tpe: BlobType, id: &str) -> RusticResult<Bytes> {
         commands::cat::cat_blob(self, tpe, id)
     }
     pub fn cat_tree(
         &self,
         snap: &str,
         sn_filter: impl FnMut(&SnapshotFile) -> bool + Send + Sync,
-        pb: &impl ProgressBars,
     ) -> RusticResult<Bytes> {
-        commands::cat::cat_tree(self, snap, sn_filter, pb)
+        commands::cat::cat_tree(self, snap, sn_filter)
     }
 }

src/commands.rs

@@ -34,7 +34,7 @@ use crate::{
         repair::RepairCmd, repoinfo::RepoInfoCmd, restore::RestoreCmd, self_update::SelfUpdateCmd,
         show_config::ShowConfigCmd, snapshots::SnapshotCmd, tag::TagCmd,
     },
-    config::RusticConfig,
+    config::{progress_options::ProgressOptions, RusticConfig},
     {Application, RUSTIC_APP},
 };
 
@@ -167,7 +167,7 @@ impl Configurable<RusticConfig> for EntryPoint {
     }
 }
 
-fn open_repository(repo: Repository) -> OpenRepository {
+fn open_repository<P>(repo: Repository<P>) -> OpenRepository<P> {
     match repo.open() {
         Ok(it) => it,
         Err(err) => {
@@ -177,8 +177,9 @@ fn open_repository(repo: Repository) -> OpenRepository {
     }
 }
 
-fn get_repository(config: &Arc<RusticConfig>) -> Repository {
-    match Repository::new(&config.repository) {
+fn get_repository(config: &Arc<RusticConfig>) -> Repository<ProgressOptions> {
+    let po = config.global.progress_options;
+    match Repository::new_with_progress(&config.repository, po) {
         Ok(it) => it,
         Err(err) => {
             status_err!("{}", err);

src/commands/cat.rs

@@ -61,23 +61,19 @@ impl Runnable for CatCmd {
 impl CatCmd {
     fn inner_run(&self) -> Result<()> {
         let config = RUSTIC_APP.config();
-        let po = config.global.progress_options;
-
         let repo = open_repository(get_repository(&config));
 
         let data = match &self.cmd {
             CatSubCmd::Config => repo.cat_file(FileType::Config, "")?,
             CatSubCmd::Index(opt) => repo.cat_file(FileType::Index, &opt.id)?,
             CatSubCmd::Snapshot(opt) => repo.cat_file(FileType::Snapshot, &opt.id)?,
             // special treatment for cating blobs: read the index and use it to locate the blob
-            CatSubCmd::TreeBlob(opt) => repo.to_indexed(&po)?.cat_blob(BlobType::Tree, &opt.id)?,
-            CatSubCmd::DataBlob(opt) => repo.to_indexed(&po)?.cat_blob(BlobType::Data, &opt.id)?,
+            CatSubCmd::TreeBlob(opt) => repo.to_indexed()?.cat_blob(BlobType::Tree, &opt.id)?,
+            CatSubCmd::DataBlob(opt) => repo.to_indexed()?.cat_blob(BlobType::Data, &opt.id)?,
             // special treatment for cating a tree within a snapshot
-            CatSubCmd::Tree(opt) => repo.to_indexed(&po)?.cat_tree(
-                &opt.snap,
-                |sn| config.snapshot_filter.matches(sn),
-                &po,
-            )?,
+            CatSubCmd::Tree(opt) => repo
+                .to_indexed()?
+                .cat_tree(&opt.snap, |sn| config.snapshot_filter.matches(sn))?,
         };
         println!("{}", String::from_utf8(data.to_vec())?);
 

src/commands/check.rs

@@ -21,10 +21,9 @@ pub(crate) struct CheckCmd {
 impl Runnable for CheckCmd {
     fn run(&self) {
         let config = RUSTIC_APP.config();
-        let progress_options = config.global.progress_options;
 
         let repo = open_repository(get_repository(&config));
-        if let Err(err) = repo.check(self.opts, &progress_options) {
+        if let Err(err) = repo.check(self.opts) {
             status_err!("{}", err);
             RUSTIC_APP.shutdown(Shutdown::Crash);
         };

src/commands/prune.rs

@@ -849,9 +849,9 @@ impl Pruner {
     }
 
     #[allow(clippy::significant_drop_tightening)]
-    fn do_prune(
+    fn do_prune<P>(
         self,
-        repo: OpenRepository,
+        repo: OpenRepository<P>,
         opts: &PruneCmd,
         progress_options: &ProgressOptions,
     ) -> Result<()> {

src/helpers.rs

@@ -25,8 +25,8 @@ pub(super) mod constants {
     pub(super) const MAX_READER_THREADS_NUM: usize = 20;
 }
 
-pub(crate) fn warm_up_wait(
-    repo: &OpenRepository,
+pub(crate) fn warm_up_wait<P>(
+    repo: &OpenRepository<P>,
     packs: impl ExactSizeIterator<Item = Id>,
     wait: bool,
     progress_options: &ProgressOptions,
@@ -97,10 +97,10 @@ pub(crate) fn warm_up(
     Ok(())
 }
 
-pub(crate) fn copy(
+pub(crate) fn copy<P>(
     snapshots: &[SnapshotFile],
     index: &impl IndexedBackend,
-    repo_dest: &OpenRepository,
+    repo_dest: &OpenRepository<P>,
 ) -> Result<()> {
     let config = RUSTIC_APP.config();
     let be_dest = &repo_dest.dbe;
@@ -201,9 +201,9 @@ pub(crate) fn copy(
     Ok(())
 }
 
-pub(crate) fn relevant_snapshots<F>(
+pub(crate) fn relevant_snapshots<F, P>(
     snaps: &[SnapshotFile],
-    dest_repo: &OpenRepository,
+    dest_repo: &OpenRepository<P>,
     filter: F,
     p: &impl Progress,
 ) -> Result<Vec<SnapshotFile>>