3 # modified: 2010-09-01 and on by tzz@lifelogs.com
5 # the remainder is the standard git-core post-receive-email with some changes:
7 # - USER_EMAIL and USER_NAME are used in the header
8 # - the update message is after the diff
9 # - without annotations, we use `git log --format=oneline' to generate the change summary (joining multiples with semicolons)
10 # - the subject is shorter
12 # Copyright (c) 2007 Andy Parkins
14 # An example hook script to mail out commit update information. This hook
15 # sends emails listing new revisions to the repository introduced by the
16 # change being reported. The rule is that (for branch updates) each commit
17 # will appear on one email and one email only.
19 # This hook is stored in the contrib/hooks directory. Your distribution
20 # will have put this somewhere standard. You should make this script
21 # executable then link to it in the repository you would like to use it in.
22 # For example, on debian the hook is stored in
23 # /usr/share/doc/git-core/contrib/hooks/post-receive-email:
25 # chmod a+x post-receive-email
26 # cd /path/to/your/repository.git
27 # ln -sf /usr/share/doc/git-core/contrib/hooks/post-receive-email hooks/post-receive
29 # This hook script assumes it is enabled on the central repository of a
30 # project, with all users pushing only to it and not between each other. It
31 # will still work if you don't operate in that style, but it would become
32 # possible for the email to be from someone other than the person doing the
38 # This is the list that all pushes will go to; leave it blank to not send
39 # emails for every ref update.
41 # This is the list that all pushes of annotated tags will go to. Leave it
42 # blank to default to the mailinglist field. The announce emails lists
43 # the short log summary of the changes since the last annotated tag.
44 # hooks.envelopesender
45 # If set then the -f option is passed to sendmail to allow the envelope
46 # sender address to be set
48 # All emails have their subjects prefixed with this prefix, or "[SCM]"
49 # if emailprefix is unset, to aid filtering
51 # The shell command used to format each revision in the email, with
52 # "%s" replaced with the commit id. Defaults to "git rev-list -1
53 # --pretty %s", displaying the commit id, author, date and log
54 # message. To list full patches separated by a blank line, you
55 # could set this to "git show -C %s; echo".
56 # To list a gitweb/cgit URL *and* a full patch for each change set, use this:
57 # "t=%s; printf 'http://.../?id=%%s' \$t; echo;echo; git show -C \$t; echo"
58 # Be careful if "..." contains things that will be expanded by shell "eval"
63 # All emails include the headers "X-Git-Refname", "X-Git-Oldrev",
64 # "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and
65 # give information for debugging.
68 # ---------------------------- Functions
71 # Top level email generation function. This decides what type of update
72 # this is and calls the appropriate body-generation routine after outputting
75 # Note this function doesn't actually generate any email output, that is
76 # taken care of by the functions it calls:
77 # - generate_email_header
78 # - generate_create_XXXX_email
79 # - generate_update_XXXX_email
80 # - generate_delete_XXXX_email
81 # - generate_email_footer
86 oldrev=$(git rev-parse $1)
87 newrev=$(git rev-parse $2)
94 if expr "$oldrev" : '0*$' >/dev/null
98 if expr "$newrev" : '0*$' >/dev/null
106 # --- Get the revision types
107 newrev_type=$(git cat-file -t $newrev 2> /dev/null)
108 oldrev_type=$(git cat-file -t "$oldrev" 2> /dev/null)
109 case "$change_type" in
112 rev_type="$newrev_type"
116 rev_type="$oldrev_type"
120 # The revision type tells us what type the commit is, combined with
121 # the location of the ref we can decide between
126 case "$refname","$rev_type" in
130 short_refname=${refname##refs/tags/}
134 refname_type="annotated tag"
135 short_refname=${refname##refs/tags/}
137 if [ -n "$announcerecipients" ]; then
138 recipients="$announcerecipients"
143 refname_type="branch"
144 short_refname=${refname##refs/heads/}
146 refs/remotes/*,commit)
148 refname_type="tracking branch"
149 short_refname=${refname##refs/remotes/}
150 echo >&2 "*** Push-update of tracking branch, $refname"
151 echo >&2 "*** - no email generated."
155 # Anything else (is there anything else?)
156 echo >&2 "*** Unknown type of update to $refname ($rev_type)"
157 echo >&2 "*** - no email generated"
162 # Check if we've got anyone to send to
163 if [ -z "$recipients" ]; then
164 case "$refname_type" in
166 config_name="hooks.announcelist"
169 config_name="hooks.mailinglist"
172 echo >&2 "*** $config_name is not set so no email will be sent"
173 echo >&2 "*** for $refname update $oldrev->$newrev"
178 # The email subject will contain the best description of the ref
179 # that we can build from the parameters
180 describe_commit=$( (git log --format="%s" $oldrev...$newrev | perl -e'@p = <>; chomp @p; print "=", scalar @p, "= ", join(" ; ", @p)') 2>/dev/null)
181 describe_last=$(git describe $rev 2>/dev/null)
183 if [ -z "$describe_last" ]; then
184 describe=$describe_commit
186 describe="$describe_last $describe_commit"
189 if [ -z "$describe" ]; then
193 generate_email_header
195 # Call the correct body generation function
197 case "$refname_type" in
198 "tracking branch"|branch)
205 generate_${change_type}_${fn_name}_email
207 generate_email_footer
210 generate_email_header()
213 # Use the email address of the author of the last commit.
214 export USER_EMAIL=$(git log -1 $short_refname --format=format:%ce HEAD)
215 export USER_NAME=$(git log -1 $short_refname --format=format:%cn HEAD)
217 # --- Email (all stdout will be the email)
220 From: ${USER_NAME} <${USER_EMAIL}>
222 Subject: $emailprefix $refname_type $short_refname ${change_type}d: $describe
223 X-Git-Refname: $refname
224 X-Git-Reftype: $refname_type
225 X-Git-Oldrev: $oldrev
226 X-Git-Newrev: $newrev
231 generate_email_footer()
236 This is an automated email from the git hooks/post-receive script. It was
237 generated because a ref change was pushed to the repository containing
238 the project "$projectdesc".
240 The $refname_type, $short_refname has been ${change_type}d
249 # --------------- Branches
252 # Called for the creation of a branch
254 generate_create_branch_email()
256 # This is a new branch and so oldrev is not valid
257 echo " at $newrev ($newrev_type)"
266 # Called for the change of a pre-existing branch
268 generate_update_branch_email()
271 # 1 --- 2 --- O --- X --- 3 --- 4 --- N
273 # O is $oldrev for $refname
274 # N is $newrev for $refname
275 # X is a revision pointed to by some other ref, for which we may
276 # assume that an email has already been generated.
277 # In this case we want to issue an email containing only revisions
278 # 3, 4, and N. Given (almost) by
280 # git rev-list N ^O --not --all
282 # The reason for the "almost", is that the "--not --all" will take
283 # precedence over the "N", and effectively will translate to
285 # git rev-list N ^O ^X ^N
287 # So, we need to build up the list more carefully. git rev-parse
288 # will generate a list of revs that may be fed into git rev-list.
289 # We can get it to make the "--not --all" part and then filter out
292 # git rev-parse --not --all | grep -v N
294 # Then, using the --stdin switch to git rev-list we have effectively
297 # git rev-list N ^O ^X
299 # This leaves a problem when someone else updates the repository
300 # while this script is running. Their new value of the ref we're
301 # working on would be included in the "--not --all" output; and as
302 # our $newrev would be an ancestor of that commit, it would exclude
303 # all of our commits. What we really want is to exclude the current
304 # value of $refname from the --not list, rather than N itself. So:
306 # git rev-parse --not --all | grep -v $(git rev-parse $refname)
308 # Get's us to something pretty safe (apart from the small time
309 # between refname being read, and git rev-parse running - for that,
313 # Next problem, consider this:
314 # * --- B --- * --- O ($oldrev)
316 # * --- X --- * --- N ($newrev)
318 # That is to say, there is no guarantee that oldrev is a strict
319 # subset of newrev (it would have required a --force, but that's
320 # allowed). So, we can't simply say rev-list $oldrev..$newrev.
321 # Instead we find the common base of the two revs and list from
324 # As above, we need to take into account the presence of X; if
325 # another branch is already in the repository and points at some of
326 # the revisions that we are about to output - we don't want them.
327 # The solution is as before: git rev-parse output filtered.
329 # Finally, tags: 1 --- 2 --- O --- T --- 3 --- 4 --- N
331 # Tags pushed into the repository generate nice shortlog emails that
332 # summarise the commits between them and the previous tag. However,
333 # those emails don't include the full commit messages that we output
334 # for a branch update. Therefore we still want to output revisions
335 # that have been output on a tag email.
337 # Luckily, git rev-parse includes just the tool. Instead of using
338 # "--all" we use "--branches"; this has the added benefit that
339 # "remotes/" will be ignored as well.
341 # List all of the revisions that were removed by this update, in a
342 # fast-forward update, this list will be empty, because rev-list O
343 # ^N is empty. For a non-fast-forward, O ^N is the list of removed
347 for rev in $(git rev-list $newrev..$oldrev)
349 revtype=$(git cat-file -t "$rev")
350 echo " discards $rev ($revtype)"
352 if [ -z "$rev" ]; then
356 # List all the revisions from baserev to newrev in a kind of
357 # "table-of-contents"; note this list can include revisions that
358 # have already had notification emails and is present to show the
359 # full detail of the change from rolling back the old revision to
360 # the base revision and then forward to the new revision
361 for rev in $(git rev-list $oldrev..$newrev)
363 revtype=$(git cat-file -t "$rev")
364 echo " via $rev ($revtype)"
367 if [ "$fast_forward" ]; then
368 echo " from $oldrev ($oldrev_type)"
370 # 1. Existing revisions were removed. In this case newrev
371 # is a subset of oldrev - this is the reverse of a
372 # fast-forward, a rewind
373 # 2. New revisions were added on top of an old revision,
374 # this is a rewind and addition.
376 # (1) certainly happened, (2) possibly. When (2) hasn't
377 # happened, we set a flag to indicate that no log printout
382 # Find the common ancestor of the old and new revisions and
383 # compare it with newrev
384 baserev=$(git merge-base $oldrev $newrev)
386 if [ "$baserev" = "$newrev" ]; then
387 echo "This update discarded existing revisions and left the branch pointing at"
388 echo "a previous point in the repository history."
390 echo " * -- * -- N ($newrev)"
392 echo " O -- O -- O ($oldrev)"
394 echo "The removed revisions are not necessarilly gone - if another reference"
395 echo "still refers to them they will stay in the repository."
398 echo "This update added new revisions after undoing existing revisions. That is"
399 echo "to say, the old revision is not a strict subset of the new revision. This"
400 echo "situation occurs when you --force push a change and generate a repository"
401 echo "containing something like this:"
403 echo " * -- * -- B -- O -- O -- O ($oldrev)"
405 echo " N -- N -- N ($newrev)"
407 echo "When this happens we assume that you've already had alert emails for all"
408 echo "of the O revisions, and so we here report only the revisions in the N"
409 echo "branch from the common base, B."
414 if [ -z "$rewind_only" ]; then
419 # XXX: Need a way of detecting whether git rev-list actually
420 # outputted anything, so that we can issue a "no new
421 # revisions added by this update" message
425 echo "Those revisions listed above that are new to this repository have"
426 echo "not appeared on any other notification email; so we listed those"
427 echo "revisions in full, above."
430 echo "No new revisions were added by this update."
433 # The diffstat is shown from the old revision to the new revision.
434 # This is to show the truth of what happened in this change.
435 # There's no point showing the stat from the base to the new
436 # revision because the base is effectively a random revision at this
437 # point - the user will be interested in what this revision changed
438 # - including the undoing of previous revisions in the case of
439 # non-fast-forward updates.
441 echo "Summary of changes:"
442 git diff-tree --stat --summary --find-copies-harder $oldrev..$newrev
446 # Called for the deletion of a branch
448 generate_delete_branch_email()
453 git show -s --pretty=oneline $oldrev
457 # --------------- Annotated tags
460 # Called for the creation of an annotated tag
462 generate_create_atag_email()
464 echo " at $newrev ($newrev_type)"
470 # Called for the update of an annotated tag (this is probably a rare event
471 # and may not even be allowed)
473 generate_update_atag_email()
475 echo " to $newrev ($newrev_type)"
476 echo " from $oldrev (which is now obsolete)"
482 # Called when an annotated tag is created or changed
484 generate_atag_email()
486 # Use git for-each-ref to pull out the individual fields from the
488 eval $(git for-each-ref --shell --format='
489 tagobject=%(*objectname)
490 tagtype=%(*objecttype)
492 tagged=%(taggerdate)' $refname
495 echo " tagging $tagobject ($tagtype)"
499 # If the tagged object is a commit, then we assume this is a
500 # release, and so we calculate which tag this tag is
502 prevtag=$(git describe --abbrev=0 $newrev^ 2>/dev/null)
504 if [ -n "$prevtag" ]; then
505 echo " replaces $prevtag"
509 echo " length $(git cat-file -s $tagobject) bytes"
512 echo " tagged by $tagger"
518 # Show the content of the tag message; this might contain a change
519 # log or release notes so is worth displaying.
520 git cat-file tag $newrev | sed -e '1,/^$/d'
525 # Only commit tags make sense to have rev-list operations
527 if [ -n "$prevtag" ]; then
528 # Show changes since the previous release
529 git rev-list --pretty=short "$prevtag..$newrev" | git shortlog
531 # No previous tag, show all the changes since time
533 git rev-list --pretty=short $newrev | git shortlog
537 # XXX: Is there anything useful we can do for non-commit
546 # Called for the deletion of an annotated tag
548 generate_delete_atag_email()
553 git show -s --pretty=oneline $oldrev
557 # --------------- General references
560 # Called when any other type of reference is created (most likely a
563 generate_create_general_email()
565 echo " at $newrev ($newrev_type)"
567 generate_general_email
571 # Called when any other type of reference is updated (most likely a
574 generate_update_general_email()
576 echo " to $newrev ($newrev_type)"
579 generate_general_email
583 # Called for creation or update of any other type of reference
585 generate_general_email()
587 # Unannotated tags are more about marking a point than releasing a
588 # version; therefore we don't do the shortlog summary that we do for
589 # annotated tags above - we simply show that the point has been
590 # marked, and print the log message for the marked point for
593 # Note this section also catches any other reference type (although
594 # there aren't any) and deals with them in the same way.
597 if [ "$newrev_type" = "commit" ]; then
599 git show --no-color --root -s --pretty=medium $newrev
602 # What can we do here? The tag marks an object that is not
603 # a commit, so there is no log for us to display. It's
604 # probably not wise to output git cat-file as it could be a
605 # binary blob. We'll just say how big it is
606 echo "$newrev is a $newrev_type, and is $(git cat-file -s $newrev) bytes long."
611 # Called for the deletion of any other type of reference
613 generate_delete_general_email()
618 git show -s --pretty=oneline $oldrev
623 # --------------- Miscellaneous utilities
626 # Show new revisions as the user would like to see them in the email.
630 # This shows all log entries that are not already covered by
631 # another ref - i.e. commits that are now accessible from this
632 # ref that were previously not accessible
633 # (see generate_update_branch_email for the explanation of this
636 # Revision range passed to rev-list differs for new vs. updated
638 if [ "$change_type" = create ]
640 # Show all revisions exclusive to this (new) branch.
643 # Branch update; show revisions not part of $oldrev.
644 revspec=$oldrev..$newrev
647 other_branches=$(git for-each-ref --format='%(refname)' refs/heads/ |
649 git rev-parse --not $other_branches |
650 if [ -z "$custom_showrev" ]
652 git rev-list --pretty --stdin $revspec
654 git rev-list --stdin $revspec |
657 eval $(printf "$custom_showrev" $onerev)
665 if [ -n "$envelopesender" ]; then
666 /usr/sbin/sendmail -t -f "$envelopesender"
668 /usr/sbin/sendmail -t
672 # ---------------------------- main()
675 LOGBEGIN="- Log -----------------------------------------------------------------"
676 LOGEND="-----------------------------------------------------------------------"
679 # Set GIT_DIR either from the working directory, or from the environment
681 GIT_DIR=$(git rev-parse --git-dir 2>/dev/null)
682 if [ -z "$GIT_DIR" ]; then
683 echo >&2 "fatal: post-receive: GIT_DIR not set"
687 projectdesc=$(sed -ne '1p' "$GIT_DIR/description")
688 # Check if the description is unchanged from it's default, and shorten it to
689 # a more manageable length if it is
690 if expr "$projectdesc" : "Unnamed repository.*$" >/dev/null
692 projectdesc="UNNAMED PROJECT"
695 recipients=$(git config hooks.mailinglist)
696 announcerecipients=$(git config hooks.announcelist)
697 envelopesender=$(git config hooks.envelopesender)
698 emailprefix=$(git config hooks.emailprefix || echo '[SCM] ')
699 custom_showrev=$(git config hooks.showrev)
702 # Allow dual mode: run from the command line just like the update hook, or
703 # if no arguments are given then run as a hook script
704 if [ -n "$1" -a -n "$2" -a -n "$3" ]; then
705 # Output to the terminal in command line mode - if someone wanted to
706 # resend an email; they could redirect the output to sendmail
708 PAGER= generate_email $2 $3 $1
710 while read oldrev newrev refname
712 generate_email $oldrev $newrev $refname | send_mail