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
29 # This is the list that all pushes will go to; leave it blank to not send
30 # emails for every ref update.
32 # This is the list that all pushes of annotated tags will go to. Leave it
33 # blank to default to the mailinglist field. The announce emails lists
34 # the short log summary of the changes since the last annotated tag.
35 # hooks.envelopesender
36 # If set then the -f option is passed to sendmail to allow the envelope
37 # sender address to be set
39 # All emails have their subjects prefixed with this prefix, or "[SCM]"
40 # if emailprefix is unset, to aid filtering
44 # All emails include the headers "X-Git-Refname", "X-Git-Oldrev",
45 # "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and
46 # give information for debugging.
49 # ---------------------------- Functions
52 # Top level email generation function. This decides what type of update
53 # this is and calls the appropriate body-generation routine after outputting
56 # Note this function doesn't actually generate any email output, that is
57 # taken care of by the functions it calls:
58 # - generate_email_header
59 # - generate_create_XXXX_email
60 # - generate_update_XXXX_email
61 # - generate_delete_XXXX_email
62 # - generate_email_footer
67 oldrev=$(git rev-parse $1)
68 newrev=$(git rev-parse $2)
75 if expr "$oldrev" : '0*$' >/dev/null
79 if expr "$newrev" : '0*$' >/dev/null
87 # --- Get the revision types
88 newrev_type=$(git cat-file -t $newrev 2> /dev/null)
89 oldrev_type=$(git cat-file -t "$oldrev" 2> /dev/null)
90 case "$change_type" in
93 rev_type="$newrev_type"
97 rev_type="$oldrev_type"
101 # The revision type tells us what type the commit is, combined with
102 # the location of the ref we can decide between
107 case "$refname","$rev_type" in
108 refs/tags/*,commit) # un-annotated tag
110 short_refname=${refname##refs/tags/}
112 refs/tags/*,tag) # annotated tag
113 refname_type="annotated tag"
114 short_refname=${refname##refs/tags/}
116 if [ -n "$announcerecipients" ]; then
117 recipients="$announcerecipients"
120 refs/heads/*,commit) # branch
121 refname_type="branch"
122 short_refname=${refname##refs/heads/}
124 refs/remotes/*,commit) # 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."
131 *) # Anything else (is there anything else?)
132 echo >&2 "*** Unknown type of update to $refname ($rev_type)"
133 echo >&2 "*** - no email generated"
138 # Check if we've got anyone to send to
139 if [ -z "$recipients" ]; then
140 case "$refname_type" in
142 config_name="hooks.announcelist"
145 config_name="hooks.mailinglist"
148 echo >&2 "*** $config_name is not set so no email will be sent"
149 echo >&2 "*** for $refname update $oldrev->$newrev"
154 # The email subject will contain the best description of the ref
155 # that we can build from the parameters
156 describe=$(git describe $rev 2>/dev/null)
157 if [ -z "$describe" ]; then
161 generate_email_header
163 # Call the correct body generation function
165 case "$refname_type" in
166 "tracking branch"|branch)
173 generate_${change_type}_${fn_name}_email
175 generate_email_footer
178 generate_email_header()
180 # --- Email (all stdout will be the email)
181 # optimize output for branch, master
183 if [ "$refname_type" == branch -a "$short_refname" == master ] ; then
186 details="$refname_type, $short_refname,"
189 # git describe format: TagName-NumOfCommitsAfterTag-Hash
190 shortrev=$(echo $describe | awk -F - '{print $NF;}' | cut -b1-8)
194 Subject: ${emailprefix}$projectdesc ${details}${change_type}d. ${shortrev}
195 X-Git-Refname: $refname
196 X-Git-Reftype: $refname_type
197 X-Git-Oldrev: $oldrev
198 X-Git-Newrev: $newrev
200 On $projectdesc, the $refname_type, $short_refname has been ${change_type}d
204 generate_email_footer()
215 # --------------- Branches
218 # Called for the creation of a branch
220 generate_create_branch_email()
222 # This is a new branch and so oldrev is not valid
223 echo " at $newrev ($newrev_type)"
227 # This shows all log entries that are not already covered by
228 # another ref - i.e. commits that are now accessible from this
229 # ref that were previously not accessible
230 # (see generate_update_branch_email for the explanation of this
232 git rev-parse --not --branches | grep -v $(git rev-parse $refname) |
233 git rev-list --pretty --stdin $newrev
238 # Called for the change of a pre-existing branch
240 generate_update_branch_email()
243 # 1 --- 2 --- O --- X --- 3 --- 4 --- N
245 # O is $oldrev for $refname
246 # N is $newrev for $refname
247 # X is a revision pointed to by some other ref, for which we may
248 # assume that an email has already been generated.
249 # In this case we want to issue an email containing only revisions
250 # 3, 4, and N. Given (almost) by
252 # git rev-list N ^O --not --all
254 # The reason for the "almost", is that the "--not --all" will take
255 # precedence over the "N", and effectively will translate to
257 # git rev-list N ^O ^X ^N
259 # So, we need to build up the list more carefully. git rev-parse
260 # will generate a list of revs that may be fed into git rev-list.
261 # We can get it to make the "--not --all" part and then filter out
264 # git rev-parse --not --all | grep -v N
266 # Then, using the --stdin switch to git rev-list we have effectively
269 # git rev-list N ^O ^X
271 # This leaves a problem when someone else updates the repository
272 # while this script is running. Their new value of the ref we're
273 # working on would be included in the "--not --all" output; and as
274 # our $newrev would be an ancestor of that commit, it would exclude
275 # all of our commits. What we really want is to exclude the current
276 # value of $refname from the --not list, rather than N itself. So:
278 # git rev-parse --not --all | grep -v $(git rev-parse $refname)
280 # Get's us to something pretty safe (apart from the small time
281 # between refname being read, and git rev-parse running - for that,
285 # Next problem, consider this:
286 # * --- B --- * --- O ($oldrev)
288 # * --- X --- * --- N ($newrev)
290 # That is to say, there is no guarantee that oldrev is a strict
291 # subset of newrev (it would have required a --force, but that's
292 # allowed). So, we can't simply say rev-list $oldrev..$newrev.
293 # Instead we find the common base of the two revs and list from
296 # As above, we need to take into account the presence of X; if
297 # another branch is already in the repository and points at some of
298 # the revisions that we are about to output - we don't want them.
299 # The solution is as before: git rev-parse output filtered.
301 # Finally, tags: 1 --- 2 --- O --- T --- 3 --- 4 --- N
303 # Tags pushed into the repository generate nice shortlog emails that
304 # summarise the commits between them and the previous tag. However,
305 # those emails don't include the full commit messages that we output
306 # for a branch update. Therefore we still want to output revisions
307 # that have been output on a tag email.
309 # Luckily, git rev-parse includes just the tool. Instead of using
310 # "--all" we use "--branches"; this has the added benefit that
311 # "remotes/" will be ignored as well.
313 # List all of the revisions that were removed by this update, in a
314 # fast forward update, this list will be empty, because rev-list O
315 # ^N is empty. For a non fast forward, O ^N is the list of removed
319 for rev in $(git rev-list $newrev..$oldrev)
321 revtype=$(git cat-file -t "$rev")
322 echo " discards $rev ($revtype)"
324 if [ -z "$rev" ]; then
328 # List all the revisions from baserev to newrev in a kind of
329 # "table-of-contents"; note this list can include revisions that
330 # have already had notification emails and is present to show the
331 # full detail of the change from rolling back the old revision to
332 # the base revision and then forward to the new revision
333 for rev in $(git rev-list $oldrev..$newrev)
335 revtype=$(git cat-file -t "$rev")
336 echo " via $rev ($revtype)"
339 if [ "$fast_forward" ]; then
340 echo " from $oldrev ($oldrev_type)"
342 # 1. Existing revisions were removed. In this case newrev
343 # is a subset of oldrev - this is the reverse of a
344 # fast-forward, a rewind
345 # 2. New revisions were added on top of an old revision,
346 # this is a rewind and addition.
347 # (1) certainly happened, (2) possibly. When (2) hasn't
348 # happened, we set a flag to indicate that no log printout
353 # Find the common ancestor of the old and new revisions and
354 # compare it with newrev
355 baserev=$(git merge-base $oldrev $newrev)
357 if [ "$baserev" = "$newrev" ]; then
358 echo "This update discarded existing revisions and left the branch pointing at"
359 echo "a previous point in the repository history."
361 echo " * -- * -- N ($newrev)"
363 echo " O -- O -- O ($oldrev)"
365 echo "The removed revisions are not necessarilly gone - if another reference"
366 echo "still refers to them they will stay in the repository."
369 echo "This update added new revisions after undoing existing revisions. That is"
370 echo "to say, the old revision is not a strict subset of the new revision. This"
371 echo "situation occurs when you --force push a change and generate a repository"
372 echo "containing something like this:"
374 echo " * -- * -- B -- O -- O -- O ($oldrev)"
376 echo " N -- N -- N ($newrev)"
378 echo "When this happens we assume that you've already had alert emails for all"
379 echo "of the O revisions, and so we here report only the revisions in the N"
380 echo "branch from the common base, B."
385 if [ -z "$rewind_only" ]; then
388 git rev-parse --not --branches | grep -v $(git rev-parse $refname) |
389 git rev-list --pretty --stdin $oldrev..$newrev
391 # XXX: Need a way of detecting whether git rev-list actually
392 # outputted anything, so that we can issue a "no new
393 # revisions added by this update" message
397 echo "No new revisions were added by this update."
400 # The diffstat is shown from the old revision to the new revision.
401 # This is to show the truth of what happened in this change.
402 # There's no point showing the stat from the base to the new
403 # revision because the base is effectively a random revision at this
404 # point - the user will be interested in what this revision changed
405 # - including the undoing of previous revisions in the case of
406 # non-fast forward updates.
408 echo "Summary of changes:"
409 git diff-tree --stat --summary --find-copies-harder $oldrev..$newrev
412 echo "Changes between commits $(cut -b1-8 <<< $oldrev)..$(cut -b1-8 <<< $newrev)"
413 git diff $oldrev..$newrev
417 # Called for the deletion of a branch
419 generate_delete_branch_email()
424 git show -s --pretty=oneline $oldrev
428 # --------------- Annotated tags
431 # Called for the creation of an annotated tag
433 generate_create_atag_email()
435 echo " at $newrev ($newrev_type)"
441 # Called for the update of an annotated tag (this is probably a rare event
442 # and may not even be allowed)
444 generate_update_atag_email()
446 echo " to $newrev ($newrev_type)"
447 echo " from $oldrev (which is now obsolete)"
453 # Called when an annotated tag is created or changed
455 generate_atag_email()
457 # Use git for-each-ref to pull out the individual fields from the tag
458 eval $(git for-each-ref --shell --format='
459 tagobject=%(*objectname)
460 tagtype=%(*objecttype)
462 tagged=%(taggerdate)' $refname
465 echo " tagging $tagobject ($tagtype)"
469 # If the tagged object is a commit, then we assume this is a
470 # release, and so we calculate which tag this tag is
472 prevtag=$(git describe --abbrev=0 $newrev^ 2>/dev/null)
474 if [ -n "$prevtag" ]; then
475 echo " replaces $prevtag"
479 echo " length $(git cat-file -s $tagobject) bytes"
482 echo " tagged by $tagger"
488 # Show the content of the tag message; this might contain a change
489 # log or release notes so is worth displaying.
490 git cat-file tag $newrev | sed -e '1,/^$/d'
495 # Only commit tags make sense to have rev-list operations
497 if [ -n "$prevtag" ]; then
498 # Show changes since the previous release
499 git rev-list --pretty=short "$prevtag..$newrev" | git shortlog
501 # No previous tag, show all the changes since time began
502 git rev-list --pretty=short $newrev | git shortlog
506 # XXX: Is there anything useful we can do for non-commit objects?
514 # Called for the deletion of an annotated tag
516 generate_delete_atag_email()
521 git show -s --pretty=oneline $oldrev
525 # --------------- General references
528 # Called when any other type of reference is created (most likely a
531 generate_create_general_email()
533 echo " at $newrev ($newrev_type)"
535 generate_general_email
539 # Called when any other type of reference is updated (most likely a
542 generate_update_general_email()
544 echo " to $newrev ($newrev_type)"
547 generate_general_email
551 # Called for creation or update of any other type of reference
553 generate_general_email()
555 # Unannotated tags are more about marking a point than releasing a
556 # version; therefore we don't do the shortlog summary that we do for
557 # annotated tags above - we simply show that the point has been
558 # marked, and print the log message for the marked point for
561 # Note this section also catches any other reference type (although
562 # there aren't any) and deals with them in the same way.
565 if [ "$newrev_type" = "commit" ]; then
567 git show --no-color --root -s $newrev
570 # What can we do here? The tag marks an object that is not
571 # a commit, so there is no log for us to display. It's
572 # probably not wise to output git cat-file as it could be a
573 # binary blob. We'll just say how big it is
574 echo "$newrev is a $newrev_type, and is $(git cat-file -s $newrev) bytes long."
579 # Called for the deletion of any other type of reference
581 generate_delete_general_email()
586 git show -s --pretty=oneline $oldrev
592 COMMITTER=$(git-for-each-ref --format='%(committer)' --sort=-committerdate count=1 refs/heads)
593 COMMITTERNAME=$(cut -d'<' -f1 <<< $COMMITTER)
594 if [ -n "$envelopesender" ] ; then
595 COMMITTERMAIL=$envelopesender
597 COMMITTERMAIL=$(cut -d'<' -f2 <<< $COMMITTER |cut -d'>' -f1)
599 /usr/sbin/sendmail -t -f "$COMMITTERMAIL" -F "$COMMITTERNAME"
602 # ---------------------------- main()
605 LOGBEGIN="-----------------------------------------------------------------------"
606 LOGEND="-----------------------------------------------------------------------"
609 # Set GIT_DIR either from the working directory, or from the environment
611 GIT_DIR=$(git rev-parse --git-dir 2>/dev/null)
612 if [ -z "$GIT_DIR" ]; then
613 echo >&2 "fatal: post-receive: GIT_DIR not set"
617 if [ -f "$GIT_DIR/description" ]; then
618 projectdesc=$(sed -ne '1p' "$GIT_DIR/description")
620 projectdesc=$(git-config gitweb.description)
622 # Check if the description is unchanged from it's default, and shorten it to
623 # a more manageable length if it is
624 if expr "$projectdesc" : "Unnamed repository.*$" >/dev/null
626 projectdesc="UNNAMED PROJECT"
629 recipients=$(git config hooks.mailinglist)
630 announcerecipients=$(git config hooks.announcelist)
631 envelopesender=$(git config hooks.envelopesender)
632 emailprefix=$(git config hooks.emailprefix || echo '[SCM] ')
635 # Allow dual mode: run from the command line just like the update hook, or
636 # if no arguments are given then run as a hook script
637 if [ -n "$1" -a -n "$2" -a -n "$3" ]; then
638 # Output to the terminal in command line mode - if someone wanted to
639 # resend an email; they could redirect the output to sendmail
641 PAGER= generate_email $2 $3 $1
643 while read oldrev newrev refname
645 generate_email $oldrev $newrev $refname | send_mail