5 # Copyright (c) 2007 Andy Parkins
7 # An example hook script to mail out commit update information. This hook
8 # sends emails listing new revisions to the repository introduced by the
9 # change being reported. The rule is that (for branch updates) each commit
10 # will appear on one email and one email only.
12 # This hook is stored in the contrib/hooks directory. Your distribution
13 # will have put this somewhere standard. You should make this script
14 # executable then link to it in the repository you would like to use it in.
15 # For example, on fedora the hook is stored in
16 # /usr/share/git-core/contrib/hooks/post-receive-email:
18 # chmod a+x post-receive-email
19 # cd /path/to/your/repository.git
20 # ln -sf /usr/share/git-core/contrib/hooks/post-receive-email hooks/post-receive
22 # This hook script assumes it is enabled on the central repository of a
23 # project, with all users pushing only to it and not between each other. It
24 # will still work if you don't operate in that style, but it would become
25 # possible for the email to be from someone other than the person doing the
31 # This is the list that all pushes will go to; leave it blank to not send
32 # emails for every ref update.
34 # This is the list that all pushes of annotated tags will go to. Leave it
35 # blank to default to the mailinglist field. The announce emails lists
36 # the short log summary of the changes since the last annotated tag.
37 # hooks.envelopesender
38 # If set then the -f option is passed to sendmail to allow the envelope
39 # sender address to be set
41 # All emails have their subjects prefixed with this prefix, or "[SCM]"
42 # if emailprefix is unset, to aid filtering
44 # The shell command used to format each revision in the email, with
45 # "%s" replaced with the commit id. Defaults to "git rev-list -1
46 # --pretty %s", displaying the commit id, author, date and log
47 # message. To list full patches separated by a blank line, you
48 # could set this to "git show -C %s; echo".
49 # To list a gitweb/cgit URL *and* a full patch for each change set, use this:
50 # "t=%s; printf 'http://.../?id=%%s' \$t; echo;echo; git show -C \$t; echo"
51 # Be careful if "..." contains things that will be expanded by shell "eval"
56 # All emails include the headers "X-Git-Refname", "X-Git-Oldrev",
57 # "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and
58 # give information for debugging.
61 # ---------------------------- Functions
64 # Top level email generation function. This decides what type of update
65 # this is and calls the appropriate body-generation routine after outputting
68 # Note this function doesn't actually generate any email output, that is
69 # taken care of by the functions it calls:
70 # - generate_email_header
71 # - generate_create_XXXX_email
72 # - generate_update_XXXX_email
73 # - generate_delete_XXXX_email
74 # - generate_email_footer
79 oldrev=$(git rev-parse $1)
80 newrev=$(git rev-parse $2)
87 if expr "$oldrev" : '0*$' >/dev/null
91 if expr "$newrev" : '0*$' >/dev/null
99 # --- Get the revision types
100 newrev_type=$(git cat-file -t $newrev 2> /dev/null)
101 oldrev_type=$(git cat-file -t "$oldrev" 2> /dev/null)
102 case "$change_type" in
105 rev_type="$newrev_type"
109 rev_type="$oldrev_type"
113 # The revision type tells us what type the commit is, combined with
114 # the location of the ref we can decide between
119 case "$refname","$rev_type" in
123 short_refname=${refname##refs/tags/}
127 refname_type="annotated tag"
128 short_refname=${refname##refs/tags/}
130 if [ -n "$announcerecipients" ]; then
131 recipients="$announcerecipients"
136 refname_type="branch"
137 short_refname=${refname##refs/heads/}
139 refs/remotes/*,commit)
141 refname_type="tracking branch"
142 short_refname=${refname##refs/remotes/}
143 echo >&2 "*** Push-update of tracking branch, $refname"
144 echo >&2 "*** - no email generated."
148 # Anything else (is there anything else?)
149 echo >&2 "*** Unknown type of update to $refname ($rev_type)"
150 echo >&2 "*** - no email generated"
155 # Check if we've got anyone to send to
156 if [ -z "$recipients" ]; then
157 case "$refname_type" in
159 config_name="hooks.announcelist"
162 config_name="hooks.mailinglist"
165 echo >&2 "*** $config_name is not set so no email will be sent"
166 echo >&2 "*** for $refname update $oldrev->$newrev"
171 # The email subject will contain the best description of the ref
172 # that we can build from the parameters
173 describe=$(git describe $rev 2>/dev/null)
174 if [ -z "$describe" ]; then
177 # SBCL: Also grab the commit title.
178 title=$(git log -n1 --pretty=format:%s $rev)
179 if [ -z "$title" ]; 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)
205 # SBCL: branch updates get the commit title in the subject
206 if [ "branch" = "$refname_type" ] && [ "update" = "$change_type" ]
208 subject="${emailprefix} $short_refname: $title"
210 subject="${emailprefix} $refname_type $short_refname: ${change_type}d. $describe"
216 X-Git-Refname: $refname
217 X-Git-Reftype: $refname_type
218 X-Git-Oldrev: $oldrev
219 X-Git-Newrev: $newrev
221 The $refname_type "$short_refname" has been ${change_type}d in $projectdesc:
225 generate_email_footer()
237 # --------------- Branches
240 # Called for the creation of a branch
242 generate_create_branch_email()
244 # This is a new branch and so oldrev is not valid
245 echo " at $newrev ($newrev_type)"
254 # Called for the change of a pre-existing branch
256 generate_update_branch_email()
259 # 1 --- 2 --- O --- X --- 3 --- 4 --- N
261 # O is $oldrev for $refname
262 # N is $newrev for $refname
263 # X is a revision pointed to by some other ref, for which we may
264 # assume that an email has already been generated.
265 # In this case we want to issue an email containing only revisions
266 # 3, 4, and N. Given (almost) by
268 # git rev-list N ^O --not --all
270 # The reason for the "almost", is that the "--not --all" will take
271 # precedence over the "N", and effectively will translate to
273 # git rev-list N ^O ^X ^N
275 # So, we need to build up the list more carefully. git rev-parse
276 # will generate a list of revs that may be fed into git rev-list.
277 # We can get it to make the "--not --all" part and then filter out
280 # git rev-parse --not --all | grep -v N
282 # Then, using the --stdin switch to git rev-list we have effectively
285 # git rev-list N ^O ^X
287 # This leaves a problem when someone else updates the repository
288 # while this script is running. Their new value of the ref we're
289 # working on would be included in the "--not --all" output; and as
290 # our $newrev would be an ancestor of that commit, it would exclude
291 # all of our commits. What we really want is to exclude the current
292 # value of $refname from the --not list, rather than N itself. So:
294 # git rev-parse --not --all | grep -v $(git rev-parse $refname)
296 # Get's us to something pretty safe (apart from the small time
297 # between refname being read, and git rev-parse running - for that,
301 # Next problem, consider this:
302 # * --- B --- * --- O ($oldrev)
304 # * --- X --- * --- N ($newrev)
306 # That is to say, there is no guarantee that oldrev is a strict
307 # subset of newrev (it would have required a --force, but that's
308 # allowed). So, we can't simply say rev-list $oldrev..$newrev.
309 # Instead we find the common base of the two revs and list from
312 # As above, we need to take into account the presence of X; if
313 # another branch is already in the repository and points at some of
314 # the revisions that we are about to output - we don't want them.
315 # The solution is as before: git rev-parse output filtered.
317 # Finally, tags: 1 --- 2 --- O --- T --- 3 --- 4 --- N
319 # Tags pushed into the repository generate nice shortlog emails that
320 # summarise the commits between them and the previous tag. However,
321 # those emails don't include the full commit messages that we output
322 # for a branch update. Therefore we still want to output revisions
323 # that have been output on a tag email.
325 # Luckily, git rev-parse includes just the tool. Instead of using
326 # "--all" we use "--branches"; this has the added benefit that
327 # "remotes/" will be ignored as well.
329 # List all of the revisions that were removed by this update, in a
330 # fast-forward update, this list will be empty, because rev-list O
331 # ^N is empty. For a non-fast-forward, O ^N is the list of removed
335 for rev in $(git rev-list $newrev..$oldrev)
337 revtype=$(git cat-file -t "$rev")
338 echo " discards $rev ($revtype)"
340 if [ -z "$rev" ]; then
344 # List all the revisions from baserev to newrev in a kind of
345 # "table-of-contents"; note this list can include revisions that
346 # have already had notification emails and is present to show the
347 # full detail of the change from rolling back the old revision to
348 # the base revision and then forward to the new revision
349 for rev in $(git rev-list $oldrev..$newrev)
351 revtype=$(git cat-file -t "$rev")
352 echo " via $rev ($revtype)"
355 if [ "$fast_forward" ]; then
356 echo " from $oldrev ($oldrev_type)"
358 # 1. Existing revisions were removed. In this case newrev
359 # is a subset of oldrev - this is the reverse of a
360 # fast-forward, a rewind
361 # 2. New revisions were added on top of an old revision,
362 # this is a rewind and addition.
364 # (1) certainly happened, (2) possibly. When (2) hasn't
365 # happened, we set a flag to indicate that no log printout
370 # Find the common ancestor of the old and new revisions and
371 # compare it with newrev
372 baserev=$(git merge-base $oldrev $newrev)
374 if [ "$baserev" = "$newrev" ]; then
375 echo "This update discarded existing revisions and left the branch pointing at"
376 echo "a previous point in the repository history."
378 echo " * -- * -- N ($newrev)"
380 echo " O -- O -- O ($oldrev)"
382 echo "The removed revisions are not necessarilly gone - if another reference"
383 echo "still refers to them they will stay in the repository."
386 echo "This update added new revisions after undoing existing revisions. That is"
387 echo "to say, the old revision is not a strict subset of the new revision. This"
388 echo "situation occurs when you --force push a change and generate a repository"
389 echo "containing something like this:"
391 echo " * -- * -- B -- O -- O -- O ($oldrev)"
393 echo " N -- N -- N ($newrev)"
395 echo "When this happens we assume that you've already had alert emails for all"
396 echo "of the O revisions, and so we here report only the revisions in the N"
397 echo "branch from the common base, B."
402 if [ -z "$rewind_only" ]; then
405 # echo "Those revisions listed above that are new to this repository have"
406 # echo "not appeared on any other notification email; so we list those"
407 # echo "revisions in full, below."
413 # XXX: Need a way of detecting whether git rev-list actually
414 # outputted anything, so that we can issue a "no new
415 # revisions added by this update" message
419 echo "No new revisions were added by this update."
422 # The diffstat is shown from the old revision to the new revision.
423 # This is to show the truth of what happened in this change.
424 # There's no point showing the stat from the base to the new
425 # revision because the base is effectively a random revision at this
426 # point - the user will be interested in what this revision changed
427 # - including the undoing of previous revisions in the case of
428 # non-fast-forward updates.
430 # Silenced for SBCL: we use "git show -p --stat -C %s" to generate
431 # revision information, getting the diffstat between the commit message
432 # and the diff. This would just duplicate that.
435 # echo "Summary of changes:"
436 # git diff-tree --stat --summary --find-copies-harder $oldrev..$newrev
440 # Called for the deletion of a branch
442 generate_delete_branch_email()
447 git show -s --pretty=oneline $oldrev
451 # --------------- Annotated tags
454 # Called for the creation of an annotated tag
456 generate_create_atag_email()
458 echo " at $newrev ($newrev_type)"
464 # Called for the update of an annotated tag (this is probably a rare event
465 # and may not even be allowed)
467 generate_update_atag_email()
469 echo " to $newrev ($newrev_type)"
470 echo " from $oldrev (which is now obsolete)"
476 # Called when an annotated tag is created or changed
478 generate_atag_email()
480 # Use git for-each-ref to pull out the individual fields from the
482 eval $(git for-each-ref --shell --format='
483 tagobject=%(*objectname)
484 tagtype=%(*objecttype)
486 tagged=%(taggerdate)' $refname
489 echo " tagging $tagobject ($tagtype)"
493 # If the tagged object is a commit, then we assume this is a
494 # release, and so we calculate which tag this tag is
496 prevtag=$(git describe --abbrev=0 $newrev^ 2>/dev/null)
498 if [ -n "$prevtag" ]; then
499 echo " replaces $prevtag"
503 echo " length $(git cat-file -s $tagobject) bytes"
506 echo " tagged by $tagger"
512 # Show the content of the tag message; this might contain a change
513 # log or release notes so is worth displaying.
514 git cat-file tag $newrev | sed -e '1,/^$/d'
519 # Only commit tags make sense to have rev-list operations
521 if [ -n "$prevtag" ]; then
522 # Show changes since the previous release
523 git rev-list --pretty=short "$prevtag..$newrev" | git shortlog
525 # No previous tag, show all the changes since time
527 git rev-list --pretty=short $newrev | git shortlog
531 # XXX: Is there anything useful we can do for non-commit
540 # Called for the deletion of an annotated tag
542 generate_delete_atag_email()
547 git show -s --pretty=oneline $oldrev
551 # --------------- General references
554 # Called when any other type of reference is created (most likely a
557 generate_create_general_email()
559 echo " at $newrev ($newrev_type)"
561 generate_general_email
565 # Called when any other type of reference is updated (most likely a
568 generate_update_general_email()
570 echo " to $newrev ($newrev_type)"
573 generate_general_email
577 # Called for creation or update of any other type of reference
579 generate_general_email()
581 # Unannotated tags are more about marking a point than releasing a
582 # version; therefore we don't do the shortlog summary that we do for
583 # annotated tags above - we simply show that the point has been
584 # marked, and print the log message for the marked point for
587 # Note this section also catches any other reference type (although
588 # there aren't any) and deals with them in the same way.
591 if [ "$newrev_type" = "commit" ]; then
593 git show --no-color --root -s --pretty=medium $newrev
596 # What can we do here? The tag marks an object that is not
597 # a commit, so there is no log for us to display. It's
598 # probably not wise to output git cat-file as it could be a
599 # binary blob. We'll just say how big it is
600 echo "$newrev is a $newrev_type, and is $(git cat-file -s $newrev) bytes long."
605 # Called for the deletion of any other type of reference
607 generate_delete_general_email()
612 git show -s --pretty=oneline $oldrev
617 # --------------- Miscellaneous utilities
620 # Show new revisions as the user would like to see them in the email.
624 # This shows all log entries that are not already covered by
625 # another ref - i.e. commits that are now accessible from this
626 # ref that were previously not accessible
627 # (see generate_update_branch_email for the explanation of this
630 # Revision range passed to rev-list differs for new vs. updated
632 if [ "$change_type" = create ]
634 # Show all revisions exclusive to this (new) branch.
637 # Branch update; show revisions not part of $oldrev.
638 revspec=$oldrev..$newrev
641 other_branches=$(git for-each-ref --format='%(refname)' refs/heads/ |
643 # SBCL: show oldest first via --reverse
644 git rev-parse --not $other_branches |
645 if [ -z "$custom_showrev" ]
647 git rev-list --reverse --pretty --stdin $revspec
649 git rev-list --reverse --stdin $revspec |
652 eval $(printf "$custom_showrev" $onerev)
660 if [ -n "$envelopesender" ]; then
661 /usr/sbin/sendmail -t -f "$envelopesender"
663 /usr/sbin/sendmail -t
667 # ---------------------------- main()
670 LOGBEGIN="- Log -----------------------------------------------------------------"
671 LOGEND="-----------------------------------------------------------------------"
674 # Set GIT_DIR either from the working directory, or from the environment
676 GIT_DIR=$(git rev-parse --git-dir 2>/dev/null)
677 if [ -z "$GIT_DIR" ]; then
678 echo >&2 "fatal: post-receive: GIT_DIR not set"
682 projectdesc=$(sed -ne '1p' "$GIT_DIR/description")
683 # Check if the description is unchanged from it's default, and shorten it to
684 # a more manageable length if it is
685 if expr "$projectdesc" : "Unnamed repository.*$" >/dev/null
687 projectdesc="UNNAMED PROJECT"
690 recipients=$(git config hooks.mailinglist)
691 announcerecipients=$(git config hooks.announcelist)
692 envelopesender=$(git config hooks.envelopesender)
693 emailprefix=$(git config hooks.emailprefix || echo '[SCM] ')
694 custom_showrev=$(git config hooks.showrev)
697 # Allow dual mode: run from the command line just like the update hook, or
698 # if no arguments are given then run as a hook script
699 if [ -n "$1" -a -n "$2" -a -n "$3" ]; then
700 # Output to the terminal in command line mode - if someone wanted to
701 # resend an email; they could redirect the output to sendmail
703 PAGER= generate_email $2 $3 $1
705 while read oldrev newrev refname
707 echo "Sending email for $refname: $oldrev -> $newrev"
708 # SBCL KLUDGE: the default script sends one email per
709 # push. We want one per commit. As long as we're
710 # in fast-forward-only world, this should do the
712 if (expr "$oldrev" : '0*$' >/dev/null || # create
713 expr "$newrev" : '0*$' >/dev/null || # delete
714 ! expr "$refname" : "refs/heads/" > /dev/null) # not a branch
717 generate_email $oldrev $newrev $refname | send_mail
719 # Get all revisions from old to new.
720 revlist=$(git rev-list --reverse $oldrev..$newrev)
725 if ($no_merges && ! git rev-parse --verify --quiet "$rev"^2 > /dev/null)
732 # Simple branch update, one mail per commit.
736 generate_email $lastrev $step $refname | send_mail
740 # There's a merge -- just one email.
741 generate_email $oldrev $newrev $refname | send_mail