[ref] refactor

Sebastian Thiel committed 5 years ago

Commit e3791771 parent a8441461 file · +21 −21Browse files

Unified · Split

git-ref/src/store/file/transaction.rs+21−21

 pub struct Transaction<'s> {
     store: &'s file::Store,
     packed_transaction: Option<packed::Transaction>,
-    packed: Option<packed::Buffer>,
     updates: Option<Vec<Edit>>,
 }
                     )
                     .map_err(Error::PreprocessingFailed)?;
-                if let Some(packed) = self.store.packed()? {
+                if self.store.packed_refs_path().is_file() {
                     let mut edits_for_packed_transaction = Vec::<RefEdit>::new();
+                    let mut needs_packed_refs_lookups = false;
                     for edit in updates.iter() {
                         let log_mode = match edit.update.change {
                             Change::Update {
                             Change::Delete { .. } => {
                                 edits_for_packed_transaction.push(edit.update.clone());
                             }
-                            _ => {}
+                            _ => {
+                                needs_packed_refs_lookups = true;
+                            }
                         }
                     }
-                    if !edits_for_packed_transaction.is_empty() {
+                    // We create a transaction even for empty packed edits to assure nobody else can change
-                        self.packed_transaction = Some(
+                    // it while we perform checks against previous values.
-                            packed
+                    if !edits_for_packed_transaction.is_empty() || needs_packed_refs_lookups {
-                                .into_transaction(lock_fail_mode)
+                        if let Some(packed) = self.store.packed()? {
-                                .map_err(Error::PackedTransactionAcquire)?
+                            self.packed_transaction = Some(
-                                .prepare(edits_for_packed_transaction)?,
+                                packed
-                        );
+                                    .into_transaction(lock_fail_mode)
-                    } else {
+                                    .map_err(Error::PackedTransactionAcquire)?
-                        self.packed = Some(packed);
+                                    .prepare(edits_for_packed_transaction)?,
+                            );
+                        }
                     }
                 }
                     if let Err(err) = Self::lock_ref_and_apply_change(
                         self.store,
                         lock_fail_mode,
-                        self.packed_transaction
+                        self.packed_transaction.as_ref().map(|t| t.buffer()),
-                            .as_ref()
-                            .map(|t| t.buffer())
-                            .or_else(|| self.packed.as_ref()),
                         change,
                     ) {
                         let err = match err {
                         }
                     }
                 }
-                let packed = match self.packed_transaction {
+                let packed = self
-                    Some(transaction) => Some(transaction.commit().map_err(Error::PackedTransactionCommit)?.1),
+                    .packed_transaction
-                    None => self.packed,
+                    .map(|t| t.commit().map(|r| r.1).map_err(Error::PackedTransactionCommit))
-                };
+                    .transpose()?;
                 Ok((updates.into_iter().map(|edit| edit.update).collect(), packed))
             }
             None => panic!("BUG: must call prepare before commit"),
         Transaction {
             store: self,
             packed_transaction: None,
-            packed: None,
             updates: None,
         }
     }