如何解决在git rebase期间重播历史记录时发生的冲突？

Question

This seems to be a not uncommon occurrence for me (in that it occurs frequently when I do need to rewrite history, which luckily is rare). Unlike rebasing on another branch, the conflicts do not seem to resolve after manually resolving them (they reoccur in future commits). Furthermore, it is a mystery why this happens at all:

I was trying to add a new commit, then move it earlier in my history by changing pick -> fixup for the moved commit. Everything related to this change, and all the commits surrounding these seemed to be fine, so I don't think that is the issue (also I had just performed the same procedure with success on another repo, and I've had similar issues in the past when doing different procedures). The issue seems to be related to replaying the history itself. Here is an example:

$ git rebase --continue                                                                                                                                      
Auto-merging services-core/src/main/java/edu/ncrn/cornell/service/CodebookService.scala
CONFLICT (content): Merge conflict in services-core/src/main/java/edu/ncrn/cornell/service/CodebookService.scala
error: could not apply a2fbc99... refactored details service return types, added pagination calls for var list services

Resolve all conflicts manually, mark them as resolved with
"git add/rm <conflicted_files>", then run "git rebase --continue".
You can instead skip this commit: run "git rebase --skip".
To abort and get back to the state before "git rebase", run "git rebase --abort".

Could not apply a2fbc99... refactored details service return types, added pagination calls for var list services
brandon@beb82dell0-DevContainer:~/workspace/ced2ar-core-services
$ git status
interactive rebase in progress; onto f3bd89d
Last commands done (97 commands done):
   pick 1228f8d fixing pom (which was fixed, but didn't make it into last few commits)
   pick a2fbc99 refactored details service return types, added pagination calls for var list services
  (see more in file .git/rebase-merge/done)
Next commands to do (23 remaining commands):
   pick 1b686a9 cleaned up codebookservice file
   pick a81a2ff updating to scala 2.12.x; adding circe library for JSON
  (use "git rebase --edit-todo" to view and edit)
You are currently rebasing branch 'master' on 'f3bd89d'.
  (fix conflicts and then run "git rebase --continue")
  (use "git rebase --skip" to skip this patch)
  (use "git rebase --abort" to check out the original branch)

Unmerged paths:
  (use "git reset HEAD <file>..." to unstage)
  (use "git add <file>..." to mark resolution)

        both modified:   services-core/src/main/java/edu/ncrn/cornell/service/CodebookService.scala

no changes added to commit (use "git add" and/or "git commit -a")
brandon@beb82dell0-DevContainer:~/workspace/ced2ar-core-services
$ git diff
diff --cc services-core/src/main/java/edu/ncrn/cornell/service/CodebookService.scala
index 02826ea,dbbdf12..0000000
--- a/services-core/src/main/java/edu/ncrn/cornell/service/CodebookService.scala
+++ b/services-core/src/main/java/edu/ncrn/cornell/service/CodebookService.scala
@@@ -126,41 -176,17 +176,51 @@@ class CodebookService 
      * @param handle
      * @return
      */
++<<<<<<< HEAD
 +  def getCodebookVariables(handle: String): Map[String, String] = {
 +    //hashmap with varnames as keys and corresponding varlabls as values
 +    val variables: mutable.Map[String, String] = mutable.Map()
 +    //get all varname instances for a given codebook
 +    val varnames: List[FieldInst] = fieldInstDao.findByRawDocIdAndFieldId(handle, "varname")
 +      .asScala.toList
 +    //for each varname find the labl and add to hashmap
 +    for (varname <- varnames) {
 +      val varnameId: Long = varname.getId
 +      val varIndices: List[FieldIndice] = fieldIndiceDao.findById_FieldInstId(varnameId).asScala.toList
 +      val varIndex: FieldIndice = varIndices.head
 +      val varIndexValue: String = varIndex.getIndexValue
 +      val lablMaps: List[Mapping] = mappingDao.findById_FieldId("varlabel").asScala.toList
 +      val lablMap: Mapping = lablMaps.head
 +      var lablXpath: String = lablMap.getXpath
 +      lablXpath = lablXpath.replace("*", varIndexValue)
 +      //find corresponding varlabl by canonical xpath
 +      val varlabls: List[FieldInst] = fieldInstDao.findByRawDocIdAndCanonicalXpath(handle, lablXpath)
 +        .asScala.toList
 +      //check that xpath was mapped correctly
 +      if (varlabls.size != 1) {
 +        println("failed to properly map xpath from varname to varlabl: " + lablXpath)
 +      }
 +      else {
 +        val varlabl: FieldInst = varlabls.head
 +        //insert into hashmap
 +        variables.put(varname.getValue, varlabl.getValue)
 +      }
 +    }
 +    variables.toMap
 +  }
++=======
+   def getCodebookVariables(handle: String): Map[String, (String, String)] =
+     getVarList(List(handle), 0)
+     
+   def getCodebookVariables(handle: String, page: Int): Map[String, (String, String)] =
+     getVarList(List(handle), page)
++>>>>>>> a2fbc99... refactored details service return types, added pagination calls for var list services

-   private def getVarList(handles: List[String]): Map[String, (String, String)] = {
+   private def getVarList(handles: List[String], pageNumber: Integer): Map[String, (String, String)] = {
      val variables: mutable.Map[String, (String, String)] = mutable.Map()
-     val varnames: List[FieldInst] = fieldInstDao.findByFieldId("varname").asScala.toList
+     val request: Pageable = new PageRequest(pageNumber, PAGE_SIZE, Sort.Direction.ASC, "value")
+     val varnamesPage: Page[FieldInst] = fieldInstDao.findByFieldIdAndRawDocIdIn("varname", handles.asJava, request)
+     val varnames: List[FieldInst] = varnamesPage.getContent.asScala.toList
      //for each varname find the labl and add to hashmap
      for (varname <- varnames) {
        val handle: String = varname.getRawDocId

I can try to patch this up by editing and running git rebase --continue , but invariably, the very next commit will have the same issue, but usually with even more code differences.

After cloning, what I did was to just do git rebase -i --root , move the second to last commit (about licensing) to the second commit, changing pick to fixup , then try to proceed with the rebase.

Answer 1

Since you are using interactive rebase, Git is using git cherry-pick to copy each commit.

A cherry-pick is literally a merge (well, it is ever since Git 1.5.1 anyway). But it's a merge with a peculiar merge base. A normal merge looks like this, graph-wise:

          o--...--o--L   <-- ours (HEAD)
         /
...--o--B
         \
          o--...--o--R   <-- theirs

Here, Git finds the changes in our branch by running (in effect) git diff --find-renames <hash-of-B> <hash-of-L> , and finds the changes in their branch using git diff --find-renames <hash-of-B> <hash-of-R> , and combines them.

For a cherry-pick, however, even if the branching looks much the same, our goal is to copy (the changes of) one particular commit, so what Git does looks instead like this:

          o--B--R--...--o   <-- theirs
         /
...--o--o
         \
          o--...--o--L   <-- ours (HEAD)

Here R is the commit being copied, L is our current (ie, HEAD ) commit, and B is the rather peculiar merge base. At this point Git does the same thing it does for any merge, diffing B (the merge base) against both R (theirs) and L (ours), and combines the changes.

If there is a merge conflict, you must resolve it. When this is done you have:

          o--*--R--S--...--o   <-- theirs
         /
...--o--o
         \
          o--...--o--L--R'   <-- ours (HEAD)

as the next cherry-pick: the merge base is now R , their commit is S , and our commit is R' . There is a very good chance that the same merge conflict you just resolved, will recur. This is what you are seeing.

(For cases like this, git rerere is helpful.)