Re: 'git stash push' isn't atomic when Ctrl-C is pressed

[Junio C Hamano <gitster@pobox.com>]

Ævar Arnfjörð Bjarmason <avarab@gmail.com> writes:

> Of course it's possible that I'm just missing something, do you see a
> reason for why having a signal handler be responsible for rolling back a
> reference transaction wouldn't work?

It is not an issue between would and would not work.  It is what is
practical and reasonable to support, and end-user expectation
management.

Besides, if you did

	open the reference transaction
	create a new commit to represent a stash entry
	revert local modifications from working tree files
	update the stash ref with the new commit
	commit the reference transaction

with the auto-rollback of the ref transaction as an atexit handler,
it would help rolling back the reference update (i.e. update to
refs/stash to append a reflog entry), but it would not help at all
rolling back updates to working tree files.

In fact, if you instead did them in this order instead:

	open the reference transaction
	create a new commit to represent a stash entry
	update the stash ref with the new commit
	commit the reference transaction
	revert local modifications from working tree files

it will safely record the local modifications in the stash *and* in
the refstore _before_ it starts to modify the working tree files, so

 (1) killing the process before the ref change is committed will
     truly be a no-op at the end-user level.  There may have been
     unreferenced objects added to the object store, but that won't
     hurt anything.

 (2) killing the process after the ref change is committed, before
     we completely revert all local modifications from the working
     tree files, will still leave crufts in the working tree.  But

     (2-a) you can "git reset --hard" to go to a known good state,
           i.e. the state you would have been in if "git stash push"
           were allowed to finish without interruption.

     (2-b) you can do (2-a) followed by "git stash pop" to go to
           another known good state, namely, the state before you
           ran "git stash push".

If you do not commit the ref transaction before starting to muck
with working tree files, such a recovery, which is transparent and
easy to understand what is going on, would not be possible.  You'd
lose the local changes and be left with a working tree with local
changes partially reverted.