3 # modified: 2010-09-01 and on by tzz@lifelogs.com
5 # Use the email address of the author of the last commit.
6 # This fails if the commit is on a branch.
7 export USER_EMAIL=$(git log -1 --format=format:%ce HEAD)
8 export USER_NAME=$(git log -1 --format=format:%cn HEAD)
10 # the remainder is the standard git-core post-receive-email with some changes:
12 # - USER_EMAIL and USER_NAME are used in the header
13 # - the update message is after the diff
14 # - without annotations, we use `git log --format=oneline' to generate the change summary (joining multiples with semicolons)
15 # - the subject is shorter
17 # Copyright (c) 2007 Andy Parkins
19 # An example hook script to mail out commit update information. This hook
20 # sends emails listing new revisions to the repository introduced by the
21 # change being reported. The rule is that (for branch updates) each commit
22 # will appear on one email and one email only.
24 # This hook is stored in the contrib/hooks directory. Your distribution
25 # will have put this somewhere standard. You should make this script
26 # executable then link to it in the repository you would like to use it in.
27 # For example, on debian the hook is stored in
28 # /usr/share/doc/git-core/contrib/hooks/post-receive-email:
30 # chmod a+x post-receive-email
31 # cd /path/to/your/repository.git
32 # ln -sf /usr/share/doc/git-core/contrib/hooks/post-receive-email hooks/post-receive
34 # This hook script assumes it is enabled on the central repository of a
35 # project, with all users pushing only to it and not between each other. It
36 # will still work if you don't operate in that style, but it would become
37 # possible for the email to be from someone other than the person doing the
43 # This is the list that all pushes will go to; leave it blank to not send
44 # emails for every ref update.
46 # This is the list that all pushes of annotated tags will go to. Leave it
47 # blank to default to the mailinglist field. The announce emails lists
48 # the short log summary of the changes since the last annotated tag.
49 # hooks.envelopesender
50 # If set then the -f option is passed to sendmail to allow the envelope
51 # sender address to be set
53 # All emails have their subjects prefixed with this prefix, or "[SCM]"
54 # if emailprefix is unset, to aid filtering
56 # The shell command used to format each revision in the email, with
57 # "%s" replaced with the commit id. Defaults to "git rev-list -1
58 # --pretty %s", displaying the commit id, author, date and log
59 # message. To list full patches separated by a blank line, you
60 # could set this to "git show -C %s; echo".
61 # To list a gitweb/cgit URL *and* a full patch for each change set, use this:
62 # "t=%s; printf 'http://.../?id=%%s' \$t; echo;echo; git show -C \$t; echo"
63 # Be careful if "..." contains things that will be expanded by shell "eval"
68 # All emails include the headers "X-Git-Refname", "X-Git-Oldrev",
69 # "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and
70 # give information for debugging.
73 # ---------------------------- Functions
76 # Top level email generation function. This decides what type of update
77 # this is and calls the appropriate body-generation routine after outputting
80 # Note this function doesn't actually generate any email output, that is
81 # taken care of by the functions it calls:
82 # - generate_email_header
83 # - generate_create_XXXX_email
84 # - generate_update_XXXX_email
85 # - generate_delete_XXXX_email
86 # - generate_email_footer
91 oldrev=$(git rev-parse $1)
92 newrev=$(git rev-parse $2)
99 if expr "$oldrev" : '0*$' >/dev/null
103 if expr "$newrev" : '0*$' >/dev/null
111 # --- Get the revision types
112 newrev_type=$(git cat-file -t $newrev 2> /dev/null)
113 oldrev_type=$(git cat-file -t "$oldrev" 2> /dev/null)
114 case "$change_type" in
117 rev_type="$newrev_type"
121 rev_type="$oldrev_type"
125 # The revision type tells us what type the commit is, combined with
126 # the location of the ref we can decide between
131 case "$refname","$rev_type" in
135 short_refname=${refname##refs/tags/}
139 refname_type="annotated tag"
140 short_refname=${refname##refs/tags/}
142 if [ -n "$announcerecipients" ]; then
143 recipients="$announcerecipients"
148 refname_type="branch"
149 short_refname=${refname##refs/heads/}
151 refs/remotes/*,commit)
153 refname_type="tracking branch"
154 short_refname=${refname##refs/remotes/}
155 echo >&2 "*** Push-update of tracking branch, $refname"
156 echo >&2 "*** - no email generated."
160 # Anything else (is there anything else?)
161 echo >&2 "*** Unknown type of update to $refname ($rev_type)"
162 echo >&2 "*** - no email generated"
167 # Check if we've got anyone to send to
168 if [ -z "$recipients" ]; then
169 case "$refname_type" in
171 config_name="hooks.announcelist"
174 config_name="hooks.mailinglist"
177 echo >&2 "*** $config_name is not set so no email will be sent"
178 echo >&2 "*** for $refname update $oldrev->$newrev"
183 # The email subject will contain the best description of the ref
184 # that we can build from the parameters
185 describe=$(git describe $rev 2>/dev/null)
186 if [ -z "$describe" ]; then
187 describe=$( (git log --format="%s" $oldrev...$newrev | perl -e'@p = <>; chomp @p; print "=", scalar @p, "= ", join(" ; ", @p)') 2>/dev/null)
190 if [ -z "$describe" ]; then
194 generate_email_header
196 # Call the correct body generation function
198 case "$refname_type" in
199 "tracking branch"|branch)
206 generate_${change_type}_${fn_name}_email
208 generate_email_footer
211 generate_email_header()
213 # --- Email (all stdout will be the email)
216 From: ${USER_NAME} <${USER_EMAIL}>
218 Subject: $emailprefix $refname_type $short_refname ${change_type}d: $describe
219 X-Git-Refname: $refname
220 X-Git-Reftype: $refname_type
221 X-Git-Oldrev: $oldrev
222 X-Git-Newrev: $newrev
227 generate_email_footer()
232 This is an automated email from the git hooks/post-receive script. It was
233 generated because a ref change was pushed to the repository containing
234 the project "$projectdesc".
236 The $refname_type, $short_refname has been ${change_type}d
245 # --------------- Branches
248 # Called for the creation of a branch
250 generate_create_branch_email()
252 # This is a new branch and so oldrev is not valid
253 echo " at $newrev ($newrev_type)"
262 # Called for the change of a pre-existing branch
264 generate_update_branch_email()
267 # 1 --- 2 --- O --- X --- 3 --- 4 --- N
269 # O is $oldrev for $refname
270 # N is $newrev for $refname
271 # X is a revision pointed to by some other ref, for which we may
272 # assume that an email has already been generated.
273 # In this case we want to issue an email containing only revisions
274 # 3, 4, and N. Given (almost) by
276 # git rev-list N ^O --not --all
278 # The reason for the "almost", is that the "--not --all" will take
279 # precedence over the "N", and effectively will translate to
281 # git rev-list N ^O ^X ^N
283 # So, we need to build up the list more carefully. git rev-parse
284 # will generate a list of revs that may be fed into git rev-list.
285 # We can get it to make the "--not --all" part and then filter out
288 # git rev-parse --not --all | grep -v N
290 # Then, using the --stdin switch to git rev-list we have effectively
293 # git rev-list N ^O ^X
295 # This leaves a problem when someone else updates the repository
296 # while this script is running. Their new value of the ref we're
297 # working on would be included in the "--not --all" output; and as
298 # our $newrev would be an ancestor of that commit, it would exclude
299 # all of our commits. What we really want is to exclude the current
300 # value of $refname from the --not list, rather than N itself. So:
302 # git rev-parse --not --all | grep -v $(git rev-parse $refname)
304 # Get's us to something pretty safe (apart from the small time
305 # between refname being read, and git rev-parse running - for that,
309 # Next problem, consider this:
310 # * --- B --- * --- O ($oldrev)
312 # * --- X --- * --- N ($newrev)
314 # That is to say, there is no guarantee that oldrev is a strict
315 # subset of newrev (it would have required a --force, but that's
316 # allowed). So, we can't simply say rev-list $oldrev..$newrev.
317 # Instead we find the common base of the two revs and list from
320 # As above, we need to take into account the presence of X; if
321 # another branch is already in the repository and points at some of
322 # the revisions that we are about to output - we don't want them.
323 # The solution is as before: git rev-parse output filtered.
325 # Finally, tags: 1 --- 2 --- O --- T --- 3 --- 4 --- N
327 # Tags pushed into the repository generate nice shortlog emails that
328 # summarise the commits between them and the previous tag. However,
329 # those emails don't include the full commit messages that we output
330 # for a branch update. Therefore we still want to output revisions
331 # that have been output on a tag email.
333 # Luckily, git rev-parse includes just the tool. Instead of using
334 # "--all" we use "--branches"; this has the added benefit that
335 # "remotes/" will be ignored as well.
337 # List all of the revisions that were removed by this update, in a
338 # fast-forward update, this list will be empty, because rev-list O
339 # ^N is empty. For a non-fast-forward, O ^N is the list of removed
343 for rev in $(git rev-list $newrev..$oldrev)
345 revtype=$(git cat-file -t "$rev")
346 echo " discards $rev ($revtype)"
348 if [ -z "$rev" ]; then
352 # List all the revisions from baserev to newrev in a kind of
353 # "table-of-contents"; note this list can include revisions that
354 # have already had notification emails and is present to show the
355 # full detail of the change from rolling back the old revision to
356 # the base revision and then forward to the new revision
357 for rev in $(git rev-list $oldrev..$newrev)
359 revtype=$(git cat-file -t "$rev")
360 echo " via $rev ($revtype)"
363 if [ "$fast_forward" ]; then
364 echo " from $oldrev ($oldrev_type)"
366 # 1. Existing revisions were removed. In this case newrev
367 # is a subset of oldrev - this is the reverse of a
368 # fast-forward, a rewind
369 # 2. New revisions were added on top of an old revision,
370 # this is a rewind and addition.
372 # (1) certainly happened, (2) possibly. When (2) hasn't
373 # happened, we set a flag to indicate that no log printout
378 # Find the common ancestor of the old and new revisions and
379 # compare it with newrev
380 baserev=$(git merge-base $oldrev $newrev)
382 if [ "$baserev" = "$newrev" ]; then
383 echo "This update discarded existing revisions and left the branch pointing at"
384 echo "a previous point in the repository history."
386 echo " * -- * -- N ($newrev)"
388 echo " O -- O -- O ($oldrev)"
390 echo "The removed revisions are not necessarilly gone - if another reference"
391 echo "still refers to them they will stay in the repository."
394 echo "This update added new revisions after undoing existing revisions. That is"
395 echo "to say, the old revision is not a strict subset of the new revision. This"
396 echo "situation occurs when you --force push a change and generate a repository"
397 echo "containing something like this:"
399 echo " * -- * -- B -- O -- O -- O ($oldrev)"
401 echo " N -- N -- N ($newrev)"
403 echo "When this happens we assume that you've already had alert emails for all"
404 echo "of the O revisions, and so we here report only the revisions in the N"
405 echo "branch from the common base, B."
410 if [ -z "$rewind_only" ]; then
415 # XXX: Need a way of detecting whether git rev-list actually
416 # outputted anything, so that we can issue a "no new
417 # revisions added by this update" message
421 echo "Those revisions listed above that are new to this repository have"
422 echo "not appeared on any other notification email; so we listed those"
423 echo "revisions in full, above."
426 echo "No new revisions were added by this update."
429 # The diffstat is shown from the old revision to the new revision.
430 # This is to show the truth of what happened in this change.
431 # There's no point showing the stat from the base to the new
432 # revision because the base is effectively a random revision at this
433 # point - the user will be interested in what this revision changed
434 # - including the undoing of previous revisions in the case of
435 # non-fast-forward updates.
437 echo "Summary of changes:"
438 git diff-tree --stat --summary --find-copies-harder $oldrev..$newrev
442 # Called for the deletion of a branch
444 generate_delete_branch_email()
449 git show -s --pretty=oneline $oldrev
453 # --------------- Annotated tags
456 # Called for the creation of an annotated tag
458 generate_create_atag_email()
460 echo " at $newrev ($newrev_type)"
466 # Called for the update of an annotated tag (this is probably a rare event
467 # and may not even be allowed)
469 generate_update_atag_email()
471 echo " to $newrev ($newrev_type)"
472 echo " from $oldrev (which is now obsolete)"
478 # Called when an annotated tag is created or changed
480 generate_atag_email()
482 # Use git for-each-ref to pull out the individual fields from the
484 eval $(git for-each-ref --shell --format='
485 tagobject=%(*objectname)
486 tagtype=%(*objecttype)
488 tagged=%(taggerdate)' $refname
491 echo " tagging $tagobject ($tagtype)"
495 # If the tagged object is a commit, then we assume this is a
496 # release, and so we calculate which tag this tag is
498 prevtag=$(git describe --abbrev=0 $newrev^ 2>/dev/null)
500 if [ -n "$prevtag" ]; then
501 echo " replaces $prevtag"
505 echo " length $(git cat-file -s $tagobject) bytes"
508 echo " tagged by $tagger"
514 # Show the content of the tag message; this might contain a change
515 # log or release notes so is worth displaying.
516 git cat-file tag $newrev | sed -e '1,/^$/d'
521 # Only commit tags make sense to have rev-list operations
523 if [ -n "$prevtag" ]; then
524 # Show changes since the previous release
525 git rev-list --pretty=short "$prevtag..$newrev" | git shortlog
527 # No previous tag, show all the changes since time
529 git rev-list --pretty=short $newrev | git shortlog
533 # XXX: Is there anything useful we can do for non-commit
542 # Called for the deletion of an annotated tag
544 generate_delete_atag_email()
549 git show -s --pretty=oneline $oldrev
553 # --------------- General references
556 # Called when any other type of reference is created (most likely a
559 generate_create_general_email()
561 echo " at $newrev ($newrev_type)"
563 generate_general_email
567 # Called when any other type of reference is updated (most likely a
570 generate_update_general_email()
572 echo " to $newrev ($newrev_type)"
575 generate_general_email
579 # Called for creation or update of any other type of reference
581 generate_general_email()
583 # Unannotated tags are more about marking a point than releasing a
584 # version; therefore we don't do the shortlog summary that we do for
585 # annotated tags above - we simply show that the point has been
586 # marked, and print the log message for the marked point for
589 # Note this section also catches any other reference type (although
590 # there aren't any) and deals with them in the same way.
593 if [ "$newrev_type" = "commit" ]; then
595 git show --no-color --root -s --pretty=medium $newrev
598 # What can we do here? The tag marks an object that is not
599 # a commit, so there is no log for us to display. It's
600 # probably not wise to output git cat-file as it could be a
601 # binary blob. We'll just say how big it is
602 echo "$newrev is a $newrev_type, and is $(git cat-file -s $newrev) bytes long."
607 # Called for the deletion of any other type of reference
609 generate_delete_general_email()
614 git show -s --pretty=oneline $oldrev
619 # --------------- Miscellaneous utilities
622 # Show new revisions as the user would like to see them in the email.
626 # This shows all log entries that are not already covered by
627 # another ref - i.e. commits that are now accessible from this
628 # ref that were previously not accessible
629 # (see generate_update_branch_email for the explanation of this
632 # Revision range passed to rev-list differs for new vs. updated
634 if [ "$change_type" = create ]
636 # Show all revisions exclusive to this (new) branch.
639 # Branch update; show revisions not part of $oldrev.
640 revspec=$oldrev..$newrev
643 other_branches=$(git for-each-ref --format='%(refname)' refs/heads/ |
645 git rev-parse --not $other_branches |
646 if [ -z "$custom_showrev" ]
648 git rev-list --pretty --stdin $revspec
650 git rev-list --stdin $revspec |
653 eval $(printf "$custom_showrev" $onerev)
661 if [ -n "$envelopesender" ]; then
662 /usr/sbin/sendmail -t -f "$envelopesender"
664 /usr/sbin/sendmail -t
668 # ---------------------------- main()
671 LOGBEGIN="- Log -----------------------------------------------------------------"
672 LOGEND="-----------------------------------------------------------------------"
675 # Set GIT_DIR either from the working directory, or from the environment
677 GIT_DIR=$(git rev-parse --git-dir 2>/dev/null)
678 if [ -z "$GIT_DIR" ]; then
679 echo >&2 "fatal: post-receive: GIT_DIR not set"
683 projectdesc=$(sed -ne '1p' "$GIT_DIR/description")
684 # Check if the description is unchanged from it's default, and shorten it to
685 # a more manageable length if it is
686 if expr "$projectdesc" : "Unnamed repository.*$" >/dev/null
688 projectdesc="UNNAMED PROJECT"
691 recipients=$(git config hooks.mailinglist)
692 announcerecipients=$(git config hooks.announcelist)
693 envelopesender=$(git config hooks.envelopesender)
694 emailprefix=$(git config hooks.emailprefix || echo '[SCM] ')
695 custom_showrev=$(git config hooks.showrev)
698 # Allow dual mode: run from the command line just like the update hook, or
699 # if no arguments are given then run as a hook script
700 if [ -n "$1" -a -n "$2" -a -n "$3" ]; then
701 # Output to the terminal in command line mode - if someone wanted to
702 # resend an email; they could redirect the output to sendmail
704 PAGER= generate_email $2 $3 $1
706 while read oldrev newrev refname
708 generate_email $oldrev $newrev $refname | send_mail