@matheusbsbs / matheus-bagliano / commits / 4557e0de5b
Fork 0

Reimplement emailing part of hooks--update in contrib/hooks/post-receive-email

The update hook is no longer the correct place to generate emails; there is now the hooks/post-receive script which is run automatically after a ref has been updated. This patch is to make use of that new location, and to address some faults in the old update hook. The primary problem in the conversion was that in the update hook, the ref has not actually been changed, but is about to be. In the post-receive hook the ref has already been updated. That meant that where we previously had lines like: git rev-list --not --all would now give the wrong list because "--all" in the post-receive hook includes the ref that we are making the email for. This made it more difficult to show only the new revisions added by this update. The solution is not pretty; however it does work and doesn't need any changes to git-rev-list itself. It also fixes (more accurately: reduces the likelihood of) a nasty race when another update occurs while this script is running. The solution, in short, looks like this (see the source code for a longer explanation) git rev-parse --not --all | grep -v $(git rev-parse $refname) | git rev-list --pretty --stdin $oldrev..$newrev This uses git-rev-parse followed by grep to filter out the revision of the ref in question before it gets to rev-list and inhibits the output of itself. By using $(git rev-parse $revname) rather than $newrev as the filter, it also takes care of the situation where another update to the same ref has been made since $refname was $newrev. The second problem that is addressed is that of tags inhibiting the correct output of an update email. Consider this, with somebranch and sometag pointing at the same revision: git push origin somebranch git push origin sometag That would work fine; the push of the branch would generate an email containing all the new commits introduced by the update, then the push of the tag would generate the shortlog formatted tag email. Now consider: git push origin sometag git push origin somebranch When some branch comes to run its "--not --all" line, it will find sometag, and filter those commits from the email - leaving nothing. That meant that those commits would not show (in full) on any email. The fix is to not use "--all", and instead use "--branches" in the git-rev-parse command. Other changes * Lose the monstrous one-giant-script layout and put things in easy to digest functions. This makes it much easier to find the place you need to change if you wanted to customise the output. I've also tried to write more verbose comments for the same reason. The hook script is big, mainly because of all the different cases that it has to handle, so being easy to navigate is important. * All uses of "git-command" changed to "git command", to cope better if a user decided not to install all the hard links to git; * Cleaned up some of the English in the email * The fact that the receive hook makes the ref available also allows me to use Shawn Pearce's fantastic suggestion that an annotated tag can be parsed with git-for-each-ref. This removes the potentially non-portable use of "<<<" heredocs and the nasty messing around with "date" to convert numbers of seconds UTC to a real date * Deletions are now caught and notified (briefly) * To help with debugging, I've retained the command line mode from the update hook; but made it so that the output is not emailed, it's just printed to the screen. This could then be redirected if the user wanted * Removed the "Hello" from the beginning of the email - it's just noise, and no one seriously has their day made happier by "friendly" programs * The fact that it doesn't rely on repository state as an indicator any more means that it's far more stable in its output; hopefully the same arguments will always generate the same email - even if the repository changes in the future. This means you can easily recreate an email should you want to. * Included Jim Meyering's envelope sender option for the sendmail call * The hook is now so big that it was inappropriate to copy it to every repository by keeping it in the templates directory. Instead, I've put a comment saying to look in contrib/hooks, and given an example of calling the script from that template hook. The advantage of calling the script residing at some fixed location is that if a future package of git included a bug fixed version of the script, that would be picked up automatically, and the user would not have to notice and manually copy the new hook to every repository that uses it. Signed-off-by: Andy Parkins <andyparkins@gmail.com> Signed-off-by: Junio C Hamano <junkio@cox.net>

