Skip to contentSkip to conversation

Add post-indexchanged hook

PATCH Superseded Ben Peart 5 participants 13 messages Feb 8, 2019 – Feb 15, 2019 Documentation

lore
Share & tools
lore

Ben Peart

author
#0 lore raw

cover Add post-indexchanged hook

From: Ben Peart <[email protected]>

Add a post-indexchanged hook that is invoked after the index is written in do_write_locked_index().

This hook is meant primarily for notification, and cannot affect the outcome of git commands that trigger the index write.

VFSForGit uses this hook to be notified when a git command has made a change that could impact the virtual files projected in the working directory.

I'm submitting this in an effort to further minimize the set of differences between the VFSForGit fork and git.git in the hope that we can someday not need a separate fork at all.

Base Ref: v2.21.0-rc0
Web-Diff: https://github.com/benpeart/git/commit/639e57486a
Checkout: git fetch https://github.com/benpeart/git post-index-changed-v1 && git checkout 639e57486a

Ben Peart (2):
read-cache: add post-indexchanged hook
read-cache: add test for post-indexchanged hook

Kevin Willford (1):
read-cache: Add documentation for the post-indexchanged hook

 Documentation/githooks.txt         |  18 ++++
 builtin/reset.c                    |   1 +
 builtin/update-index.c             |   2 +
 cache.h                            |   4 +-
 read-cache.c                       |  14 ++-
 t/t7113-post-index-changed-hook.sh | 144 +++++++++++++++++++++++++++++
 unpack-trees.c                     |   2 +
 7 files changed, 182 insertions(+), 3 deletions(-)
 create mode 100755 t/t7113-post-index-changed-hook.sh

base-commit: d62dad7a7dca3f6a65162bf0e52cdf6927958e78

Signature · 1 line
2.20.1.windows.1
author
#1 lore raw

PATCH 1/3 read-cache: add post-indexchanged hook

From: Ben Peart <[email protected]>

Add a post-indexchanged hook that is invoked after the index is written in do_write_locked_index().

This hook is meant primarily for notification, and cannot affect the outcome of git commands that trigger the index write.

---
 builtin/reset.c        |  1 +
 builtin/update-index.c |  2 ++
 cache.h                |  4 +++-
 read-cache.c           | 14 ++++++++++++--
 unpack-trees.c         |  2 ++
 5 files changed, 20 insertions(+), 3 deletions(-)
builtin/reset.c +1 -0
index 4d18a461fa..e173afcaac 100644
@@ -380,6 +380,7 @@ int cmd_reset(int argc, const char **argv, const char *prefix)
 			int flags = quiet ? REFRESH_QUIET : REFRESH_IN_PORCELAIN;
 			if (read_from_tree(&pathspec, &oid, intent_to_add))
 				return 1;
