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 'post-index-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.)

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).
+
+`post-index-change`;;
+	run the `post-command` hook only if the current process wrote to
+	the index.
+----

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,58 @@ 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;
+
+	repo_git_path_replace(r, &path, "hooks/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;
+}
+
 int run_hooks_opt(struct repository *r, const char *hook_name,
 		  struct run_hooks_opt *options)
 {
@@ -185,7 +238,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 +254,21 @@ int run_hooks_opt(struct repository *r, const char *hook_name,
 		.data = &cb_data,
 	};
 
+	/* Interject hook behavior depending on strategy. */
+	if (r && r->gitdir) {
+		const char *strval;
+		if (!repo_config_get_string_tmp(r, "postcommand.strategy", &strval) &&
+		    !strcasecmp(strval, "post-index-change")) {
+			if (!strcmp(hook_name, "post-index-change"))
+				return write_post_index_change_sentinel(r);
+			if (!strcmp(hook_name, "post-command") &&
+			    !post_index_change_sentinel_exists(r))
+				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,45 @@ 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 .git/hooks &&
+	write_script .git/hooks/post-command <<-EOF &&
+	echo ran >post-command.out
+	EOF
+	write_script .git/hooks/post-index-change <<-EOF &&
+	echo ran >post-index-change.out
+	EOF
+
+	# 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 post-index-change &&
+	rm -f post-command.out post-index-change.out &&
+
+	# rev-parse leaves index intact and thus skips post-command.
+	git rev-parse HEAD &&
+	test_path_is_missing post-index-change.out &&
+	test_path_is_missing post-command.out &&
+
+	echo stuff >>file &&
+	# add updates the index and runs post-command.
+	git add file &&
+	test_path_is_missing post-index-change.out &&
+	test_cmp expect post-command.out
+'
+
 test_done