[pack] write packs to a directory with the proper name

Sebastian Thiel committed 5 years ago

Commit 3fbca7d1 parent f10adea8 files · +31 −25Browse files

Unified · Split

8 files

@@ -1210,6 +1210,7 @@ dependencies = [ · 1209 unmodified lines
1210	"rayon",	1210	"rayon",
1211	"serde",	1211	"serde",
1212	"serde_json",	1212	"serde_json",
		1213	"tempfile",
1213	]	1214	]
1214		1215
1215	[[package]]	1216	[[package]]

     pub input: I,
     /// A way of writing encoded bytes.
     output: hash::Write<W>,
+    /// Our trailing hash when done writing all input entries
+    trailer: Option<git_hash::ObjectId>,
     /// The amount of objects in the iteration and the version of the packfile to be written.
     /// Will be `None` to signal the header was written already.
     header_info: Option<(crate::data::Version, u32)>,
         FromEntriesIter {
             input,
             output: hash::Write::new(output, hash_kind),
+            trailer: None,
             entry_version: version,
             header_info: Some((version, num_entries)),
             is_done: false,
         self.output.inner
     }
+    /// Returns the trailing hash over all written entries once done.
+    /// It's `None` if we are not yet done writing.
+    pub fn digest(&self) -> Option<git_hash::ObjectId> {
+        self.trailer.clone()
+    }
     fn next_inner(&mut self) -> Result<u64, Error<E>> {
         let mut written = 0u64;
         if let Some((version, num_entries)) = self.header_info.take() {
                 written += digest.len() as u64;
                 self.output.flush()?;
                 self.is_done = true;
+                self.trailer = Some(git_hash::ObjectId::from(digest));
             }
         };
         Ok(written)

@@ -36,6 +36,7 @@ anyhow = "1.0.31" · 35 unmodified lines
36	quick-error = "2.0.0"	36	quick-error = "2.0.0"
37	bytesize = "1.0.1"	37	bytesize = "1.0.1"
38	serde_json = { version = "1.0.56", optional = true }	38	serde_json = { version = "1.0.56", optional = true }
		39	tempfile = "3.1.0"
39		40
40	# for async-client	41	# for async-client
41	async-trait = { version = "0.1.50", optional = true }	42	async-trait = { version = "0.1.50", optional = true }

     repository: impl AsRef<Path>,
     tips: impl IntoIterator<Item = impl AsRef<OsStr>>,
     input: Option<impl io::BufRead + Send + 'static>,
-    out: impl io::Write,
+    output_directory: impl AsRef<Path>,
     mut progress: impl Progress,
     ctx: Context,
 ) -> anyhow::Result<()> {
     write_progress.init(None, progress::bytes());
     let start = Instant::now();
+    let mut pack_file = tempfile::NamedTempFile::new_in(&output_directory)?;
     let mut output_iter = pack::data::output::bytes::FromEntriesIter::new(
         entries.inspect(|e| {
             if let Ok(entries) = e {
                 entries_progress.inc_by(entries.len())
             }
         }),
-        out,
+        &mut pack_file,
         num_objects as u32,
         pack::data::Version::default(),
         hash::Kind::default(),
     );
-    while let Some(io_res) = output_iter.next() {
+    for io_res in output_iter.by_ref() {
         if interrupt::is_triggered() {
             bail!("Cancelled by user")
         }
         let written = io_res?;
         write_progress.inc_by(written as usize);
     }
-    output_iter.into_write().flush()?;
+    let hash = output_iter.digest().expect("iteration is done");
+    pack_file.persist(output_directory.as_ref().join(format!("{}.pack", hash)))?;
     write_progress.show_throughput(start);
     entries_progress.show_throughput(start);

             repository,
             expansion,
             tips,
+            output_directory,
         }) => {
             let (_handle, progress) = prepare(verbose, "pack-create", Some(core::pack::create::PROGRESS_RANGE));
             let has_tips = !tips.is_empty();
-            let stdout = stdout();
-            let stdout_lock = stdout.lock();
-            #[cfg(feature = "atty")]
-            if atty::is(atty::Stream::Stdout) {
-                anyhow::bail!("Refusing to output pack data stream to stdout.")
-            }
             let input = if has_tips {
                 None
             } else {
                 repository.unwrap_or_else(|| PathBuf::from(".")),
                 tips,
                 input,
-                stdout_lock,
+                output_directory,
                 DoOrDiscard::from(progress),
                 core::pack::create::Context {
                     expansion,

     /// Possible values are "none" and "tree-traversal". Default is "none".
     pub expansion: Option<core::pack::create::ObjectExpansion>,
+    /// the directory into which to write the pack file.
+    #[argh(option, short = 'o')]
+    pub output_directory: PathBuf,
     /// the tips from which to start the commit graph iteration.
     ///
     /// If empty, we expect to read objects on stdin and default to 'none' as expansion mode.

             repository,
             expansion,
             tips,
+            output_directory,
         } => {
             let has_tips = !tips.is_empty();
-            let has_tui = progress;
-            if atty::is(if has_tui {
-                atty::Stream::Stderr
-            } else {
-                atty::Stream::Stdout
-            }) {
-                anyhow::bail!("Refusing to output pack data stream to stderr.")
-            }
             prepare_and_run(
                 "pack-create",
                 verbose,
                 progress,
                 progress_keep_open,
                 core::pack::create::PROGRESS_RANGE,
-                move |progress, out, err| {
+                move |progress, _out, _err| {
                     let input = if has_tips {
                         None
                     } else {
                         }),
                     };
                     let progress = git_features::progress::DoOrDiscard::from(progress);
-                    if has_tui {
+                    core::pack::create(repository, tips, input, output_directory, progress, context)
-                        core::pack::create(repository, tips, input, err, progress, context)
-                    } else {
-                        core::pack::create(repository, tips, input, out, progress, context)
-                    }
                 },
             )
         }

         /// Possible values are "none" and "tree-traversal". Default is "none".
         expansion: Option<core::pack::create::ObjectExpansion>,
+        /// The directory into which to write the pack file.
+        #[clap(long, short = 'o')]
+        output_directory: PathBuf,
         /// the tips from which to start the commit graph iteration.
         ///
         /// If empty, we expect to read objects on stdin and default to 'none' as expansion mode.