Web lists-archives.com

Re: [PATCH 1/2] commit/reset: try to clean up sequencer state




Hi Junio

On 01/04/2019 09:28, Junio C Hamano wrote:
Phillip Wood <phillip.wood123@xxxxxxxxx> writes:

From: Phillip Wood <phillip.wood@xxxxxxxxxxxxx>

When cherry-picking or reverting a sequence of commits and if the final
pick/revert has conflicts and the user uses `git commit` to commit the
conflict resolution and does not run `git cherry-pick --continue` then
the sequencer state is left behind. This can cause problems later. In my
case I cherry-picked a sequence of commits the last one of which I
committed with `git commit` after resolving some conflicts, then a while
later, on a different branch I aborted a revert which rewound my HEAD to
the end of the cherry-pick sequence on the previous branch.

I've certainly seen this myself.  Do you use command line prompt
support to remind you of the operation in progress?  I do, and I
have a suspicion that it did not help me in this situation by
ceasing to tell me that I have leftover state files after a manual
commit of the final step that conflicted and gave control back to
me.

Same here, the prompt I use just checks for the presence of CHERRY_PICK_HEAD which disappears after committing.

And detecting that we are finishing the last step and making sure
that the state files are removed does sound like the right approach
to fix it.

diff --git a/branch.c b/branch.c
index 28b81a7e02..9ed60081c1 100644
--- a/branch.c
+++ b/branch.c
@@ -5,6 +5,7 @@
  #include "refs.h"
  #include "refspec.h"
  #include "remote.h"
+#include "sequencer.h"
  #include "commit.h"
  #include "worktree.h"
@@ -339,8 +340,10 @@ void create_branch(struct repository *r, void remove_branch_state(struct repository *r)
  {
-	unlink(git_path_cherry_pick_head(r));
-	unlink(git_path_revert_head(r));
+	if (!unlink(git_path_cherry_pick_head(r)))
+		sequencer_post_commit_cleanup();
+	if (!unlink(git_path_revert_head(r)))
+		sequencer_post_commit_cleanup();

This and the same one in builtin/commit.c feels a bit iffy.  If we
had CHERRY_PICK_HEAD or REVERT_HEAD and attempted to remove one or
the other, whether the removal succeeds or fails (perhaps a virus
scanner on Windows had the file open while we tried to unlink it,
causing the unlink() to fail), don't we want the clean-up to happen?

Good point, I could add '|| errno == ENOENT' to the if or just use file_exists() as you suggest below

@@ -1678,6 +1680,7 @@ int cmd_commit(int argc, const char **argv, const char *prefix)
  	if (amend && !no_post_rewrite) {
  		commit_post_rewrite(the_repository, current_head, &oid);
  	}
+

This is an unrelated change.

Oops I'm not sure where that came from

  	if (!quiet) {
  		unsigned int flags = 0;
diff --git a/sequencer.c b/sequencer.c
index 0db410d590..028699209f 100644
--- a/sequencer.c
+++ b/sequencer.c
@@ -2220,6 +2220,29 @@ static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
  	return len;
  }
+void sequencer_post_commit_cleanup(void)
+{
+	struct replay_opts opts = REPLAY_OPTS_INIT;
+	struct strbuf buf = STRBUF_INIT;
+	const char *eol;
+	const char *todo_path = git_path_todo_file();
+
+	if (strbuf_read_file(&buf, todo_path, 0) < 0) {
+		if (errno == ENOENT) {
+			return;
+		} else {
+			error_errno("unable to open '%s'", todo_path);
+			return;
+		}
+	}
+	/* If there is only one line then we are done */
+	eol = strchr(buf.buf, '\n');
+	if (!eol || !eol[1])
+		sequencer_remove_state(&opts);
+
+	strbuf_release(&buf);
+}

I find this helper doing a bit too much and a bit too little at the
same time.  To reduce the iffiness I mentioned earlier, the callers
would behefit to have a helper that

  - notices the need to remove CHERRY_PICK_HEAD or REVERT_HEAD, and
    returns without doing anything if there is no need;

  - remove the *_HEAD file.

  - detect if we have dealt with the last step, and returns without
    doing any more thing if there are more to do;

  - remove the state files.

IOW, replace the existing series of two unlink() calls with a single
call to the helper.

On the other hand, the bulk of hand-rolled logic to determine if we
have processed the last step is better done in another helper
function that helps this helper, i.e.

	void sequencer_post_commit_cleanup(struct repo *r)
	{
		int need_cleanup = 0;

		if (file_exists(git_path_cherry_pick_head(r)) {
			unlink(git_path_cherry_pick_head(r));
			need_cleanup = 1;
		}
		if (file_exists(git_path_revert_head(r)) {
			unlink(git_path_revert_head(r));
			need_cleanup = 1;
		}
		if (!need_cleanup)
			return;
		if (!have_finished_the_last_pick())
			return;
		sequencer_remove_state(&opts);
	}

as that makes it easier to follow the logic of what is going on at
this level, while at the same time making the logic in the
have_finished_the_last_pick() helper easier to read by giving it a
meaningful name.

Thanks that definitely improves things, I'll send a re-roll

Best Wishes

Phillip