merger: Keep redundant cherry-pick commits

In normal git usage, cherry-picking a commit that has already been
applied and doesn't do anything or cherry-picking an empty commit causes
git to exit with an error to let the user decide what they want to do.
However, this doesn't match the behavior of merges and rebases where
non-empty commits that have already been applied are simply skipped
(empty source commits are preserved).

To fix this, add the --keep-redundant-commit option to `git cherry-pick`
to make git always keep a commit when cherry-picking even when it is
empty for either reason. Then, after the cherry-pick, check if the new
commit is empty and if so back it out if the original commit _wasn't_
empty.

This two step process is necessary because git doesn't have any options
to simply skip cherry-pick commits that have already been applied to the
tree.

Removing commits that have already been applied is particularly
important in a "deploy" pipeline triggered by a Gerrit "change-merged"
event, since the scheduler will try to cherry-pick the change on top of
the commit that just merged. Without this option, the cherry-pick will
fail and the deploy pipeline will fail with a MERGE_CONFICT.

Change-Id: I326ba49e2268197662d11fd79e46f3c020675f21

1 files changed, 20 insertions, 2 deletions

diff --git a/zuul/merger/merger.py b/zuul/merger/merger.py
index e4688a1b7..1df833bc5 100644
--- a/zuul/merger/merger.py
+++ b/zuul/merger/merger.py
@@ -595,14 +595,32 @@ class Repo(object):
         log = get_annotated_logger(self.log, zuul_event_id)
         repo = self.createRepoObject(zuul_event_id)
         self.fetch(ref, zuul_event_id=zuul_event_id)
-        if len(repo.commit("FETCH_HEAD").parents) > 1:
+        fetch_head = repo.commit("FETCH_HEAD")
+        if len(fetch_head.parents) > 1:
             args = ["-s", "resolve", "FETCH_HEAD"]
             log.debug("Merging %s with args %s instead of cherry-picking",
                       ref, args)
             repo.git.merge(*args)
         else:
             log.debug("Cherry-picking %s", ref)
-            repo.git.cherry_pick("FETCH_HEAD")
+            # Git doesn't have an option to ignore commits that are already
+            # applied to the working tree when cherry-picking, so pass the
+            # --keep-redundant-commits option, which will cause it to make an
+            # empty commit
+            repo.git.cherry_pick("FETCH_HEAD", keep_redundant_commits=True)
+
+            # If the newly applied commit is empty, it means either:
+            #  1) The commit being cherry-picked was empty, in which the empty
+            #     commit should be kept
+            #  2) The commit being cherry-picked was already applied to the
+            #     tree, in which case the empty commit should be backed out
+            head = repo.commit("HEAD")
+            parent = head.parents[0]
+            if not any(head.diff(parent)) and \
+                    any(fetch_head.diff(fetch_head.parents[0])):
+                log.debug("%s was already applied. Removing it", ref)
+                self._checkout(repo, parent)
+
         return repo.head.commit
 
     def merge(self, ref, strategy=None, zuul_event_id=None):