client: pxar: combine writers into struct

Introduce a `PxarWriters` struct to bundle all writer instances
required for the pxar archive creation into a single object to limit
the number of function call parameters.

Signed-off-by: Christian Ebner <c.ebner@proxmox.com>

pbs-client/src/pxar/create.rs

@@ -18,7 +18,7 @@ use nix::sys::stat::{FileStat, Mode};
 use pathpatterns::{MatchEntry, MatchFlag, MatchList, MatchType, PatternFlag};
 use proxmox_sys::error::SysError;
 use pxar::encoder::{LinkOffset, SeqWrite};
-use pxar::Metadata;
+use pxar::{Metadata, PxarVariant};
 
 use proxmox_io::vec;
 use proxmox_lang::c_str;
@@ -135,12 +135,25 @@ struct Archiver {
 
 type Encoder<'a, T> = pxar::encoder::aio::Encoder<'a, T>;
 
+pub struct PxarWriters<T> {
+    archive: PxarVariant<T, T>,
+    catalog: Option<Arc<Mutex<dyn BackupCatalogWriter + Send>>>,
+}
+
+impl<T> PxarWriters<T> {
+    pub fn new(
+        archive: PxarVariant<T, T>,
+        catalog: Option<Arc<Mutex<dyn BackupCatalogWriter + Send>>>,
+    ) -> Self {
+        Self { archive, catalog }
+    }
+}
+
 pub async fn create_archive<T, F>(
     source_dir: Dir,
-    mut writer: T,
+    writers: PxarWriters<T>,
     feature_flags: Flags,
     callback: F,
-    catalog: Option<Arc<Mutex<dyn BackupCatalogWriter + Send>>>,
     options: PxarCreateOptions,
 ) -> Result<(), Error>
 where
@@ -170,7 +183,7 @@ where
         set.insert(stat.st_dev);
     }
 
-    let mut encoder = Encoder::new(pxar::PxarVariant::Unified(&mut writer), &metadata).await?;
+    let mut encoder = Encoder::new(writers.archive, &metadata).await?;
 
     let mut patterns = options.patterns;
 
@@ -188,7 +201,7 @@ where
         fs_magic,
         callback: Box::new(callback),
         patterns,
-        catalog,
+        catalog: writers.catalog,
         path: PathBuf::new(),
         entry_counter: 0,
         entry_limit: options.entries_max,

pbs-client/src/pxar/mod.rs

@@ -56,7 +56,7 @@ pub(crate) mod tools;
 mod flags;
 pub use flags::Flags;
 
-pub use create::{create_archive, PxarCreateOptions};
+pub use create::{create_archive, PxarCreateOptions, PxarWriters};
 pub use extract::{
     create_tar, create_zip, extract_archive, extract_sub_dir, extract_sub_dir_seq, ErrorHandler,
     OverwriteFlags, PxarExtractContext, PxarExtractOptions,

pbs-client/src/pxar_backup_stream.rs

@@ -17,6 +17,8 @@ use proxmox_io::StdChannelWriter;
 
 use pbs_datastore::catalog::CatalogWriter;
 
+use crate::pxar::create::PxarWriters;
+
 /// Stream implementation to encode and upload .pxar archives.
 ///
 /// The hyper client needs an async Stream for file upload, so we
@@ -53,16 +55,16 @@ impl PxarBackupStream {
                 StdChannelWriter::new(tx),
             ));
 
-            let writer = pxar::encoder::sync::StandardWriter::new(writer);
+            let writer =
+                pxar::PxarVariant::Unified(pxar::encoder::sync::StandardWriter::new(writer));
             if let Err(err) = crate::pxar::create_archive(
                 dir,
-                writer,
+                PxarWriters::new(writer, Some(catalog)),
                 crate::pxar::Flags::DEFAULT,
                 move |path| {
                     log::debug!("{:?}", path);
                     Ok(())
                 },
-                Some(catalog),
                 options,
             )
             .await

proxmox-restore-daemon/src/proxmox_restore_daemon/api.rs

@@ -23,7 +23,9 @@ use proxmox_sortable_macro::sortable;
 use proxmox_sys::fs::read_subdir;
 
 use pbs_api_types::file_restore::{FileRestoreFormat, RestoreDaemonStatus};
-use pbs_client::pxar::{create_archive, Flags, PxarCreateOptions, ENCODER_MAX_ENTRIES};
+use pbs_client::pxar::{
+    create_archive, Flags, PxarCreateOptions, PxarWriters, ENCODER_MAX_ENTRIES,
+};
 use pbs_datastore::catalog::{ArchiveEntry, DirEntryAttribute};
 use pbs_tools::json::required_string_param;
 
@@ -360,8 +362,8 @@ fn extract(
                         skip_e2big_xattr: false,
                     };
 
-                    let pxar_writer = TokioWriter::new(writer);
+                    let pxar_writer = pxar::PxarVariant::Unified(TokioWriter::new(writer));
-                    create_archive(dir, pxar_writer, Flags::DEFAULT, |_| Ok(()), None, options)
+                    create_archive(dir, PxarWriters::new(pxar_writer, None), Flags::DEFAULT, |_| Ok(()), options)
                         .await
                 }
                 .await;

pxar-bin/src/main.rs

@@ -13,7 +13,8 @@ use tokio::signal::unix::{signal, SignalKind};
 
 use pathpatterns::{MatchEntry, MatchType, PatternFlag};
 use pbs_client::pxar::{
-    format_single_line_entry, Flags, OverwriteFlags, PxarExtractOptions, ENCODER_MAX_ENTRIES,
+    format_single_line_entry, Flags, OverwriteFlags, PxarExtractOptions, PxarWriters,
+    ENCODER_MAX_ENTRIES,
 };
 
 use proxmox_router::cli::*;
@@ -373,16 +374,15 @@ async fn create_archive(
         feature_flags.remove(Flags::WITH_SOCKETS);
     }
 
-    let writer = pxar::encoder::sync::StandardWriter::new(writer);
+    let writer = pxar::PxarVariant::Unified(pxar::encoder::sync::StandardWriter::new(writer));
     pbs_client::pxar::create_archive(
         dir,
-        writer,
+        PxarWriters::new(writer, None),
         feature_flags,
         move |path| {
             log::debug!("{:?}", path);
             Ok(())
         },
-        None,
         options,
     )
     .await?;

tests/catar.rs

@@ -19,7 +19,7 @@ fn run_test(dir_name: &str) -> Result<(), Error> {
         .write(true)
         .truncate(true)
         .open("test-proxmox.catar")?;
-    let writer = pxar::encoder::sync::StandardWriter::new(writer);
+    let writer = pxar::PxarVariant::Unified(pxar::encoder::sync::StandardWriter::new(writer));
 
     let dir = nix::dir::Dir::open(
         dir_name,
@@ -35,10 +35,9 @@ fn run_test(dir_name: &str) -> Result<(), Error> {
     let rt = tokio::runtime::Runtime::new().unwrap();
     rt.block_on(create_archive(
         dir,
-        writer,
+        PxarWriters::new(writer, None),
         Flags::DEFAULT,
         |_| Ok(()),
-        None,
         options,
     ))?;