| #include "git-compat-util.h" |
| #include "abspath.h" |
| #include "advice.h" |
| #include "gettext.h" |
| #include "hook.h" |
| #include "path.h" |
| #include "run-command.h" |
| #include "config.h" |
| #include "strbuf.h" |
| #include "environment.h" |
| #include "setup.h" |
| |
| const char *find_hook(struct repository *r, const char *name) |
| { |
| static struct strbuf path = STRBUF_INIT; |
| |
| int found_hook; |
| |
| strbuf_reset(&path); |
| strbuf_repo_git_path(&path, r, "hooks/%s", name); |
| found_hook = access(path.buf, X_OK) >= 0; |
| #ifdef STRIP_EXTENSION |
| if (!found_hook) { |
| int err = errno; |
| |
| strbuf_addstr(&path, STRIP_EXTENSION); |
| found_hook = access(path.buf, X_OK) >= 0; |
| if (!found_hook) |
| errno = err; |
| } |
| #endif |
| |
| if (!found_hook) { |
| if (errno == EACCES && advice_enabled(ADVICE_IGNORED_HOOK)) { |
| static struct string_list advise_given = STRING_LIST_INIT_DUP; |
| |
| if (!string_list_lookup(&advise_given, name)) { |
| string_list_insert(&advise_given, name); |
| advise(_("The '%s' hook was ignored because " |
| "it's not set as executable.\n" |
| "You can disable this warning with " |
| "`git config advice.ignoredHook false`."), |
| path.buf); |
| } |
| } |
| return NULL; |
| } |
| return path.buf; |
| } |
| |
| int hook_exists(struct repository *r, const char *name) |
| { |
| return !!find_hook(r, name); |
| } |
| |
| static int pick_next_hook(struct child_process *cp, |
| struct strbuf *out UNUSED, |
| void *pp_cb, |
| void **pp_task_cb UNUSED) |
| { |
| struct hook_cb_data *hook_cb = pp_cb; |
| const char *hook_path = hook_cb->hook_path; |
| |
| if (!hook_path) |
| return 0; |
| |
| cp->no_stdin = 1; |
| strvec_pushv(&cp->env, hook_cb->options->env.v); |
| /* reopen the file for stdin; run_command closes it. */ |
| if (hook_cb->options->path_to_stdin) { |
| cp->no_stdin = 0; |
| cp->in = xopen(hook_cb->options->path_to_stdin, O_RDONLY); |
| } |
| cp->stdout_to_stderr = 1; |
| cp->trace2_hook_name = hook_cb->hook_name; |
| cp->dir = hook_cb->options->dir; |
| |
| strvec_push(&cp->args, hook_path); |
| strvec_pushv(&cp->args, hook_cb->options->args.v); |
| |
| /* |
| * This pick_next_hook() will be called again, we're only |
| * running one hook, so indicate that no more work will be |
| * done. |
| */ |
| hook_cb->hook_path = NULL; |
| |
| return 1; |
| } |
| |
| static int notify_start_failure(struct strbuf *out UNUSED, |
| void *pp_cb, |
| void *pp_task_cp UNUSED) |
| { |
| struct hook_cb_data *hook_cb = pp_cb; |
| |
| hook_cb->rc |= 1; |
| |
| return 1; |
| } |
| |
| static int notify_hook_finished(int result, |
| struct strbuf *out UNUSED, |
| void *pp_cb, |
| void *pp_task_cb UNUSED) |
| { |
| struct hook_cb_data *hook_cb = pp_cb; |
| struct run_hooks_opt *opt = hook_cb->options; |
| |
| hook_cb->rc |= result; |
| |
| if (opt->invoked_hook) |
| *opt->invoked_hook = 1; |
| |
| return 0; |
| } |
| |
| static void run_hooks_opt_clear(struct run_hooks_opt *options) |
| { |
| strvec_clear(&options->env); |
| strvec_clear(&options->args); |
| } |
| |
| int run_hooks_opt(struct repository *r, const char *hook_name, |
| struct run_hooks_opt *options) |
| { |
| struct strbuf abs_path = STRBUF_INIT; |
| struct hook_cb_data cb_data = { |
| .rc = 0, |
| .hook_name = hook_name, |
| .options = options, |
| }; |
| const char *const hook_path = find_hook(r, hook_name); |
| int ret = 0; |
| const struct run_process_parallel_opts opts = { |
| .tr2_category = "hook", |
| .tr2_label = hook_name, |
| |
| .processes = 1, |
| .ungroup = 1, |
| |
| .get_next_task = pick_next_hook, |
| .start_failure = notify_start_failure, |
| .task_finished = notify_hook_finished, |
| |
| .data = &cb_data, |
| }; |
| |
| if (!options) |
| BUG("a struct run_hooks_opt must be provided to run_hooks"); |
| |
| if (options->invoked_hook) |
| *options->invoked_hook = 0; |
| |
| if (!hook_path && !options->error_if_missing) |
| goto cleanup; |
| |
| if (!hook_path) { |
| ret = error("cannot find a hook named %s", hook_name); |
| goto cleanup; |
| } |
| |
| cb_data.hook_path = hook_path; |
| if (options->dir) { |
| strbuf_add_absolute_path(&abs_path, hook_path); |
| cb_data.hook_path = abs_path.buf; |
| } |
| |
| run_processes_parallel(&opts); |
| ret = cb_data.rc; |
| cleanup: |
| strbuf_release(&abs_path); |
| run_hooks_opt_clear(options); |
| return ret; |
| } |
| |
| int run_hooks(struct repository *r, const char *hook_name) |
| { |
| struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; |
| |
| return run_hooks_opt(r, hook_name, &opt); |
| } |
| |
| int run_hooks_l(struct repository *r, const char *hook_name, ...) |
| { |
| struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; |
| va_list ap; |
| const char *arg; |
| |
| va_start(ap, hook_name); |
| while ((arg = va_arg(ap, const char *))) |
| strvec_push(&opt.args, arg); |
| va_end(ap); |
| |
| return run_hooks_opt(r, hook_name, &opt); |
| } |