hooks: add custom post-command hook config

The microsoft/git fork includes pre- and post-command hooks, with the
initial intention of using these for VFS for Git. In that environment,
these are important hooks to avoid concurrent issues when the
virtualization is incomplete.

However, in the Office monorepo the post-command hook is used in a
different way. A custom hook is used to update the sparse-checkout, if
necessary. To avoid this hook from being incredibly slow on every Git
command, this hook checks for the existence of a "sentinel file" that is
written by a custom post-index-change hook and no-ops if that file does
not exist.

However, even this "no-op" is 200ms due to the use of two scripts (one
simple script in .git/hooks/ does some environment checking and then
calls a script from the working directory which actually contains the
logic).

Add a new config option, 'postCommand.strategy', that will allow for
multiple possible strategies in the future. For now, the one we are
adding is 'worktree-change' which states that we should write a
sentinel file instead of running the 'post-index-change' hook and then
skip the 'post-command' hook if the proper sentinel file doesn't exist.
If it does exist, then delete it and run the hook. This behavior is
_only_ triggered, however, if a part of the index changes that is within
the sparse checkout; If only parts of the index change that are not even
checked out on disk, the hook is still skipped.

I originally planned to put this into the repo-settings, but this caused
the repo settings to load in more cases than they did previously. When
there is an invalid boolean config option, this causes failure in new
places. This was caught by t3007.

This behavior is tested in t0401-post-command-hook.sh.

Signed-off-by: Derrick Stolee <[email protected]>

Author: derrickstolee

Documentation/config.adoc

@@ -490,6 +490,8 @@ include::config/pack.adoc[]
 
 include::config/pager.adoc[]
 
+include::config/postcommand.adoc[]
+
 include::config/pretty.adoc[]
 
 include::config/promisor.adoc[]

Documentation/config/postcommand.adoc

@@ -0,0 +1,13 @@
+postCommand.strategy::
+	The `post-command` hook is run on every Git process by default. This
+	config option allows running the hook only conditionally, according
+	to these values:
++
+----
+`always`;;
+	run the `post-command` hook on every process (default).
+
+`worktree-change`;;
+	run the `post-command` hook only if the current process wrote to
+	the index and updated the worktree.
+----

hook.c

@@ -1,6 +1,7 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "git-compat-util.h"
+#include "trace2/tr2_sid.h"
 #include "abspath.h"
 #include "environment.h"
 #include "advice.h"
@@ -176,6 +177,93 @@ static void run_hooks_opt_clear(struct run_hooks_opt *options)
 	strvec_clear(&options->args);
 }
 
