threads / discuss / 24274
Subject: 'git commit --short' without touching index?
'git commit --short' touches .git/index ('--short' implies '--dry-run').Is there any equivalent command that does not touch .git/index?
I'm using 'git commit --short' in a script to check if the repository needs attention. At present, it touches .git/index, which causes unnecessary activity in another script running rsync.
thanks, Daniel
Jeff KingRe: 'git commit --short' without touching index?
On Sat, Jul 03, 2010 at 08:30:31AM +0000, Daniel wrote:
> 'git commit --short' touches .git/index ('--short' implies '--dry-run').
>
> Is there any equivalent command that does not touch .git/index?
>
> I'm using 'git commit --short' in a script to check if the repository needs
> attention. At present, it touches .git/index, which causes
> unnecessary activity in another script running rsync.If you are just calling "git commit --short" without arguments (i.e., you care about the current state, not about "what would happen if I commit with these arguments"), then you probably want "git status". Also, you probably should use "git status --porcelain", which is the same as --short but is guaranteed not to change in the future.
However, both "status" and "commit --dry-run" will opportunistically refresh the index. If you don't want to touch the index at all, you can use a combination of:
# show changes between HEAD and index git diff-index HEAD
# show changes between index and working tree git diff-files
# show untracked files git ls-files --exclude-standard -o
One thing you will find, though, is that not refreshing the index means that stat-dirty files (e.g., ones which have no content changed but which have had their timestamps changed) will appear the diff-files above.
I don't think there is a simple way to tell "git status" to refresh the index internally, but not to write it out. It will do this if it doesn't have write permissions, but chmod'ing your index before running the script seems like an awful hack. You could refresh to a temporary index, but that also seems like a hack.
It would be nice if the index-refreshing code only wrote to the index if there was something worth writing. I'm not sure how hard that would be to implement, though.
-Peff
Re: 'git commit --short' without touching index?
Thanks. Your suggestion seems to work. Much appreciated.
Daniel
On 2010.07.03 9:17 AM, Jeff King wrote:
> However, both "status" and "commit --dry-run" will opportunistically > refresh the index. If you don't want to touch the index at all, you can > use a combination of: > > # show changes between HEAD and index > git diff-index HEAD > > # show changes between index and working tree > git diff-files > > # show untracked files > git ls-files --exclude-standard -o >
Junio C HamanoRe: 'git commit --short' without touching index?
Jeff King <peff@peff.net> writes:
> It would be nice if the index-refreshing code only wrote to the index if > there was something worth writing. I'm not sure how hard that would be > to implement, though.
Hmm, don't we already do that with "istate->cache_changed"?
In any case, we should diagnose "commit --short" (and "--procelain") as an error, perhaps by splitting option parsers for commit and status further.
Jeff KingRe: 'git commit --short' without touching index?
On Mon, Jul 05, 2010 at 01:10:43PM -0700, Junio C Hamano wrote:
> Jeff King <peff@peff.net> writes: > > > It would be nice if the index-refreshing code only wrote to the index if > > there was something worth writing. I'm not sure how hard that would be > > to implement, though. > > Hmm, don't we already do that with "istate->cache_changed"?
Apparently not:
$ stat .git/index | grep -i modify Modify: 2010-07-05 16:52:11.000000000 -0400 $ git status # On branch master nothing to commit $ stat .git/index | grep -i modify Modify: 2010-07-05 16:53:09.000000000 -0400
and it is not just updating some stat-dirtiness. Doing it over and over will keep updating the index. It looks like we unconditionally do the lock and write in cmd_status, but I haven't looked further.
> In any case, we should diagnose "commit --short" (and "--procelain") as an > error, perhaps by splitting option parsers for commit and status further.
I don't think it's an error. "commit --short" implies "commit --dry-run --short", which is actually a useful thing (well, _I_ don't find it useful, but I believe it was kept intentionally during the "status is no longer commit --dry-run" conversion).
-Peff
Junio C HamanoRe: 'git commit --short' without touching index?
Jeff King <peff@peff.net> writes:
> On Mon, Jul 05, 2010 at 01:10:43PM -0700, Junio C Hamano wrote: > >> Jeff King <peff@peff.net> writes: >> >> > It would be nice if the index-refreshing code only wrote to the index if >> > there was something worth writing. I'm not sure how hard that would be >> > to implement, though. >> >> Hmm, don't we already do that with "istate->cache_changed"? > > Apparently not: > > $ stat .git/index | grep -i modify > Modify: 2010-07-05 16:52:11.000000000 -0400 > $ git status > # On branch master > nothing to commit > $ stat .git/index | grep -i modify > Modify: 2010-07-05 16:53:09.000000000 -0400 > > and it is not just updating some stat-dirtiness. Doing it over and over > will keep updating the index. It looks like we unconditionally do the > lock and write in cmd_status, but I haven't looked further.
Something like this, plus possibly a similar fix to "git commit $path" codepath, perhaps?
We may want to audit all uses of write_cache() and write_index() that are not protected with active_cache_changed (or istate->cache_changed); I am reluctant to suggest placing that logic into write_index() at this point, though, as we may be updating the index in bulk, without marking active_cache_changed bit, exactly because we know we will unconditionally write the result out.
builtin/commit.c | 10 +++++++--- 1 files changed, 7 insertions(+), 3 deletions(-)
diff --git a/builtin/commit.c b/builtin/commit.c index c101f00..86d3926 100644 --- a/builtin/commit.c +++ b/builtin/commit.c @@ -343,9 +343,13 @@ static char *prepare_index(int argc, const char **argv, const char *prefix, int if (!pathspec || !*pathspec) { fd = hold_locked_index(&index_lock, 1); refresh_cache_or_die(refresh_flags); - if (write_cache(fd, active_cache, active_nr) || - commit_locked_index(&index_lock)) - die("unable to write new_index file"); + if (active_cache_changed) { + if (write_cache(fd, active_cache, active_nr) || + commit_locked_index(&index_lock)) + die("unable to write new_index file"); + } else { + rollback_lock_file(&index_lock); + } commit_style = COMMIT_AS_IS; return get_index_file(); }
Jeff KingRe: 'git commit --short' without touching index?
On Mon, Jul 05, 2010 at 02:28:16PM -0700, Junio C Hamano wrote:
> > Apparently not: > > > > $ stat .git/index | grep -i modify > > Modify: 2010-07-05 16:52:11.000000000 -0400 > > $ git status > > # On branch master > > nothing to commit > > $ stat .git/index | grep -i modify > > Modify: 2010-07-05 16:53:09.000000000 -0400 > > > > and it is not just updating some stat-dirtiness. Doing it over and over > > will keep updating the index. It looks like we unconditionally do the > > lock and write in cmd_status, but I haven't looked further. > > Something like this, plus possibly a similar fix to "git commit $path" > codepath, perhaps?
Yeah, that looks sane, though the one for "git status" is actually:
diff --git a/builtin/commit.c b/builtin/commit.c index 8258a16..5e578af 100644 --- a/builtin/commit.c +++ b/builtin/commit.c @@ -1090,9 +1090,11 @@ int cmd_status(int argc, const char **argv, const char *prefix) fd = hold_locked_index(&index_lock, 0); if (0 <= fd) { - if (!write_cache(fd, active_cache, active_nr)) + if (active_cache_changed && + !write_cache(fd, active_cache, active_nr)) commit_locked_index(&index_lock); - rollback_lock_file(&index_lock); + else + rollback_lock_file(&index_lock); } s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0; and I did confirm that it works (does not touch the index when nothing changes, and does write out the index even for a stat-dirty entry). > We may want to audit all uses of write_cache() and write_index() that are > not protected with active_cache_changed (or istate->cache_changed); I am > reluctant to suggest placing that logic into write_index() at this point, > though, as we may be updating the index in bulk, without marking > active_cache_changed bit, exactly because we know we will unconditionally > write the result out. I don't think changing write_index() is a good idea. There are a lot of calls, and I would rather have each one opt into this optimization than break them in a mass change. I was thinking that we might be able to simplify all of these lines into a "lock, write, and commit" function that would either rollback or die on failure, depending on a parameter. But there's often more complex logic going on between those functions, so I don't think it would really save us much. -Peff