After the backup, print out a list of new CACHEDIR.TAGs

2 files changed, 26 insertions, 7 deletions

diff --git a/src/backup_run.rs b/src/backup_run.rs
index 2b23aa4..b01b365 100644
--- a/src/backup_run.rs
+++ b/src/backup_run.rs
@@ -9,7 +9,7 @@ use crate::fsiter::{AnnotatedFsEntry, FsIterError, FsIterator};
 use crate::generation::{LocalGeneration, LocalGenerationError, NascentError, NascentGeneration};
 use crate::policy::BackupPolicy;
 use log::{info, warn};
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 pub struct BackupRun<'a> {
     client: &'a BackupClient,
@@ -102,19 +102,30 @@ impl<'a> BackupRun<'a> {
         config: &ClientConfig,
         old: &LocalGeneration,
         newpath: &Path,
-    ) -> Result<(i64, Vec<BackupError>), NascentError> {
+        // TODO: turn this tuple into a struct for readability
+    ) -> Result<(i64, Vec<BackupError>, Vec<PathBuf>), NascentError> {
         let mut all_warnings = vec![];
+        let mut new_cachedir_tags = vec![];
         let count = {
             let mut new = NascentGeneration::create(newpath)?;
             for root in &config.roots {
                 let iter = FsIterator::new(root, config.exclude_cache_tag_directories);
-                let mut warnings = new.insert_iter(iter.map(|entry| self.backup(entry, &old)))?;
+                let entries = iter.map(|entry| {
+                    if let Ok(ref entry) = entry {
+                        let path = entry.inner.pathbuf();
+                        if entry.is_cachedir_tag && !old.is_cachedir_tag(&path)? {
+                            new_cachedir_tags.push(path);
+                        }
+                    };
+                    self.backup(entry, &old)
+                });
+                let mut warnings = new.insert_iter(entries)?;
                 all_warnings.append(&mut warnings);
             }
             new.file_count()
         };
         self.finish();
-        Ok((count, all_warnings))
+        Ok((count, all_warnings, new_cachedir_tags))
     }
 
     pub fn backup(
diff --git a/src/cmd/backup.rs b/src/cmd/backup.rs
index d574b96..6777856 100644
--- a/src/cmd/backup.rs
+++ b/src/cmd/backup.rs
@@ -26,18 +26,18 @@ impl Backup {
         let oldtemp = NamedTempFile::new()?;
         let newtemp = NamedTempFile::new()?;
 
-        let (count, warnings) = match genlist.resolve("latest") {
+        let (is_incremental, (count, warnings, new_tags)) = match genlist.resolve("latest") {
             Err(_) => {
                 info!("fresh backup without a previous generation");
                 let mut run = BackupRun::initial(config, &client)?;
                 let old = run.start(None, oldtemp.path())?;
-                run.backup_roots(config, &old, newtemp.path())?
+                (false, run.backup_roots(config, &old, newtemp.path())?)
             }
             Ok(old_id) => {
                 info!("incremental backup based on {}", old_id);
                 let mut run = BackupRun::incremental(config, &client)?;
                 let old = run.start(Some(&old_id), oldtemp.path())?;
-                run.backup_roots(config, &old, newtemp.path())?
+                (true, run.backup_roots(config, &old, newtemp.path())?)
             }
         };
 
@@ -47,6 +47,14 @@ impl Backup {
             println!("warning: {}", w);
         }
 
+        if is_incremental && !new_tags.is_empty() {
+            println!("New CACHEDIR.TAG files since the last backup:");
+            for t in new_tags {
+                println!("- {:?}", t);
+            }
+            println!("You can configure Obnam to ignore all such files by setting `exclude_cache_tag_directories` to `false`.");
+        }
+
         report_stats(&runtime, count, &gen_id, warnings.len())?;
 
         Ok(())