+			the_index.updated_skipworktree = 1;
 			if (!quiet && get_git_work_tree()) {
 				uint64_t t_begin, t_delta_in_ms;
 
builtin/update-index.c +2 -0
index 02ace602b9..cf731640fa 100644
@@ -1071,6 +1071,8 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
 	if (entries < 0)
 		die("cache corrupted");
 
+	the_index.updated_skipworktree = 1;
+
 	/*
 	 * Custom copy of parse_options() because we want to handle
 	 * filename arguments as they come.
cache.h +3 -1
index 27fe635f62..46eb862d3e 100644
@@ -338,7 +338,9 @@ struct index_state {
 	struct cache_time timestamp;
 	unsigned name_hash_initialized : 1,
 		 initialized : 1,
-		 drop_cache_tree : 1;
+		 drop_cache_tree : 1,
+		 updated_workdir : 1,
+		 updated_skipworktree : 1;
 	struct hashmap name_hash;
 	struct hashmap dir_hash;
 	struct object_id oid;
read-cache.c +12 -2
index 0e0c93edc9..0fcfa8a075 100644
@@ -17,6 +17,7 @@
 #include "commit.h"
 #include "blob.h"
 #include "resolve-undo.h"
+#include "run-command.h"
 #include "strbuf.h"
 #include "varint.h"
 #include "split-index.h"
@@ -2999,8 +3000,17 @@ static int do_write_locked_index(struct index_state *istate, struct lock_file *l
 	if (ret)
 		return ret;
 	if (flags & COMMIT_LOCK)
-		return commit_locked_index(lock);
-	return close_lock_file_gently(lock);
+		ret = commit_locked_index(lock);
+	else
+		ret = close_lock_file_gently(lock);
+
+	run_hook_le(NULL, "post-indexchanged",
+			istate->updated_workdir ? "1" : "0",
+			istate->updated_skipworktree ? "1" : "0", NULL);
+	istate->updated_workdir = 0;
+	istate->updated_skipworktree = 0;
+
+	return ret;
 }
 
 static int write_split_index(struct index_state *istate,
unpack-trees.c +2 -0
index 3563daae1a..8665a4a7c0 100644
@@ -1637,6 +1637,8 @@ int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options
 						  WRITE_TREE_SILENT |
 						  WRITE_TREE_REPAIR);
 		}
+
+		o->result.updated_workdir = 1;
 		discard_index(o->dst_index);
 		*o->dst_index = o->result;
 	} else {
Signature · 1 line
2.20.1.windows.1
#2 lore raw

Re: [PATCH v1 1/3] read-cache: add post-indexchanged hook

Quoted 9 lines · Ben Peart

From: Ben Peart <[email protected]>

Add a post-indexchanged hook that is invoked after the index is written in do_write_locked_index().

This hook is meant primarily for notification, and cannot affect the outcome of git commands that trigger the index write.

First, I think the tests should be merged into this commit. That's what we typically do.

I'm also going to bikeshed slightly and suggest "post-index-changed", since we normally use dashes between words in our hook names.

cache.h struct index_state { · line 343

Quoted 12 lines
cache.h +3 -1
index 27fe635f62..46eb862d3e 100644
@@ -338,7 +338,9 @@ struct index_state {
 	struct cache_time timestamp;
 	unsigned name_hash_initialized : 1,
 		 initialized : 1,
-		 drop_cache_tree : 1;
+		 drop_cache_tree : 1,
+		 updated_workdir : 1,
+		 updated_skipworktree : 1;

How important is it that we expose whether the skip-worktree bit is changed? I can understand if we expose the workdir is updated, since that's a thing a general user of this hook is likely to be interested in. However, I'm not sure that for a general-purpose hook, the skip-worktree bit is interesting.

Quoted 15 lines
read-cache.c +1 -0
index 0e0c93edc9..0fcfa8a075 100644
@@ -17,6 +17,7 @@
 #include "commit.h"
 #include "blob.h"
 #include "resolve-undo.h"
+#include "run-command.h"
 #include "strbuf.h"
 #include "varint.h"
 #include "split-index.h"
@@ -2999,8 +3000,17 @@ static int do_write_locked_index(struct index_state *istate, struct lock_file *l
 	if (ret)
 		return ret;

read-cache.c static int do_write_locked_index(struct index_state *istate, struct lock_file *l · line 3009

Quoted 10 lines
read-cache.c +7 -2
 	if (flags & COMMIT_LOCK)
-		return commit_locked_index(lock);
-	return close_lock_file_gently(lock);
+		ret = commit_locked_index(lock);
+	else
+		ret = close_lock_file_gently(lock);
+
+	run_hook_le(NULL, "post-indexchanged",
+			istate->updated_workdir ? "1" : "0",
+			istate->updated_skipworktree ? "1" : "0", NULL);

I have, in general, some concerns about this API. First, I think we need to consider that if we're going to expose various bits of information, we might in the future want to expose more such bits. If so, adding integer parameters is not likely to be a good way to do this. It's hard to remember and if a binary is used as the hook, it may not always handle additional arguments gracefully like shell scripts tend to.

If we're not going to expose the skip-worktree bit, then I suppose one argument is fine. Otherwise, it might be better to expose key-value pairs on stdin instead, or something like that.

Finally, I have questions about performance. What's the overhead of determining whether the hook exists in this code path when there isn't one? Since the index is frequently used, and can be written out as an optimization by some commands, it would be nice to keep overhead low if the hook isn't present.

Signature · 2 lines
brian m. carlson: Houston, Texas, US
OpenPGP: https://keybase.io/bk2204
author
#3 lore raw

Re: [PATCH v1 1/3] read-cache: add post-indexchanged hook

Quoted 6 lines · brian m. carlson
Quoted 5 lines · Ben Peart

From: Ben Peart <[email protected]>

Add a post-indexchanged hook that is invoked after the index is written in do_write_locked_index().

Quoted 7 lines
Quoted 4 lines

This hook is meant primarily for notification, and cannot affect the outcome of git commands that trigger the index write.

First, I think the tests should be merged into this commit. That's what we typically do.

Happy to. In fact, I'd be happy to add the documentation as well and have a single commit. That's what _I'd_ typically do for something small like this. :)

Quoted 4 lines

I'm also going to bikeshed slightly and suggest "post-index-changed", since we normally use dashes between words in our hook names.

I can do that as well to help make it more consistent.

Quoted 10 lines
Quoted 10 lines
cache.h +1 -1
index 27fe635f62..46eb862d3e 100644
@@ -338,7 +338,9 @@ struct index_state {
  	struct cache_time timestamp;
  	unsigned name_hash_initialized : 1,
  		 initialized : 1,
-		 drop_cache_tree : 1;
+		 drop_cache_tree : 1,
Quoted 9 lines

cache.h struct index_state { · line 343

Quoted 2 lines
cache.h +2 -0
+		 updated_workdir : 1,
+		 updated_skipworktree : 1;

How important is it that we expose whether the skip-worktree bit is changed? I can understand if we expose the workdir is updated, since that's a thing a general user of this hook is likely to be interested in. However, I'm not sure that for a general-purpose hook, the skip-worktree bit is interesting.

In our use case, we needed the skip-worktree flag because if something clears the skip-worktree bit on a file, we need to start paying attention to it in the work directory. This flag tells us that may have happened and enables us to not have to do the extra work for other index changed events that don't change the index without updating the working directory.

Initially this was just to deal with 'reset --mixed' as it behaves differently with regards to updating the index and working directory than most other commands. However, the update-index command can also arbitrarily clear the skip-worktree bit so we renamed the flag to be more generic.

Quoted 24 lines
Quoted 24 lines
read-cache.c +7 -2
index 0e0c93edc9..0fcfa8a075 100644
@@ -17,6 +17,7 @@
  #include "commit.h"
  #include "blob.h"
  #include "resolve-undo.h"
+#include "run-command.h"
  #include "strbuf.h"
  #include "varint.h"
  #include "split-index.h"
@@ -2999,8 +3000,17 @@ static int do_write_locked_index(struct index_state *istate, struct lock_file *l
  	if (ret)
  		return ret;
  	if (flags & COMMIT_LOCK)
-		return commit_locked_index(lock);
-	return close_lock_file_gently(lock);
+		ret = commit_locked_index(lock);
+	else
+		ret = close_lock_file_gently(lock);
+
+	run_hook_le(NULL, "post-indexchanged",
+			istate->updated_workdir ? "1" : "0",
Quoted 9 lines

read-cache.c static int do_write_locked_index(struct index_state *istate, struct lock_file *l · line 3009

Quoted 1 line
read-cache.c +1 -0
+			istate->updated_skipworktree ? "1" : "0", NULL);

I have, in general, some concerns about this API. First, I think we need to consider that if we're going to expose various bits of information, we might in the future want to expose more such bits. If so, adding integer parameters is not likely to be a good way to do this. It's hard to remember and if a binary is used as the hook, it may not always handle additional arguments gracefully like shell scripts tend to.

Binaries deal with a variable number of arguments all the time via int argc, const char **argv so this isn't a problem (we actually use a binary for this hook already).

Quoted 4 lines

If we're not going to expose the skip-worktree bit, then I suppose one argument is fine. Otherwise, it might be better to expose key-value pairs on stdin instead, or something like that.

I'm not sure what else we may want to add in the future; this is all we've needed for our uses. For now, I'd suggest we keep it simple and just pass them as command line parameters like we do with the other hooks. It's easy to add additional arguments in the future and if we ever get to where that is unwieldy, we can address it then (YAGNI).

Quoted 6 lines

Finally, I have questions about performance. What's the overhead of determining whether the hook exists in this code path when there isn't one? Since the index is frequently used, and can be written out as an optimization by some commands, it would be nice to keep overhead low if the hook isn't present.

If you ever hit this code path, we've just updated the index which means we read the index file, did an lstat() on every file in the repo plus various refs, config files, etc, and then wrote out a new index file. Adding one more test for a hooks existence doesn't have any measurable impact.

Thank you for the feedback!

author
#4 lore raw

PATCH 2/3 read-cache: add test for post-indexchanged hook

In reply to Ben Peart

From: Ben Peart <[email protected]>

Test the new post-indexchanged hook and ensure it is triggered and passes the correct flags for various git commands.

---
 t/t7113-post-index-changed-hook.sh | 144 +++++++++++++++++++++++++++++
 1 file changed, 144 insertions(+)
 create mode 100755 t/t7113-post-index-changed-hook.sh
t/t7113-post-index-changed-hook.sh new file +144 -0
new file mode 100755
index 0000000000..5aeb726e37
@@ -0,0 +1,144 @@
+#!/bin/sh
+
+test_description='post index changed hook'
+
+. ./test-lib.sh
+
+test_expect_success 'setup' '
+	mkdir -p dir1 &&
+	touch dir1/file1.txt &&
+	echo testing >dir1/file2.txt &&
+	git add . &&
+	git commit -m "initial"
+'
+
+test_expect_success 'test status, add, commit, others trigger hook without flags set' '
+	mkdir -p .git/hooks &&
+	write_script .git/hooks/post-indexchanged <<-\EOF &&
+		if test "$1" -eq 1; then
+			echo "Invalid combination of flags passed to hook; updated_workdir is set." >testfailure
+			exit 1
+		fi
+		if test "$2" -eq 1; then
+			echo "Invalid combination of flags passed to hook; updated_skipworktree is set." >testfailure
+			exit 1
+		fi
+		if test -f ".git/index.lock"; then
+			echo ".git/index.lock exists" >testfailure
+			exit 3
+		fi
+		if ! test -f ".git/index"; then
+			echo ".git/index does not exist" >testfailure
+			exit 3
+		fi
+		echo "success" >testsuccess
+	EOF
+	mkdir -p dir2 &&
+	touch dir2/file1.txt &&
+	touch dir2/file2.txt &&
+	: force index to be dirty &&
+	test-tool chmtime +60 dir1/file1.txt &&
+	git status &&
+	test_path_is_file testsuccess && rm -f testsuccess &&
+	test_path_is_missing testfailure &&
+	git add . &&
+	test_path_is_file testsuccess && rm -f testsuccess &&
+	test_path_is_missing testfailure &&
+	git commit -m "second" &&
+	test_path_is_file testsuccess && rm -f testsuccess &&
+	test_path_is_missing testfailure &&
+	git checkout -- dir1/file1.txt &&
+	test_path_is_file testsuccess && rm -f testsuccess &&
+	test_path_is_missing testfailure &&
+	git update-index &&
+	test_path_is_missing testsuccess &&
+	test_path_is_missing testfailure &&
+	git reset --soft &&
+	test_path_is_missing testsuccess &&
+	test_path_is_missing testfailure
+'
+
+test_expect_success 'test checkout and reset trigger the hook' '
+	write_script .git/hooks/post-indexchanged <<-\EOF &&
+		if test "$1" -eq 1 && test "$2" -eq 1; then
+			echo "Invalid combination of flags passed to hook; updated_workdir and updated_skipworktree are both set." >testfailure
+			exit 1
+		fi
+		if test "$1" -eq 0 && test "$2" -eq 0; then
+			echo "Invalid combination of flags passed to hook; neither updated_workdir or updated_skipworktree are set." >testfailure
+			exit 2
+		fi
+		if test "$1" -eq 1; then
+			if test -f ".git/index.lock"; then
+				echo "updated_workdir set but .git/index.lock exists" >testfailure
+				exit 3
+			fi
+			if ! test -f ".git/index"; then
+				echo "updated_workdir set but .git/index does not exist" >testfailure
+				exit 3
+			fi
+		else
+			echo "update_workdir should be set for checkout" >testfailure
+			exit 4
+		fi
+		echo "success" >testsuccess
+	EOF
+	: force index to be dirty &&
+	test-tool chmtime +60 dir1/file1.txt &&
+	git checkout master &&
+	test_path_is_file testsuccess && rm -f testsuccess &&
+	test_path_is_missing testfailure &&
+	test-tool chmtime +60 dir1/file1.txt &&
+	git checkout HEAD &&
+	test_path_is_file testsuccess && rm -f testsuccess &&
+	test_path_is_missing testfailure &&
+	test-tool chmtime +60 dir1/file1.txt &&
+	git reset --hard &&
+	test_path_is_file testsuccess && rm -f testsuccess &&
+	test_path_is_missing testfailure &&
+	git checkout -B test &&
+	test_path_is_file testsuccess && rm -f testsuccess &&
+	test_path_is_missing testfailure
+'
+
+test_expect_success 'test reset --mixed and update-index triggers the hook' '
+	write_script .git/hooks/post-indexchanged <<-\EOF &&
+		if test "$1" -eq 1 && test "$2" -eq 1; then
+			echo "Invalid combination of flags passed to hook; updated_workdir and updated_skipworktree are both set." >testfailure
+			exit 1
+		fi
+		if test "$1" -eq 0 && test "$2" -eq 0; then
+			echo "Invalid combination of flags passed to hook; neither updated_workdir or updated_skipworktree are set." >testfailure
+			exit 2
+		fi
+		if test "$2" -eq 1; then
+			if test -f ".git/index.lock"; then
+				echo "updated_skipworktree set but .git/index.lock exists" >testfailure
+				exit 3
+			fi
+			if ! test -f ".git/index"; then
+				echo "updated_skipworktree set but .git/index does not exist" >testfailure
+				exit 3
+			fi
+		else
+			echo "updated_skipworktree should be set for reset --mixed and update-index" >testfailure
+			exit 4
+		fi
+		echo "success" >testsuccess
+	EOF
+	: force index to be dirty &&
+	test-tool chmtime +60 dir1/file1.txt &&
+	git reset --mixed --quiet HEAD~1 &&
+	test_path_is_file testsuccess && rm -f testsuccess &&
+	test_path_is_missing testfailure &&
+	git hash-object -w --stdin <dir1/file2.txt >expect &&
+	git update-index --cacheinfo 100644 "$(cat expect)" dir1/file1.txt &&
+	test_path_is_file testsuccess && rm -f testsuccess &&
+	test_path_is_missing testfailure &&
+	git update-index --skip-worktree dir1/file2.txt &&
+	git update-index --remove dir1/file2.txt &&
+	test_path_is_file testsuccess && rm -f testsuccess &&
+	test_path_is_missing testfailure
+'
+
+test_done
Signature · 1 line
2.20.1.windows.1
author
#5 lore raw

PATCH 3/3 read-cache: Add documentation for the post-indexchanged hook

In reply to Ben Peart

From: Kevin Willford <[email protected]>

Document the new post-indexchanged hook with information on when it is called as well as the flags passed and what each of them mean.

---
 Documentation/githooks.txt | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
Documentation/githooks.txt +18 -0
index 959044347e..9349cd8900 100644
@@ -492,6 +492,24 @@ This hook is invoked by `git-p4 submit`. It takes no parameters and nothing
 from standard input. Exiting with non-zero status from this script prevent
 `git-p4 submit` from launching. Run `git-p4 submit --help` for details.
 
+post-indexchanged
+~~~~~~~~~~~~~~~~~
+
+This hook is invoked when the index is written in read-cache.c
+do_write_locked_index.
+
+The first parameter passed to the hook is the indicator for the
+working directory being updated.  "1" meaning working directory
+was updated or "0" when the working directory was not updated.
+
+The second parameter passed to the hook is the indicator for whether
+or not the index was updated and the skip-worktree bit could have
+changed.  "1" meaning skip-worktree bits could have been updated
+and "0" meaning they were not.
+
+Only one parameter should be set to "1" when the hook runs.  The hook
+running passing "1", "1" should not be possible.
+
 GIT
 ---
 Part of the linkgit:git[1] suite
Signature · 1 line
2.20.1.windows.1
author
#6 lore raw

PATCH v2 1/1 read-cache: add post-indexchanged hook

In reply to Ben Peart

From: Ben Peart <[email protected]>

Add a post-indexchanged hook that is invoked after the index is written in do_write_locked_index().

This hook is meant primarily for notification, and cannot affect the outcome of git commands that trigger the index write.

The hook is passed a flag to indicate whether the working directory was updated or not and a flag indicating if a skip-worktree bit could have changed. These flags enable the hook to optmize its response to the index changed notification.

---

Notes:

    Base Ref: v2.21.0-rc0
    Web-Diff: https://github.com/benpeart/git/commit/03b96ccbd5
    Checkout: git fetch https://github.com/benpeart/git post-index-changed-v2 && git checkout 03b96ccbd5
    
    ### Interdiff (v1..v2):
    
    diff --git a/Documentation/githooks.txt b/Documentation/githooks.txt
    index 9349cd8900..94b4dadf30 100644
    --- a/Documentation/githooks.txt
    +++ b/Documentation/githooks.txt
    @@ -492,7 +492,7 @@ This hook is invoked by `git-p4 submit`. It takes no parameters and nothing
     from standard input. Exiting with non-zero status from this script prevent
     `git-p4 submit` from launching. Run `git-p4 submit --help` for details.
    
    -post-indexchanged
    +post-index-changed
     ~~~~~~~~~~~~~~~~~
    
     This hook is invoked when the index is written in read-cache.c
    diff --git a/read-cache.c b/read-cache.c
    index 0fcfa8a075..b6ead7bf8f 100644
    --- a/read-cache.c
    +++ b/read-cache.c
    @@ -3004,7 +3004,7 @@ static int do_write_locked_index(struct index_state *istate, struct lock_file *l
     	else
     		ret = close_lock_file_gently(lock);
    
    -	run_hook_le(NULL, "post-indexchanged",
    +	run_hook_le(NULL, "post-index-changed",
     			istate->updated_workdir ? "1" : "0",
     			istate->updated_skipworktree ? "1" : "0", NULL);
     	istate->updated_workdir = 0;
    diff --git a/t/t7113-post-index-changed-hook.sh b/t/t7113-post-index-changed-hook.sh
    index 5aeb726e37..6231b88fca 100755
    --- a/t/t7113-post-index-changed-hook.sh
    +++ b/t/t7113-post-index-changed-hook.sh
    @@ -14,7 +14,7 @@ test_expect_success 'setup' '
    
     test_expect_success 'test status, add, commit, others trigger hook without flags set' '
     	mkdir -p .git/hooks &&
    -	write_script .git/hooks/post-indexchanged <<-\EOF &&
    +	write_script .git/hooks/post-index-changed <<-\EOF &&
     		if test "$1" -eq 1; then
     			echo "Invalid combination of flags passed to hook; updated_workdir is set." >testfailure
     			exit 1
    @@ -59,7 +59,7 @@ test_expect_success 'test status, add, commit, others trigger hook without flags
     '
    
     test_expect_success 'test checkout and reset trigger the hook' '
    -	write_script .git/hooks/post-indexchanged <<-\EOF &&
    +	write_script .git/hooks/post-index-changed <<-\EOF &&
     		if test "$1" -eq 1 && test "$2" -eq 1; then
     			echo "Invalid combination of flags passed to hook; updated_workdir and updated_skipworktree are both set." >testfailure
     			exit 1
    @@ -102,7 +102,7 @@ test_expect_success 'test checkout and reset trigger the hook' '
     '
    
     test_expect_success 'test reset --mixed and update-index triggers the hook' '
    -	write_script .git/hooks/post-indexchanged <<-\EOF &&
    +	write_script .git/hooks/post-index-changed <<-\EOF &&
     		if test "$1" -eq 1 && test "$2" -eq 1; then
     			echo "Invalid combination of flags passed to hook; updated_workdir and updated_skipworktree are both set." >testfailure
     			exit 1
    
    ### Patches
 Documentation/githooks.txt         |  18 ++++
 builtin/reset.c                    |   1 +
 builtin/update-index.c             |   2 +
 cache.h                            |   4 +-
 read-cache.c                       |  14 ++-
 t/t7113-post-index-changed-hook.sh | 144 +++++++++++++++++++++++++++++
 unpack-trees.c                     |   2 +
 7 files changed, 182 insertions(+), 3 deletions(-)
 create mode 100755 t/t7113-post-index-changed-hook.sh
Documentation/githooks.txt +18 -0
index 959044347e..94b4dadf30 100644
@@ -492,6 +492,24 @@ This hook is invoked by `git-p4 submit`. It takes no parameters and nothing
 from standard input. Exiting with non-zero status from this script prevent
 `git-p4 submit` from launching. Run `git-p4 submit --help` for details.
 
+post-index-changed
+~~~~~~~~~~~~~~~~~
+
+This hook is invoked when the index is written in read-cache.c
+do_write_locked_index.
+
+The first parameter passed to the hook is the indicator for the
+working directory being updated.  "1" meaning working directory
+was updated or "0" when the working directory was not updated.
+
+The second parameter passed to the hook is the indicator for whether
+or not the index was updated and the skip-worktree bit could have
+changed.  "1" meaning skip-worktree bits could have been updated
+and "0" meaning they were not.
+
+Only one parameter should be set to "1" when the hook runs.  The hook
+running passing "1", "1" should not be possible.
+
 GIT
 ---
 Part of the linkgit:git[1] suite
builtin/reset.c +1 -0
index 4d18a461fa..e173afcaac 100644
@@ -380,6 +380,7 @@ int cmd_reset(int argc, const char **argv, const char *prefix)
 			int flags = quiet ? REFRESH_QUIET : REFRESH_IN_PORCELAIN;
 			if (read_from_tree(&pathspec, &oid, intent_to_add))
 				return 1;
+			the_index.updated_skipworktree = 1;
 			if (!quiet && get_git_work_tree()) {
 				uint64_t t_begin, t_delta_in_ms;
 
builtin/update-index.c +2 -0
index 02ace602b9..cf731640fa 100644
@@ -1071,6 +1071,8 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
 	if (entries < 0)
 		die("cache corrupted");
 
+	the_index.updated_skipworktree = 1;
+
 	/*
 	 * Custom copy of parse_options() because we want to handle
 	 * filename arguments as they come.
cache.h +3 -1
index 27fe635f62..46eb862d3e 100644
@@ -338,7 +338,9 @@ struct index_state {
 	struct cache_time timestamp;
 	unsigned name_hash_initialized : 1,
 		 initialized : 1,
-		 drop_cache_tree : 1;
+		 drop_cache_tree : 1,
+		 updated_workdir : 1,
+		 updated_skipworktree : 1;
 	struct hashmap name_hash;
 	struct hashmap dir_hash;
 	struct object_id oid;
read-cache.c +12 -2
index 0e0c93edc9..b6ead7bf8f 100644
@@ -17,6 +17,7 @@
 #include "commit.h"
 #include "blob.h"
 #include "resolve-undo.h"
+#include "run-command.h"
 #include "strbuf.h"
 #include "varint.h"
 #include "split-index.h"
@@ -2999,8 +3000,17 @@ static int do_write_locked_index(struct index_state *istate, struct lock_file *l
 	if (ret)
 		return ret;
 	if (flags & COMMIT_LOCK)
-		return commit_locked_index(lock);
-	return close_lock_file_gently(lock);
+		ret = commit_locked_index(lock);
+	else
+		ret = close_lock_file_gently(lock);
+
+	run_hook_le(NULL, "post-index-changed",
+			istate->updated_workdir ? "1" : "0",
+			istate->updated_skipworktree ? "1" : "0", NULL);
+	istate->updated_workdir = 0;
+	istate->updated_skipworktree = 0;
+
+	return ret;
 }
 
 static int write_split_index(struct index_state *istate,
t/t7113-post-index-changed-hook.sh new file +144 -0

144 lines not on this page · raw message

unpack-trees.c +2 -0
index 3563daae1a..8665a4a7c0 100644
@@ -1637,6 +1637,8 @@ int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options
 						  WRITE_TREE_SILENT |
 						  WRITE_TREE_REPAIR);
 		}
+
+		o->result.updated_workdir = 1;
 		discard_index(o->dst_index);
 		*o->dst_index = o->result;
 	} else {

base-commit: d62dad7a7dca3f6a65162bf0e52cdf6927958e78

Signature · 1 line
2.20.1.windows.1
#7 lore raw

Re: [PATCH v2] read-cache: add post-indexchanged hook

Quoted 3 lines · Ben Peart

From: Ben Peart <[email protected]>

Add a post-indexchanged hook that is invoked after the index is written in

s/post-indexchanged/post-index-changed/

Quoted 8 lines

do_write_locked_index().

This hook is meant primarily for notification, and cannot affect the outcome of git commands that trigger the index write.

The hook is passed a flag to indicate whether the working directory was updated or not and a flag indicating if a skip-worktree bit could have changed. These flags enable the hook to optmize its response to the

s/optmize/optimize/

ATB,
Ramsay Jones

#8 lore raw

Re: [PATCH v2] read-cache: add post-indexchanged hook

Quoted 6 lines · Ramsay Jones
Quoted 3 lines · Ben Peart

From: Ben Peart <[email protected]>

Add a post-indexchanged hook that is invoked after the index is written in

s/post-indexchanged/post-index-changed/

Good. I wasn't paying close attention to the previous round, but is that the only name-related bikeshedding? I somehow feel that without s/changed/change/ the name does not roll well on my tongue and does not sit well together with existing ones like post-receive (which is not post-received). I dunno.

Will queue. Thanks.

Quoted 13 lines
Quoted 8 lines

do_write_locked_index().

This hook is meant primarily for notification, and cannot affect the outcome of git commands that trigger the index write.

The hook is passed a flag to indicate whether the working directory was updated or not and a flag indicating if a skip-worktree bit could have changed. These flags enable the hook to optmize its response to the

s/optmize/optimize/

ATB,
Ramsay Jones

author
#9 lore raw

Re: [PATCH v2] read-cache: add post-indexchanged hook

Quoted 9 lines · Junio C Hamano
Quoted 6 lines · Ramsay Jones
Quoted 3 lines · Ben Peart

From: Ben Peart <[email protected]>

Add a post-indexchanged hook that is invoked after the index is written in

s/post-indexchanged/post-index-changed/

Quoted 7 lines

Good. I wasn't paying close attention to the previous round, but is that the only name-related bikeshedding? I somehow feel that without s/changed/change/ the name does not roll well on my tongue and does not sit well together with existing ones like post-receive (which is not post-received). I dunno.

Will queue. Thanks.

Would you like me to submit another version with the above spelling corrections in the commit message or is it easier to fix it up yourself?

Quoted 14 lines
Quoted 14 lines
Quoted 9 lines

do_write_locked_index().

This hook is meant primarily for notification, and cannot affect the outcome of git commands that trigger the index write.

The hook is passed a flag to indicate whether the working directory was updated or not and a flag indicating if a skip-worktree bit could have changed. These flags enable the hook to optmize its response to the

s/optmize/optimize/

ATB,
Ramsay Jones

#10 lore raw

Re: [PATCH v2] read-cache: add post-indexchanged hook

Quoted 16 lines · Ben Peart
Quoted 15 lines · Junio C Hamano
Quoted 6 lines · Ramsay Jones
Quoted 3 lines · Ben Peart

From: Ben Peart <[email protected]>

Add a post-indexchanged hook that is invoked after the index is written in

s/post-indexchanged/post-index-changed/

Good. I wasn't paying close attention to the previous round, but is that the only name-related bikeshedding? I somehow feel that without s/changed/change/ the name does not roll well on my tongue and does not sit well together with existing ones like post-receive (which is not post-received). I dunno.

Quoted 5 lines
Quoted 1 line

Will queue. Thanks.

Would you like me to submit another version with the above spelling corrections in the commit message or is it easier to fix it up yourself?

I've already done s/indexchanged/index-changed/ before queuing (there was only one IIRC in the log message), and also the 'optimize' typofix.

I didn't do anything about dropping 'd' at the end, as I haven't heard any feedback on that from anybody yet.

Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 8 lines

do_write_locked_index().

This hook is meant primarily for notification, and cannot affect the outcome of git commands that trigger the index write.

The hook is passed a flag to indicate whether the working directory was updated or not and a flag indicating if a skip-worktree bit could have changed. These flags enable the hook to optmize its response to the

s/optmize/optimize/

ATB,
Ramsay Jones

#11 lore raw

RE: [PATCH v2] read-cache: add post-indexchanged hook

Quoted 34 lines

-----Original Message-----
From: Junio C Hamano <[email protected]> On Behalf Of Junio C Hamano
Sent: Friday, February 15, 2019 12:50 PM
To: Ben Peart <[email protected]>
Cc: Ramsay Jones <[email protected]>; [email protected]; Ben Peart <[email protected]>; Kevin Willford <[email protected]>; [email protected]
Subject: Re: [PATCH v2] read-cache: add post-indexchanged hook

Quoted 17 lines · Ben Peart
Quoted 16 lines · Junio C Hamano
Quoted 7 lines · Ramsay Jones
Quoted 4 lines · Ben Peart

From: Ben Peart <[email protected]>

Add a post-indexchanged hook that is invoked after the index is written in

s/post-indexchanged/post-index-changed/

Good. I wasn't paying close attention to the previous round, but is that the only name-related bikeshedding? I somehow feel that without s/changed/change/ the name does not roll well on my tongue and does not sit well together with existing ones like post-receive (which is not post-received). I dunno.

Quoted 5 lines
Quoted 1 line

Will queue. Thanks.

Would you like me to submit another version with the above spelling corrections in the commit message or is it easier to fix it up yourself?

Quoted 6 lines

I've already done s/indexchanged/index-changed/ before queuing (there was only one IIRC in the log message), and also the 'optimize' typofix.

I didn't do anything about dropping 'd' at the end, as I haven't heard any feedback on that from anybody yet.

I'm ok with either. post-index-changed sounded clearer to me but you're right, none of the other hooks use the post tense. I've submitted one with 'post-index-change' - feel free to keep/user either.

Quoted 14 lines
Quoted 14 lines
Quoted 14 lines
Quoted 14 lines
Quoted 9 lines

do_write_locked_index().

This hook is meant primarily for notification, and cannot affect the outcome of git commands that trigger the index write.

The hook is passed a flag to indicate whether the working directory was updated or not and a flag indicating if a skip-worktree bit could have changed. These flags enable the hook to optmize its response to the

s/optmize/optimize/

ATB,
Ramsay Jones

author
#12 lore raw

PATCH v3 1/1 read-cache: add post-index-change hook

In reply to Ben Peart

From: Ben Peart <[email protected]>

Add a post-index-change hook that is invoked after the index is written in do_write_locked_index().

This hook is meant primarily for notification, and cannot affect the outcome of git commands that trigger the index write.

The hook is passed a flag to indicate whether the working directory was updated or not and a flag indicating if a skip-worktree bit could have changed. These flags enable the hook to optimize its response to the index change notification.

---

Notes:

    Base Ref: v2.21.0-rc0
    Web-Diff: https://github.com/benpeart/git/commit/27001af8db
    Checkout: git fetch https://github.com/benpeart/git post-index-changed-v3 && git checkout 27001af8db
    
    ### Interdiff (v2..v3):
    
    diff --git a/Documentation/githooks.txt b/Documentation/githooks.txt
    index 94b4dadf30..bfb0be3659 100644
    --- a/Documentation/githooks.txt
    +++ b/Documentation/githooks.txt
    @@ -492,7 +492,7 @@ This hook is invoked by `git-p4 submit`. It takes no parameters and nothing
     from standard input. Exiting with non-zero status from this script prevent
     `git-p4 submit` from launching. Run `git-p4 submit --help` for details.
    
    -post-index-changed
    +post-index-change
     ~~~~~~~~~~~~~~~~~
    
     This hook is invoked when the index is written in read-cache.c
    diff --git a/read-cache.c b/read-cache.c
    index b6ead7bf8f..862bdf383d 100644
    --- a/read-cache.c
    +++ b/read-cache.c
    @@ -3004,7 +3004,7 @@ static int do_write_locked_index(struct index_state *istate, struct lock_file *l
     	else
     		ret = close_lock_file_gently(lock);
    
    -	run_hook_le(NULL, "post-index-changed",
    +	run_hook_le(NULL, "post-index-change",
     			istate->updated_workdir ? "1" : "0",
     			istate->updated_skipworktree ? "1" : "0", NULL);
     	istate->updated_workdir = 0;
    diff --git a/t/t7113-post-index-changed-hook.sh b/t/t7113-post-index-change-hook.sh
    similarity index 95%
    rename from t/t7113-post-index-changed-hook.sh
    rename to t/t7113-post-index-change-hook.sh
    index 6231b88fca..f011ad7eec 100755
    --- a/t/t7113-post-index-changed-hook.sh
    +++ b/t/t7113-post-index-change-hook.sh
    @@ -1,6 +1,6 @@
     #!/bin/sh
    
    -test_description='post index changed hook'
    +test_description='post index change hook'
    
     . ./test-lib.sh
    
    @@ -14,7 +14,7 @@ test_expect_success 'setup' '
    
     test_expect_success 'test status, add, commit, others trigger hook without flags set' '
     	mkdir -p .git/hooks &&
    -	write_script .git/hooks/post-index-changed <<-\EOF &&
    +	write_script .git/hooks/post-index-change <<-\EOF &&
     		if test "$1" -eq 1; then
     			echo "Invalid combination of flags passed to hook; updated_workdir is set." >testfailure
     			exit 1
    @@ -59,7 +59,7 @@ test_expect_success 'test status, add, commit, others trigger hook without flags
     '
    
     test_expect_success 'test checkout and reset trigger the hook' '
    -	write_script .git/hooks/post-index-changed <<-\EOF &&
    +	write_script .git/hooks/post-index-change <<-\EOF &&
     		if test "$1" -eq 1 && test "$2" -eq 1; then
     			echo "Invalid combination of flags passed to hook; updated_workdir and updated_skipworktree are both set." >testfailure
     			exit 1
    @@ -102,7 +102,7 @@ test_expect_success 'test checkout and reset trigger the hook' '
     '
    
     test_expect_success 'test reset --mixed and update-index triggers the hook' '
    -	write_script .git/hooks/post-index-changed <<-\EOF &&
    +	write_script .git/hooks/post-index-change <<-\EOF &&
     		if test "$1" -eq 1 && test "$2" -eq 1; then
     			echo "Invalid combination of flags passed to hook; updated_workdir and updated_skipworktree are both set." >testfailure
     			exit 1
    
    ### Patches
 Documentation/githooks.txt        |  18 ++++
 builtin/reset.c                   |   1 +
 builtin/update-index.c            |   2 +
 cache.h                           |   4 +-
 read-cache.c                      |  14 ++-
 t/t7113-post-index-change-hook.sh | 144 ++++++++++++++++++++++++++++++
 unpack-trees.c                    |   2 +
 7 files changed, 182 insertions(+), 3 deletions(-)
 create mode 100755 t/t7113-post-index-change-hook.sh
Documentation/githooks.txt +18 -0
index 959044347e..bfb0be3659 100644
@@ -492,6 +492,24 @@ This hook is invoked by `git-p4 submit`. It takes no parameters and nothing
 from standard input. Exiting with non-zero status from this script prevent
 `git-p4 submit` from launching. Run `git-p4 submit --help` for details.
 
+post-index-change
+~~~~~~~~~~~~~~~~~
+
+This hook is invoked when the index is written in read-cache.c
+do_write_locked_index.
+
+The first parameter passed to the hook is the indicator for the
+working directory being updated.  "1" meaning working directory
+was updated or "0" when the working directory was not updated.
+
+The second parameter passed to the hook is the indicator for whether
+or not the index was updated and the skip-worktree bit could have
+changed.  "1" meaning skip-worktree bits could have been updated
+and "0" meaning they were not.
+
+Only one parameter should be set to "1" when the hook runs.  The hook
+running passing "1", "1" should not be possible.
+
 GIT
 ---
 Part of the linkgit:git[1] suite
builtin/reset.c +1 -0
index 4d18a461fa..e173afcaac 100644
@@ -380,6 +380,7 @@ int cmd_reset(int argc, const char **argv, const char *prefix)
 			int flags = quiet ? REFRESH_QUIET : REFRESH_IN_PORCELAIN;
 			if (read_from_tree(&pathspec, &oid, intent_to_add))
 				return 1;
+			the_index.updated_skipworktree = 1;
 			if (!quiet && get_git_work_tree()) {
 				uint64_t t_begin, t_delta_in_ms;
 
builtin/update-index.c +2 -0
index 02ace602b9..cf731640fa 100644
@@ -1071,6 +1071,8 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
 	if (entries < 0)
 		die("cache corrupted");
 
+	the_index.updated_skipworktree = 1;
+
 	/*
 	 * Custom copy of parse_options() because we want to handle
 	 * filename arguments as they come.
cache.h +3 -1
index 27fe635f62..46eb862d3e 100644
@@ -338,7 +338,9 @@ struct index_state {
 	struct cache_time timestamp;
 	unsigned name_hash_initialized : 1,
 		 initialized : 1,
-		 drop_cache_tree : 1;
+		 drop_cache_tree : 1,
+		 updated_workdir : 1,
+		 updated_skipworktree : 1;
 	struct hashmap name_hash;
 	struct hashmap dir_hash;
 	struct object_id oid;
read-cache.c +12 -2
index 0e0c93edc9..862bdf383d 100644
@@ -17,6 +17,7 @@
 #include "commit.h"
 #include "blob.h"
 #include "resolve-undo.h"
+#include "run-command.h"
 #include "strbuf.h"
 #include "varint.h"
 #include "split-index.h"
@@ -2999,8 +3000,17 @@ static int do_write_locked_index(struct index_state *istate, struct lock_file *l
 	if (ret)
 		return ret;
 	if (flags & COMMIT_LOCK)
-		return commit_locked_index(lock);
-	return close_lock_file_gently(lock);
+		ret = commit_locked_index(lock);
+	else
+		ret = close_lock_file_gently(lock);
+
+	run_hook_le(NULL, "post-index-change",
+			istate->updated_workdir ? "1" : "0",
+			istate->updated_skipworktree ? "1" : "0", NULL);
+	istate->updated_workdir = 0;
+	istate->updated_skipworktree = 0;
+
+	return ret;
 }
 
 static int write_split_index(struct index_state *istate,
t/t7113-post-index-change-hook.sh new file +144 -0

144 lines not on this page · raw message

unpack-trees.c +2 -0
index 3563daae1a..8665a4a7c0 100644
@@ -1637,6 +1637,8 @@ int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options
 						  WRITE_TREE_SILENT |
 						  WRITE_TREE_REPAIR);
 		}
+
+		o->result.updated_workdir = 1;
 		discard_index(o->dst_index);
 		*o->dst_index = o->result;
 	} else {

base-commit: d62dad7a7dca3f6a65162bf0e52cdf6927958e78

Signature · 1 line
2.20.1.windows.1