3 # Copyright (c) 2007 Andy Parkins
5 # An example hook script to mail out commit update information. This hook
6 # sends emails listing new revisions to the repository introduced by the
7 # change being reported. The rule is that (for branch updates) each commit
8 # will appear on one email and one email only.
10 # This hook is stored in the contrib/hooks directory. Your distribution
11 # will have put this somewhere standard. You should make this script
12 # executable then link to it in the repository you would like to use it in.
13 # For example, on debian the hook is stored in
14 # /usr/share/doc/git-core/contrib/hooks/post-receive-email:
16 # chmod a+x post-receive-email
17 # cd /path/to/your/repository.git
18 # ln -sf /usr/share/doc/git-core/contrib/hooks/post-receive-email hooks/post-receive
20 # This hook script assumes it is enabled on the central repository of a
21 # project, with all users pushing only to it and not between each other. It
22 # will still work if you don't operate in that style, but it would become
23 # possible for the email to be from someone other than the person doing the
26 # To help with debugging and use on pre-v1.5.1 git servers, this script will
27 # also obey the interface of hooks/update, taking its arguments on the
28 # command line. Unfortunately, hooks/update is called once for each ref.
29 # To avoid firing one email per ref, this script just prints its output to
30 # the screen when used in this mode. The output can then be redirected if
36 # This is the list that all pushes will go to; leave it blank to not send
37 # emails for every ref update.
39 # This is the list that all pushes of annotated tags will go to. Leave it
40 # blank to default to the mailinglist field. The announce emails lists
41 # the short log summary of the changes since the last annotated tag.
42 # hooks.envelopesender
43 # If set then the -f option is passed to sendmail to allow the envelope
44 # sender address to be set
46 # All emails have their subjects prefixed with this prefix, or "[SCM]"
47 # if emailprefix is unset, to aid filtering
49 # The shell command used to format each revision in the email, with
50 # "%s" replaced with the commit id. Defaults to "git rev-list -1
51 # --pretty %s", displaying the commit id, author, date and log
52 # message. To list full patches separated by a blank line, you
53 # could set this to "git show -C %s; echo".
54 # To list a gitweb/cgit URL *and* a full patch for each change set, use this:
55 # "t=%s; printf 'http://.../?id=%%s' \$t; echo;echo; git show -C \$t; echo"
56 # Be careful if "..." contains things that will be expanded by shell "eval"
61 # All emails include the headers "X-Git-Refname", "X-Git-Oldrev",
62 # "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and
63 # give information for debugging.
66 # ---------------------------- Functions
69 # Top level email generation function. This decides what type of update
70 # this is and calls the appropriate body-generation routine after outputting
73 # Note this function doesn't actually generate any email output, that is
74 # taken care of by the functions it calls:
75 # - generate_email_header
76 # - generate_create_XXXX_email
77 # - generate_update_XXXX_email
78 # - generate_delete_XXXX_email
79 # - generate_email_footer
84 oldrev=$(git rev-parse $1)
85 newrev=$(git rev-parse $2)
92 if expr "$oldrev" : '0*$' >/dev/null
96 if expr "$newrev" : '0*$' >/dev/null
104 # --- Get the revision types
105 newrev_type=$(git cat-file -t $newrev 2> /dev/null)
106 oldrev_type=$(git cat-file -t "$oldrev" 2> /dev/null)
107 case "$change_type" in
110 rev_type="$newrev_type"
114 rev_type="$oldrev_type"
118 # The revision type tells us what type the commit is, combined with
119 # the location of the ref we can decide between
124 case "$refname","$rev_type" in
128 short_refname=${refname##refs/tags/}
132 refname_type="annotated tag"
133 short_refname=${refname##refs/tags/}
135 if [ -n "$announcerecipients" ]; then
136 recipients="$announcerecipients"
141 refname_type="branch"
142 short_refname=${refname##refs/heads/}
144 refs/remotes/*,commit)
146 refname_type="tracking branch"
147 short_refname=${refname##refs/remotes/}
148 echo >&2 "*** Push-update of tracking branch, $refname"
149 echo >&2 "*** - no email generated."
153 # Anything else (is there anything else?)
154 echo >&2 "*** Unknown type of update to $refname ($rev_type)"
155 echo >&2 "*** - no email generated"
160 # Check if we've got anyone to send to
161 if [ -z "$recipients" ]; then
162 case "$refname_type" in
164 config_name="hooks.announcelist"
167 config_name="hooks.mailinglist"
170 echo >&2 "*** $config_name is not set so no email will be sent"
171 echo >&2 "*** for $refname update $oldrev->$newrev"
176 # The email subject will contain the best description of the ref
177 # that we can build from the parameters
178 describe=$(git describe $rev 2>/dev/null)
179 if [ -z "$describe" ]; then
183 generate_email_header
185 # Call the correct body generation function
187 case "$refname_type" in
188 "tracking branch"|branch)
195 generate_${change_type}_${fn_name}_email
197 generate_email_footer
200 generate_email_header()
202 # --- Email (all stdout will be the email)
206 Subject: ${emailprefix}$projectdesc $refname_type $short_refname ${change_type}d. $describe
207 Content-Type: text/plain; charset=utf-8
208 X-Git-Refname: $refname
209 X-Git-Reftype: $refname_type
210 X-Git-Oldrev: $oldrev
211 X-Git-Newrev: $newrev
213 This is an automated email from the git hooks/post-receive script. It was
214 generated because a ref change was pushed to the repository containing
215 the project "$projectdesc".
217 The $refname_type, $short_refname has been ${change_type}d
221 generate_email_footer()
233 # --------------- Branches
236 # Called for the creation of a branch
238 generate_create_branch_email()
240 # This is a new branch and so oldrev is not valid
241 echo " at $newrev ($newrev_type)"
250 # Called for the change of a pre-existing branch
252 generate_update_branch_email()
255 # 1 --- 2 --- O --- X --- 3 --- 4 --- N
257 # O is $oldrev for $refname
258 # N is $newrev for $refname
259 # X is a revision pointed to by some other ref, for which we may
260 # assume that an email has already been generated.
261 # In this case we want to issue an email containing only revisions
262 # 3, 4, and N. Given (almost) by
264 # git rev-list N ^O --not --all
266 # The reason for the "almost", is that the "--not --all" will take
267 # precedence over the "N", and effectively will translate to
269 # git rev-list N ^O ^X ^N
271 # So, we need to build up the list more carefully. git rev-parse
272 # will generate a list of revs that may be fed into git rev-list.
273 # We can get it to make the "--not --all" part and then filter out
276 # git rev-parse --not --all | grep -v N
278 # Then, using the --stdin switch to git rev-list we have effectively
281 # git rev-list N ^O ^X
283 # This leaves a problem when someone else updates the repository
284 # while this script is running. Their new value of the ref we're
285 # working on would be included in the "--not --all" output; and as
286 # our $newrev would be an ancestor of that commit, it would exclude
287 # all of our commits. What we really want is to exclude the current
288 # value of $refname from the --not list, rather than N itself. So:
290 # git rev-parse --not --all | grep -v $(git rev-parse $refname)
292 # Get's us to something pretty safe (apart from the small time
293 # between refname being read, and git rev-parse running - for that,
297 # Next problem, consider this:
298 # * --- B --- * --- O ($oldrev)
300 # * --- X --- * --- N ($newrev)
302 # That is to say, there is no guarantee that oldrev is a strict
303 # subset of newrev (it would have required a --force, but that's
304 # allowed). So, we can't simply say rev-list $oldrev..$newrev.
305 # Instead we find the common base of the two revs and list from
308 # As above, we need to take into account the presence of X; if
309 # another branch is already in the repository and points at some of
310 # the revisions that we are about to output - we don't want them.
311 # The solution is as before: git rev-parse output filtered.
313 # Finally, tags: 1 --- 2 --- O --- T --- 3 --- 4 --- N
315 # Tags pushed into the repository generate nice shortlog emails that
316 # summarise the commits between them and the previous tag. However,
317 # those emails don't include the full commit messages that we output
318 # for a branch update. Therefore we still want to output revisions
319 # that have been output on a tag email.
321 # Luckily, git rev-parse includes just the tool. Instead of using
322 # "--all" we use "--branches"; this has the added benefit that
323 # "remotes/" will be ignored as well.
325 # List all of the revisions that were removed by this update, in a
326 # fast-forward update, this list will be empty, because rev-list O
327 # ^N is empty. For a non-fast-forward, O ^N is the list of removed
331 for rev in $(git rev-list $newrev..$oldrev)
333 revtype=$(git cat-file -t "$rev")
334 echo " discards $rev ($revtype)"
336 if [ -z "$rev" ]; then
340 # List all the revisions from baserev to newrev in a kind of
341 # "table-of-contents"; note this list can include revisions that
342 # have already had notification emails and is present to show the
343 # full detail of the change from rolling back the old revision to
344 # the base revision and then forward to the new revision
345 for rev in $(git rev-list $oldrev..$newrev)
347 revtype=$(git cat-file -t "$rev")
348 echo " via $rev ($revtype)"
351 if [ "$fast_forward" ]; then
352 echo " from $oldrev ($oldrev_type)"
354 # 1. Existing revisions were removed. In this case newrev
355 # is a subset of oldrev - this is the reverse of a
356 # fast-forward, a rewind
357 # 2. New revisions were added on top of an old revision,
358 # this is a rewind and addition.
360 # (1) certainly happened, (2) possibly. When (2) hasn't
361 # happened, we set a flag to indicate that no log printout
366 # Find the common ancestor of the old and new revisions and
367 # compare it with newrev
368 baserev=$(git merge-base $oldrev $newrev)
370 if [ "$baserev" = "$newrev" ]; then
371 echo "This update discarded existing revisions and left the branch pointing at"
372 echo "a previous point in the repository history."
374 echo " * -- * -- N ($newrev)"
376 echo " O -- O -- O ($oldrev)"
378 echo "The removed revisions are not necessarilly gone - if another reference"
379 echo "still refers to them they will stay in the repository."
382 echo "This update added new revisions after undoing existing revisions. That is"
383 echo "to say, the old revision is not a strict subset of the new revision. This"
384 echo "situation occurs when you --force push a change and generate a repository"
385 echo "containing something like this:"
387 echo " * -- * -- B -- O -- O -- O ($oldrev)"
389 echo " N -- N -- N ($newrev)"
391 echo "When this happens we assume that you've already had alert emails for all"
392 echo "of the O revisions, and so we here report only the revisions in the N"
393 echo "branch from the common base, B."
398 if [ -z "$rewind_only" ]; then
399 echo "Those revisions listed above that are new to this repository have"
400 echo "not appeared on any other notification email; so we list those"
401 echo "revisions in full, below."
407 # XXX: Need a way of detecting whether git rev-list actually
408 # outputted anything, so that we can issue a "no new
409 # revisions added by this update" message
413 echo "No new revisions were added by this update."
416 # The diffstat is shown from the old revision to the new revision.
417 # This is to show the truth of what happened in this change.
418 # There's no point showing the stat from the base to the new
419 # revision because the base is effectively a random revision at this
420 # point - the user will be interested in what this revision changed
421 # - including the undoing of previous revisions in the case of
422 # non-fast-forward updates.
424 echo "Summary of changes:"
425 git diff-tree --stat --summary --find-copies-harder $oldrev..$newrev
429 # Called for the deletion of a branch
431 generate_delete_branch_email()
436 git show -s --pretty=oneline $oldrev
440 # --------------- Annotated tags
443 # Called for the creation of an annotated tag
445 generate_create_atag_email()
447 echo " at $newrev ($newrev_type)"
453 # Called for the update of an annotated tag (this is probably a rare event
454 # and may not even be allowed)
456 generate_update_atag_email()
458 echo " to $newrev ($newrev_type)"
459 echo " from $oldrev (which is now obsolete)"
465 # Called when an annotated tag is created or changed
467 generate_atag_email()
469 # Use git for-each-ref to pull out the individual fields from the
471 eval $(git for-each-ref --shell --format='
472 tagobject=%(*objectname)
473 tagtype=%(*objecttype)
475 tagged=%(taggerdate)' $refname
478 echo " tagging $tagobject ($tagtype)"
482 # If the tagged object is a commit, then we assume this is a
483 # release, and so we calculate which tag this tag is
485 prevtag=$(git describe --abbrev=0 $newrev^ 2>/dev/null)
487 if [ -n "$prevtag" ]; then
488 echo " replaces $prevtag"
492 echo " length $(git cat-file -s $tagobject) bytes"
495 echo " tagged by $tagger"
501 # Show the content of the tag message; this might contain a change
502 # log or release notes so is worth displaying.
503 git cat-file tag $newrev | sed -e '1,/^$/d'
508 # Only commit tags make sense to have rev-list operations
510 if [ -n "$prevtag" ]; then
511 # Show changes since the previous release
512 git rev-list --pretty=short "$prevtag..$newrev" | git shortlog
514 # No previous tag, show all the changes since time
516 git rev-list --pretty=short $newrev | git shortlog
520 # XXX: Is there anything useful we can do for non-commit
529 # Called for the deletion of an annotated tag
531 generate_delete_atag_email()
536 git show -s --pretty=oneline $oldrev
540 # --------------- General references
543 # Called when any other type of reference is created (most likely a
546 generate_create_general_email()
548 echo " at $newrev ($newrev_type)"
550 generate_general_email
554 # Called when any other type of reference is updated (most likely a
557 generate_update_general_email()
559 echo " to $newrev ($newrev_type)"
562 generate_general_email
566 # Called for creation or update of any other type of reference
568 generate_general_email()
570 # Unannotated tags are more about marking a point than releasing a
571 # version; therefore we don't do the shortlog summary that we do for
572 # annotated tags above - we simply show that the point has been
573 # marked, and print the log message for the marked point for
576 # Note this section also catches any other reference type (although
577 # there aren't any) and deals with them in the same way.
580 if [ "$newrev_type" = "commit" ]; then
582 git show --no-color --root -s --pretty=medium $newrev
585 # What can we do here? The tag marks an object that is not
586 # a commit, so there is no log for us to display. It's
587 # probably not wise to output git cat-file as it could be a
588 # binary blob. We'll just say how big it is
589 echo "$newrev is a $newrev_type, and is $(git cat-file -s $newrev) bytes long."
594 # Called for the deletion of any other type of reference
596 generate_delete_general_email()
601 git show -s --pretty=oneline $oldrev
606 # --------------- Miscellaneous utilities
609 # Show new revisions as the user would like to see them in the email.
613 # This shows all log entries that are not already covered by
614 # another ref - i.e. commits that are now accessible from this
615 # ref that were previously not accessible
616 # (see generate_update_branch_email for the explanation of this
619 # Revision range passed to rev-list differs for new vs. updated
621 if [ "$change_type" = create ]
623 # Show all revisions exclusive to this (new) branch.
626 # Branch update; show revisions not part of $oldrev.
627 revspec=$oldrev..$newrev
630 other_branches=$(git for-each-ref --format='%(refname)' refs/heads/ |
632 git rev-parse --not $other_branches |
633 if [ -z "$custom_showrev" ]
635 git rev-list --pretty --stdin $revspec
637 git rev-list --stdin $revspec |
640 eval $(printf "$custom_showrev" $onerev)
648 if [ -n "$envelopesender" ]; then
649 /usr/sbin/sendmail -t -f "$envelopesender"
651 /usr/sbin/sendmail -t
655 # ---------------------------- main()
658 LOGBEGIN="- Log -----------------------------------------------------------------"
659 LOGEND="-----------------------------------------------------------------------"
662 # Set GIT_DIR either from the working directory, or from the environment
664 GIT_DIR=$(git rev-parse --git-dir 2>/dev/null)
665 if [ -z "$GIT_DIR" ]; then
666 echo >&2 "fatal: post-receive: GIT_DIR not set"
670 projectdesc=$(sed -ne '1p' "$GIT_DIR/description")
671 # Check if the description is unchanged from it's default, and shorten it to
672 # a more manageable length if it is
673 if expr "$projectdesc" : "Unnamed repository.*$" >/dev/null
675 projectdesc="UNNAMED PROJECT"
678 recipients=$(git config hooks.mailinglist)
679 announcerecipients=$(git config hooks.announcelist)
680 envelopesender=$(git config hooks.envelopesender)
681 emailprefix=$(git config hooks.emailprefix || echo '[SCM] ')
682 custom_showrev=$(git config hooks.showrev)
685 # Allow dual mode: run from the command line just like the update hook, or
686 # if no arguments are given then run as a hook script
687 if [ -n "$1" -a -n "$2" -a -n "$3" ]; then
688 # Output to the terminal in command line mode - if someone wanted to
689 # resend an email; they could redirect the output to sendmail
691 PAGER= generate_email $2 $3 $1
693 while read oldrev newrev refname
695 generate_email $oldrev $newrev $refname | send_mail