+static char *get_post_index_change_sentinel_name(struct repository *r)
+{
+	struct strbuf path = STRBUF_INIT;
+	const char *sid = tr2_sid_get();
+	char *slash = strchr(sid, '/');
+
+	/*
+	 * Name is based on top-level SID, so children can indicate that
+	 * the top-level process should run the post-command hook.
+	 */
+	if (slash)
+		*slash = 0;
+
+	/*
+	 * Do not write to hooks directory, as it could be redirected
+	 * somewhere like the source tree.
+	 */
+	repo_git_path_replace(r, &path, "info/index-change-%s.snt", sid);
+
+	return strbuf_detach(&path, NULL);
+}
+
+static int write_post_index_change_sentinel(struct repository *r)
+{
+	char *path = get_post_index_change_sentinel_name(r);
+	FILE *fp = xfopen(path, "w");
+
+	if (fp) {
+		fprintf(fp, "run post-command hook");
+		fclose(fp);
+	}
+
+	free(path);
+	return fp ? 0 : -1;
+}
+
+/**
+ * Try to delete the sentinel file for this repository. If that succeeds, then
+ * return 1.
+ */
+static int post_index_change_sentinel_exists(struct repository *r)
+{
+	char *path = get_post_index_change_sentinel_name(r);
+	int res = 1;
+
+	if (unlink(path)) {
+		if (is_missing_file_error(errno))
+			res = 0;
+		else
+			warning_errno("failed to remove index-change sentinel file '%s'", path);
+	}
+
+	free(path);
+	return res;
+}
+
+/**
+ * See if we can replace the requested hook with an internal behavior.
+ * Returns 0 if the real hook should run. Returns nonzero if we instead
+ * executed custom internal behavior and the real hook should not run.
+ */
+static int handle_hook_replacement(struct repository *r,
+				   const char *hook_name,
+				   struct strvec *args)
+{
+	const char *strval;
+	if (repo_config_get_string_tmp(r, "postcommand.strategy", &strval) ||
+	    strcasecmp(strval, "worktree-change"))
+		return 0;
+
+	if (!strcmp(hook_name, "post-index-change")) {
+		/* Create a sentinel file only if the worktree changed. */
+		if (!strcmp(args->v[0], "1"))
+			write_post_index_change_sentinel(r);
+
+		/* We don't skip post-index-change hooks that exist. */
+		return 0;
+	}
+	if (!strcmp(hook_name, "post-command") &&
+	    !post_index_change_sentinel_exists(r)) {
+		/* We skip the post-command hook in this case. */
+		return 1;
+	}
+
+	return 0;
+}
+
 int run_hooks_opt(struct repository *r, const char *hook_name,
 		  struct run_hooks_opt *options)
 {
@@ -185,7 +273,7 @@ int run_hooks_opt(struct repository *r, const char *hook_name,
 		.hook_name = hook_name,
 		.options = options,
 	};
-	const char *hook_path = find_hook(r, hook_name);
+	const char *hook_path;
 	int ret = 0;
 	const struct run_process_parallel_opts opts = {
 		.tr2_category = "hook",
@@ -201,6 +289,13 @@ int run_hooks_opt(struct repository *r, const char *hook_name,
 		.data = &cb_data,
 	};
 
+	/* Interject hook behavior depending on strategy. */
+	if (r && r->gitdir &&
+	    handle_hook_replacement(r, hook_name, &options->args))
+		return 0;
+
+	hook_path = find_hook(r, hook_name);
+
 	/*
 	 * Backwards compatibility hack in VFS for Git: when originally
 	 * introduced (and used!), it was called `post-indexchanged`, but this

t/t0401-post-command-hook.sh

@@ -22,6 +22,7 @@ test_expect_success 'with succeeding hook' '
 '
 
 test_expect_success 'with failing pre-command hook' '
+	test_when_finished rm -f .git/hooks/pre-command &&
 	write_script .git/hooks/pre-command <<-EOF &&
 	exit 1
 	EOF
@@ -30,4 +31,59 @@ test_expect_success 'with failing pre-command hook' '
 	test_path_is_missing "$(cat .git/post-command.out)"
 '
 
+test_expect_success 'with post-index-change config' '
+	mkdir -p internal-hooks &&
+	write_script internal-hooks/post-command <<-EOF &&
+	echo ran >post-command.out
+	EOF
+	write_script internal-hooks/post-index-change <<-EOF &&
+	echo ran >post-index-change.out
+	EOF
+
+	# prevent writing of sentinel files to this directory.
+	test_when_finished chmod 775 internal-hooks &&
+	chmod a-w internal-hooks &&
+
+	git config core.hooksPath internal-hooks &&
+
+	# First, show expected behavior.
+	echo ran >expect &&
+	rm -f post-command.out post-index-change.out &&
+
+	# rev-parse leaves index intact, but runs post-command.
+	git rev-parse HEAD &&
+	test_path_is_missing post-index-change.out &&
+	test_cmp expect post-command.out &&
+	rm -f post-command.out &&
+
+	echo stuff >>file &&
+	# add updates the index and runs post-command.
+	git add file &&
+	test_cmp expect post-index-change.out &&
+	test_cmp expect post-command.out &&
+
+	# Now, show configured behavior
+	git config postCommand.strategy worktree-change &&
+
+	# rev-parse leaves index intact and thus skips post-command.
+	rm -f post-command.out post-index-change.out &&
+	git rev-parse HEAD &&
+	test_path_is_missing post-index-change.out &&
+	test_path_is_missing post-command.out &&
+
+	echo stuff >>file &&
+	# add keeps the worktree the same, so does not run post-command.
+	rm -f post-command.out post-index-change.out &&
+	git add file &&
+	test_cmp expect post-index-change.out &&
+	test_path_is_missing post-command.out &&
+
+	echo stuff >>file &&
+	# reset --hard updates the worktree.
+	rm -f post-command.out post-index-change.out &&
+	git reset --hard &&
+	test_cmp expect post-index-change.out &&
+	test_cmp expect post-command.out
+'
+
 test_done