Andy Parkins committed Mar 30, 2007 at 19:16 UTC 4557e0de5b7ef9d25cc7618ca37ae5f1acf82806
2 files changed +605
contrib/hooks/post-receieve-email new
+588
@@ -0,0 +1,588 @@
1 +#!/bin/sh
2 +#
3 +# Copyright (c) 2007 Andy Parkins
4 +#
5 +# An example hook script to mail out commit update information. This hook sends emails
6 +# listing new revisions to the repository introduced by the change being reported. The
7 +# rule is that (for branch updates) each commit will appear on one email and one email
8 +# only.
9 +#
10 +# This hook is stored in the contrib/hooks directory. Your distribution will have put
11 +# this somewhere standard. You should make this script executable then link to it in
12 +# the repository you would like to use it in. For example, on debian the hook is stored
13 +# in /usr/share/doc/git-core/contrib/hooks/post-receive-email:
14 +#
15 +# chmod a+x post-receive-email
16 +# cd /path/to/your/repository.git
17 +# ln -sf /usr/share/doc/git-core/contrib/hooks/post-receive-email hooks/post-receive
18 +#
19 +# This hook script assumes it is enabled on the central repository of a project, with
20 +# all users pushing only to it and not between each other. It will still work if you
21 +# don't operate in that style, but it would become possible for the email to be from
22 +# someone other than the person doing the push.
23 +#
24 +# Config
25 +# ------
26 +# hooks.mailinglist
27 +# This is the list that all pushes will go to; leave it blank to not send
28 +# emails for every ref update.
29 +# hooks.announcelist
30 +# This is the list that all pushes of annotated tags will go to. Leave it
31 +# blank to default to the mailinglist field. The announce emails lists the
32 +# short log summary of the changes since the last annotated tag.
33 +# hook.envelopesender
34 +# If set then the -f option is passed to sendmail to allow the envelope sender
35 +# address to be set
36 +#
37 +# Notes
38 +# -----
39 +# All emails have their subjects prefixed with "[SCM]" to aid filtering.
40 +# All emails include the headers "X-Git-Refname", "X-Git-Oldrev",
41 +# "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and
42 +# give information for debugging.
43 +#
44 +
45 +# ---------------------------- Functions
46 +
47 +#
48 +# Top level email generation function. This decides what type of update
49 +# this is and calls the appropriate body-generation routine after outputting
50 +# the common header
51 +#
52 +# Note this function doesn't actually generate any email output, that is taken
53 +# care of by the functions it calls:
54 +# - generate_email_header
55 +# - generate_create_XXXX_email
56 +# - generate_update_XXXX_email
57 +# - generate_delete_XXXX_email
58 +# - generate_email_footer
59 +#
60 +generate_email()
61 +{
62 + # --- Arguments
63 + oldrev=$(git rev-parse $1)
64 + newrev=$(git rev-parse $2)
65 + refname="$3"
66 +
67 + # --- Interpret
68 + # 0000->1234 (create)
69 + # 1234->2345 (update)
70 + # 2345->0000 (delete)
71 + if expr "$oldrev" : '0*$' >/dev/null
72 + then
73 + change_type="create"
74 + else
75 + if expr "$newrev" : '0*$' >/dev/null
76 + then
77 + change_type="delete"
78 + else
79 + change_type="update"
80 + fi
81 + fi
82 +
83 + # --- Get the revision types
84 + newrev_type=$(git cat-file -t $newrev 2> /dev/null)
85 + oldrev_type=$(git cat-file -t "$oldrev" 2> /dev/null)
86 + case "$change_type" in
87 + create|update)
88 + rev="$newrev"
89 + rev_type="$newrev_type"
90 + ;;
91 + delete)
92 + rev="$oldrev"
93 + rev_type="$oldrev_type"
94 + ;;
95 + esac
96 +
97 + # The revision type tells us what type the commit is, combined with
98 + # the location of the ref we can decide between
99 + # - working branch
100 + # - tracking branch
101 + # - unannoted tag
102 + # - annotated tag
103 + case "$refname","$rev_type" in
104 + refs/tags/*,commit)
105 + # un-annotated tag
106 + refname_type="tag"
107 + short_refname=${refname##refs/tags/}
108 + ;;
109 + refs/tags/*,tag)
110 + # annotated tag
111 + refname_type="annotated tag"
112 + short_refname=${refname##refs/tags/}
113 + # change recipients
114 + if [ -n "$announcerecipients" ]; then
115 + recipients="$announcerecipients"
116 + fi
117 + ;;
118 + refs/heads/*,commit)
119 + # branch
120 + refname_type="branch"
121 + short_refname=${refname##refs/heads/}
122 + ;;
123 + refs/remotes/*,commit)
124 + # tracking branch
125 + refname_type="tracking branch"
126 + short_refname=${refname##refs/remotes/}
127 + echo >&2 "*** Push-update of tracking branch, $refname"
128 + echo >&2 "*** - no email generated."
129 + exit 0
130 + ;;
131 + *)
132 + # Anything else (is there anything else?)
133 + echo >&2 "*** Unknown type of update to $refname ($rev_type)"
134 + echo >&2 "*** - no email generated"
135 + exit 1
136 + ;;
137 + esac
138 +
139 + # Check if we've got anyone to send to
140 + if [ -z "$recipients" ]; then
141 + echo >&2 "*** hooks.recipients is not set so no email will be sent"
142 + echo >&2 "*** for $refname update $oldrev->$newrev"
143 + exit 0
144 + fi
145 +
146 + # Email parameters
147 + # The committer will be obtained from the latest existing rev; so
148 + # for a deletion it will be the oldrev, for the others, then newrev
149 + committer=$(git show --pretty=full -s $rev | sed -ne "s/^Commit: //p" |
150 + sed -ne 's/\(.*\) </"\1" </p')
151 + # The email subject will contain the best description of the ref
152 + # that we can build from the parameters
153 + describe=$(git describe $rev 2>/dev/null)
154 + if [ -z "$describe" ]; then
155 + describe=$rev
156 + fi
157 +
158 + generate_email_header
159 +
160 + # Call the correct body generation function
161 + fn_name=general
162 + case "$refname_type" in
163 + "tracking branch"|branch)
164 + fn_name=branch
165 + ;;
166 + "annotated tag")
167 + fn_name=atag
168 + ;;
169 + esac
170 + generate_${change_type}_${fn_name}_email
171 +
172 + generate_email_footer
173 +}
174 +
175 +generate_email_header()
176 +{
177 + # --- Email (all stdout will be the email)
178 + # Generate header
179 + cat <<-EOF
180 + From: $committer
181 + To: $recipients
182 + Subject: ${EMAILPREFIX}$projectdesc $refname_type, $short_refname, ${change_type}d. $describe
183 + X-Git-Refname: $refname
184 + X-Git-Reftype: $refname_type
185 + X-Git-Oldrev: $oldrev
186 + X-Git-Newrev: $newrev
187 +
188 + This is an automated email from the git hooks/post-receive script. It was
189 + generated because a ref change was pushed to the repository containing
190 + the project "$projectdesc".
191 +
192 + The $refname_type, $short_refname has been ${change_type}d
193 + EOF
194 +}
195 +
196 +generate_email_footer()
197 +{
198 + cat <<-EOF
199 +
200 +
201 + hooks/post-receive
202 + --
203 + $projectdesc
204 + EOF
205 +}
206 +
207 +# --------------- Branches
208 +
209 +#
210 +# Called for the creation of a branch
211 +#
212 +generate_create_branch_email()
213 +{
214 + # This is a new branch and so oldrev is not valid
215 + echo " at $newrev ($newrev_type)"
216 + echo ""
217 +
218 + echo $LOGBEGIN
219 + # This shows all log entries that are not already covered by
220 + # another ref - i.e. commits that are now accessible from this
221 + # ref that were previously not accessible (see generate_update_branch_email
222 + # for the explanation of this command)
223 + git rev-parse --not --branches | grep -v $(git rev-parse $refname) |
224 + git rev-list --pretty --stdin $newrev
225 + echo $LOGEND
226 +}
227 +
228 +#
229 +# Called for the change of a pre-existing branch
230 +#
231 +generate_update_branch_email()
232 +{
233 + # Consider this:
234 + # 1 --- 2 --- O --- X --- 3 --- 4 --- N
235 + #
236 + # O is $oldrev for $refname
237 + # N is $newrev for $refname
238 + # X is a revision pointed to by some other ref, for which we may
239 + # assume that an email has already been generated.
240 + # In this case we want to issue an email containing only revisions
241 + # 3, 4, and N. Given (almost) by
242 + #
243 + # git-rev-list N ^O --not --all
244 + #
245 + # The reason for the "almost", is that the "--not --all" will take
246 + # precedence over the "N", and effectively will translate to
247 + #
248 + # git-rev-list N ^O ^X ^N
249 + #
250 + # So, we need to build up the list more carefully. git-rev-parse will
251 + # generate a list of revs that may be fed into git-rev-list. We can get
252 + # it to make the "--not --all" part and then filter out the "^N" with:
253 + #
254 + # git-rev-parse --not --all | grep -v N
255 + #
256 + # Then, using the --stdin switch to git-rev-list we have effectively
257 + # manufactured
258 + #
259 + # git-rev-list N ^O ^X
260 + #
261 + # This leaves a problem when someone else updates the repository
262 + # while this script is running. Their new value of the ref we're working
263 + # on would be included in the "--not --all" output; and as our $newrev
264 + # would be an ancestor of that commit, it would exclude all of our
265 + # commits. What we really want is to exclude the current value of
266 + # $refname from the --not list, rather than N itself. So:
267 + #
268 + # git-rev-parse --not --all | grep -v $(git-rev-parse $refname)
269 + #
270 + # Get's us to something pretty safe (apart from the small time between
271 + # refname being read, and git-rev-parse running - for that, I give up)
272 + #
273 + #
274 + # Next problem, consider this:
275 + # * --- B --- * --- O ($oldrev)
276 + # \
277 + # * --- X --- * --- N ($newrev)
278 + #
279 + # That is to say, there is no guarantee that oldrev is a strict subset of
280 + # newrev (it would have required a --force, but that's allowed). So, we
281 + # can't simply say rev-list $oldrev..$newrev. Instead we find the common
282 + # base of the two revs and list from there.
283 + #
284 + # As above, we need to take into account the presence of X; if another
285 + # branch is already in the repository and points at some of the revisions
286 + # that we are about to output - we don't want them. The solution is as
287 + # before: git-rev-parse output filtered.
288 + #
289 + # Finally, tags:
290 + # 1 --- 2 --- O --- T --- 3 --- 4 --- N
291 + #
292 + # Tags pushed into the repository generate nice shortlog emails that
293 + # summarise the commits between them and the previous tag. However,
294 + # those emails don't include the full commit messages that we output
295 + # for a branch update. Therefore we still want to output revisions
296 + # that have been output on a tag email.
297 + #
298 + # Luckily, git-rev-parse includes just the tool. Instead of using "--all"
299 + # we use "--branches"; this has the added benefit that "remotes/" will
300 + # be ignored as well.
301 +
302 + # List all of the revisions that were removed by this update, in a fast forward
303 + # update, this list will be empty, because rev-list O ^N is empty. For a non
304 + # fast forward, O ^N is the list of removed revisions
305 + fastforward=""
306 + rev=""
307 + for rev in $(git rev-list $newrev..$oldrev)
308 + do
309 + revtype=$(git cat-file -t "$rev")
310 + echo " discards $rev ($revtype)"
311 + done
312 + if [ -z "$rev" ]; then
313 + fast_forward=1
314 + fi
315 +
316 + # List all the revisions from baserev to newrev in a kind of
317 + # "table-of-contents"; note this list can include revisions that have
318 + # already had notification emails and is present to show the full detail
319 + # of the change from rolling back the old revision to the base revision and
320 + # then forward to the new revision
321 + for rev in $(git rev-list $oldrev..$newrev)
322 + do
323 + revtype=$(git cat-file -t "$rev")
324 + echo " via $rev ($revtype)"
325 + done
326 +
327 + if [ -z "$fastforward" ]; then
328 + echo " from $oldrev ($oldrev_type)"
329 + else
330 + echo ""
331 + echo "This update added new revisions after undoing old revisions. That is to"
332 + echo "say, the old revision is not a strict subset of the new revision. This"
333 + echo "situation occurs when you --force push a change and generate a"
334 + echo "repository containing something like this:"
335 + echo ""
336 + echo " * -- * -- B -- O -- O -- O ($oldrev)"
337 + echo " \\"
338 + echo " N -- N -- N ($newrev)"
339 + echo ""
340 + echo "When this happens we assume that you've already had alert emails for all"
341 + echo "of the O revisions, and so we here report only the revisions in the N"
342 + echo "branch from the common base, B."
343 + fi
344 +
345 + echo ""
346 + echo "Those revisions listed above that are new to this repository have"
347 + echo "not appeared on any other notification email; so we list those"
348 + echo "revisions in full, below."
349 +
350 + echo ""
351 + echo $LOGBEGIN
352 + git rev-parse --not --branches | grep -v $(git rev-parse $refname) |
353 + git rev-list --pretty --stdin $oldrev..$newrev
354 +
355 + # XXX: Need a way of detecting whether git rev-list actually outputted
356 + # anything, so that we can issue a "no new revisions added by this
357 + # update" message
358 +
359 + echo $LOGEND
360 +
361 + # The diffstat is shown from the old revision to the new revision. This
362 + # is to show the truth of what happened in this change. There's no point
363 + # showing the stat from the base to the new revision because the base
364 + # is effectively a random revision at this point - the user will be
365 + # interested in what this revision changed - including the undoing of
366 + # previous revisions in the case of non-fast forward updates.
367 + echo ""
368 + echo "Summary of changes:"
369 + git diff-tree --stat --summary --find-copies-harder $oldrev..$newrev
370 +}
371 +
372 +#
373 +# Called for the deletion of a branch
374 +#
375 +generate_delete_branch_email()
376 +{
377 + echo " was $oldrev"
378 + echo ""
379 + echo $LOGEND
380 + git show -s --pretty=oneline $oldrev
381 + echo $LOGEND
382 +}
383 +
384 +# --------------- Annotated tags
385 +
386 +#
387 +# Called for the creation of an annotated tag
388 +#
389 +generate_create_atag_email()
390 +{
391 + echo " at $newrev ($newrev_type)"
392 +
393 + generate_atag_email
394 +}
395 +
396 +#
397 +# Called for the update of an annotated tag (this is probably a rare event
398 +# and may not even be allowed)
399 +#
400 +generate_update_atag_email()
401 +{
402 + echo " to $newrev ($newrev_type)"
403 + echo " from $oldrev (which is now obsolete)"
404 +
405 + generate_atag_email
406 +}
407 +
408 +#
409 +# Called when an annotated tag is created or changed
410 +#
411 +generate_atag_email()
412 +{
413 + # Use git-for-each-ref to pull out the individual fields from the tag
414 + eval $(git for-each-ref --shell --format='
415 + tagobject=%(*objectname)
416 + tagtype=%(*objecttype)
417 + tagger=%(taggername)
418 + tagged=%(taggerdate)' $refname
419 + )
420 +
421 + echo " tagging $tagobject ($tagtype)"
422 + case "$tagtype" in
423 + commit)
424 + # If the tagged object is a commit, then we assume this is a
425 + # release, and so we calculate which tag this tag is replacing
426 + prevtag=$(git describe --abbrev=0 $newrev^ 2>/dev/null)
427 +
428 + if [ -n "$prevtag" ]; then
429 + echo " replaces $prevtag"
430 + fi
431 + ;;
432 + *)
433 + echo " length $(git cat-file -s $tagobject) bytes"
434 + ;;
435 + esac
436 + echo " tagged by $tagger"
437 + echo " on $tagged"
438 +
439 + echo ""
440 + echo $LOGBEGIN
441 +
442 + # Show the content of the tag message; this might contain a change log
443 + # or release notes so is worth displaying.
444 + git cat-file tag $newrev | sed -e '1,/^$/d'
445 +
446 + echo ""
447 + case "$tagtype" in
448 + commit)
449 + # Only commit tags make sense to have rev-list operations performed
450 + # on them
451 + if [ -n "$prevtag" ]; then
452 + # Show changes since the previous release
453 + git rev-list --pretty=short "$prevtag..$newrev" | git shortlog
454 + else
455 + # No previous tag, show all the changes since time began
456 + git rev-list --pretty=short $newrev | git shortlog
457 + fi
458 + ;;
459 + *)
460 + # XXX: Is there anything useful we can do for non-commit objects?
461 + ;;
462 + esac
463 +
464 + echo $LOGEND
465 +}
466 +
467 +#
468 +# Called for the deletion of an annotated tag
469 +#
470 +generate_delete_atag_email()
471 +{
472 + echo " was $oldrev"
473 + echo ""
474 + echo $LOGEND
475 + git show -s --pretty=oneline $oldrev
476 + echo $LOGEND
477 +}
478 +
479 +# --------------- General references
480 +
481 +#
482 +# Called when any other type of reference is created (most likely a
483 +# non-annotated tag)
484 +#
485 +generate_create_general_email()
486 +{
487 + echo " at $newrev ($newrev_type)"
488 +
489 + generate_general_email
490 +}
491 +
492 +#
493 +# Called when any other type of reference is updated (most likely a
494 +# non-annotated tag)
495 +#
496 +generate_update_general_email()
497 +{
498 + echo " to $newrev ($newrev_type)"
499 + echo " from $oldrev"
500 +
501 + generate_general_email
502 +}
503 +
504 +#
505 +# Called for creation or update of any other type of reference
506 +#
507 +generate_general_email()
508 +{
509 + # Unannotated tags are more about marking a point than releasing a version;
510 + # therefore we don't do the shortlog summary that we do for annotated tags
511 + # above - we simply show that the point has been marked, and print the log
512 + # message for the marked point for reference purposes
513 + #
514 + # Note this section also catches any other reference type (although there
515 + # aren't any) and deals with them in the same way.
516 +
517 + echo ""
518 + if [ "$newrev_type" = "commit" ]; then
519 + echo $LOGBEGIN
520 + git show --no-color --root -s $newrev
521 + echo $LOGEND
522 + else
523 + # What can we do here? The tag marks an object that is not a commit,
524 + # so there is no log for us to display. It's probably not wise to
525 + # output git-cat-file as it could be a binary blob. We'll just say how
526 + # big it is
527 + echo "$newrev is a $newrev_type, and is $(git cat-file -s $newrev) bytes long."
528 + fi
529 +}
530 +
531 +#
532 +# Called for the deletion of any other type of reference
533 +#
534 +generate_delete_general_email()
535 +{
536 + echo " was $oldrev"
537 + echo ""
538 + echo $LOGEND
539 + git show -s --pretty=oneline $oldrev
540 + echo $LOGEND
541 +}
542 +
543 +# ---------------------------- main()
544 +
545 +# --- Constants
546 +EMAILPREFIX="[SCM] "
547 +LOGBEGIN="- Log -----------------------------------------------------------------"
548 +LOGEND="-----------------------------------------------------------------------"
549 +
550 +# --- Config
551 +# Set GIT_DIR either from the working directory, or from the environment
552 +# variable.
553 +GIT_DIR=$(git rev-parse --git-dir 2>/dev/null)
554 +if [ -z "$GIT_DIR" ]; then
555 + echo >&2 "fatal: post-receive: GIT_DIR not set"
556 + exit 1
557 +fi
558 +
559 +projectdesc=$(sed -e '1p' "$GIT_DIR/description")
560 +# Check if the description is unchanged from it's default, and shorten it to a
561 +# more manageable length if it is
562 +if expr "$projectdesc" : "Unnamed repository.*$" >/dev/null
563 +then
564 + projectdesc="UNNAMED PROJECT"
565 +fi
566 +
567 +recipients=$(git repo-config hooks.mailinglist)
568 +announcerecipients=$(git repo-config hooks.announcelist)
569 +envelopesender=$(git-repo-config hooks.envelopesender)
570 +
571 +# --- Main loop
572 +# Allow dual mode: run from the command line just like the update hook, or if
573 +# no arguments are given then run as a hook script
574 +if [ -n "$1" -a -n "$2" -a -n "$3" ]; then
575 + # Output to the terminal in command line mode - if someone wanted to
576 + # resend an email; they could redirect the output to sendmail themselves
577 + PAGER= generate_email $2 $3 $1
578 +else
579 + if [ -n "$envelopesender" ]; then
580 + envelopesender="-f '$envelopesender'"
581 + fi
582 +
583 + while read oldrev newrev refname
584 + do
585 + generate_email $oldrev $newrev $refname |
586 + /usr/sbin/sendmail -t $envelopesender
587 + done
588 +fi
templates/hooks--post-receive new
+17
@@ -0,0 +1,17 @@
1 +#!/bin/sh
2 +#
3 +# An example hook script for the post-receive event
4 +#
5 +# This script is run after receive-pack has accepted a pack and the
6 +# repository has been updated. It is passed arguments in through stdin
7 +# in the form
8 +# <oldrev> <newrev> <refname>
9 +# For example:
10 +# aa453216d1b3e49e7f6f98441fa56946ddcd6a20 68f7abf4e6f922807889f52bc043ecd31b79f814 refs/heads/master
11 +#
12 +# see contrib/hooks/ for an sample, or uncomment the next line (on debian)
13 +#
14 +
15 +
16 +#. /usr/share/doc/git-core/contrib/hooks/post-receive-email
17 +