3 # Based on /usr/share/doc/git-core/contrib/hooks/post-receive-email
5 # Copyright (c) 2007 Andy Parkins
7 # An example hook script to mail out commit update information. This hook sends emails
8 # listing new revisions to the repository introduced by the change being reported. The
9 # rule is that (for branch updates) each commit will appear on one email and one email
12 # This hook is stored in the contrib/hooks directory. Your distribution will have put
13 # this somewhere standard. You should make this script executable then link to it in
14 # the repository you would like to use it in. For example, on debian the hook is stored
15 # in /usr/share/doc/git-core/contrib/hooks/post-receive-email:
17 # chmod a+x post-receive-email
18 # cd /path/to/your/repository.git
19 # ln -sf /usr/share/doc/git-core/contrib/hooks/post-receive-email hooks/post-receive
21 # This hook script assumes it is enabled on the central repository of a project, with
22 # all users pushing only to it and not between each other. It will still work if you
23 # don't operate in that style, but it would become possible for the email to be from
24 # someone other than the person doing the push.
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 the
34 # short log summary of the changes since the last annotated tag.
36 # If set then the -f option is passed to sendmail to allow the envelope sender
41 # All emails have their subjects prefixed with "[SCM]" to aid filtering.
42 # All emails include the headers "X-Git-Refname", "X-Git-Oldrev",
43 # "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and
44 # give information for debugging.
47 # ---------------------------- Functions
50 # Top level email generation function. This decides what type of update
51 # this is and calls the appropriate body-generation routine after outputting
54 # Note this function doesn't actually generate any email output, that is taken
55 # care of by the functions it calls:
56 # - generate_email_header
57 # - generate_create_XXXX_email
58 # - generate_update_XXXX_email
59 # - generate_delete_XXXX_email
60 # - generate_email_footer
66 oldrev=$(git rev-parse $1)
67 newrev=$(git rev-parse $2)
74 if expr "$oldrev" : '0*$' >/dev/null
78 if expr "$newrev" : '0*$' >/dev/null
86 # --- Get the revision types
87 newrev_type=$(git cat-file -t $newrev 2> /dev/null)
88 oldrev_type=$(git cat-file -t "$oldrev" 2> /dev/null)
89 case "$change_type" in
92 rev_type="$newrev_type"
96 rev_type="$oldrev_type"
100 # The revision type tells us what type the commit is, combined with
101 # the location of the ref we can decide between
106 case "$refname","$rev_type" in
110 short_refname=${refname##refs/tags/}
114 refname_type="annotated tag"
115 short_refname=${refname##refs/tags/}
117 if [ -n "$announcerecipients" ]; then
118 recipients="$announcerecipients"
123 refname_type="branch"
124 short_refname=${refname##refs/heads/}
126 refs/remotes/*,commit)
128 refname_type="tracking branch"
129 short_refname=${refname##refs/remotes/}
130 echo >&2 "*** Push-update of tracking branch, $refname"
131 echo >&2 "*** - no email generated."
135 # Anything else (is there anything else?)
136 echo >&2 "*** Unknown type of update to $refname ($rev_type)"
137 echo >&2 "*** - no email generated"
142 # Check if we've got anyone to send to
143 if [ -z "$recipients" ]; then
144 echo >&2 "*** hooks.recipients is not set so no email will be sent"
145 echo >&2 "*** for $refname update $oldrev->$newrev"
150 # The committer will be obtained from the latest existing rev; so
151 # for a deletion it will be the oldrev, for the others, then newrev
152 committer=$(git show --pretty=full -s $rev | sed -ne "s/^Commit: //p" |
153 sed -ne 's/\(.*\) </"\1" </p')
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)
186 Subject: ${EMAILPREFIX}$dir $refname_type, $short_refname, ${change_type}d. $describe
187 X-Git-Refname: $refname
188 X-Git-Reftype: $refname_type
189 X-Git-Oldrev: $oldrev
190 X-Git-Newrev: $newrev
192 $dir : "$projectdesc".
194 The $refname_type, $short_refname has been ${change_type}d
198 generate_email_footer()
209 # --------------- Branches
212 # Called for the creation of a branch
214 generate_create_branch_email()
216 # This is a new branch and so oldrev is not valid
217 echo " at $newrev ($newrev_type)"
221 # This shows all log entries that are not already covered by
222 # another ref - i.e. commits that are now accessible from this
223 # ref that were previously not accessible (see generate_update_branch_email
224 # for the explanation of this command)
225 git rev-parse --not --branches | grep -v $(git rev-parse $refname) |
226 git rev-list --pretty --stdin $newrev
231 # Called for the change of a pre-existing branch
233 generate_update_branch_email()
236 # 1 --- 2 --- O --- X --- 3 --- 4 --- N
238 # O is $oldrev for $refname
239 # N is $newrev for $refname
240 # X is a revision pointed to by some other ref, for which we may
241 # assume that an email has already been generated.
242 # In this case we want to issue an email containing only revisions
243 # 3, 4, and N. Given (almost) by
245 # git-rev-list N ^O --not --all
247 # The reason for the "almost", is that the "--not --all" will take
248 # precedence over the "N", and effectively will translate to
250 # git-rev-list N ^O ^X ^N
252 # So, we need to build up the list more carefully. git-rev-parse will
253 # generate a list of revs that may be fed into git-rev-list. We can get
254 # it to make the "--not --all" part and then filter out the "^N" with:
256 # git-rev-parse --not --all | grep -v N
258 # Then, using the --stdin switch to git-rev-list we have effectively
261 # git-rev-list N ^O ^X
263 # This leaves a problem when someone else updates the repository
264 # while this script is running. Their new value of the ref we're working
265 # on would be included in the "--not --all" output; and as our $newrev
266 # would be an ancestor of that commit, it would exclude all of our
267 # commits. What we really want is to exclude the current value of
268 # $refname from the --not list, rather than N itself. So:
270 # git-rev-parse --not --all | grep -v $(git-rev-parse $refname)
272 # Get's us to something pretty safe (apart from the small time between
273 # refname being read, and git-rev-parse running - for that, I give up)
276 # Next problem, consider this:
277 # * --- B --- * --- O ($oldrev)
279 # * --- X --- * --- N ($newrev)
281 # That is to say, there is no guarantee that oldrev is a strict subset of
282 # newrev (it would have required a --force, but that's allowed). So, we
283 # can't simply say rev-list $oldrev..$newrev. Instead we find the common
284 # base of the two revs and list from there.
286 # As above, we need to take into account the presence of X; if another
287 # branch is already in the repository and points at some of the revisions
288 # that we are about to output - we don't want them. The solution is as
289 # before: git-rev-parse output filtered.
292 # 1 --- 2 --- O --- T --- 3 --- 4 --- N
294 # Tags pushed into the repository generate nice shortlog emails that
295 # summarise the commits between them and the previous tag. However,
296 # those emails don't include the full commit messages that we output
297 # for a branch update. Therefore we still want to output revisions
298 # that have been output on a tag email.
300 # Luckily, git-rev-parse includes just the tool. Instead of using "--all"
301 # we use "--branches"; this has the added benefit that "remotes/" will
302 # be ignored as well.
304 # List all of the revisions that were removed by this update, in a fast forward
305 # update, this list will be empty, because rev-list O ^N is empty. For a non
306 # fast forward, O ^N is the list of removed revisions
309 for rev in $(git rev-list $newrev..$oldrev)
311 revtype=$(git cat-file -t "$rev")
312 echo " discards $rev ($revtype)"
314 if [ -z "$rev" ]; then
318 # List all the revisions from baserev to newrev in a kind of
319 # "table-of-contents"; note this list can include revisions that have
320 # already had notification emails and is present to show the full detail
321 # of the change from rolling back the old revision to the base revision and
322 # then forward to the new revision
323 for rev in $(git rev-list $oldrev..$newrev)
325 revtype=$(git cat-file -t "$rev")
326 echo " via $rev ($revtype)"
329 if [ -z "$fastforward" ]; then
330 echo " from $oldrev ($oldrev_type)"
332 # 1. Existing revisions were removed. In this case newrev is a
333 # subset of oldrev - this is the reverse of a fast-forward,
335 # 2. New revisions were added on top of an old revision, this is
336 # a rewind and addition.
338 # (1) certainly happened, (2) possibly. When (2) hasn't happened,
339 # we set a flag to indicate that no log printout is required.
343 # Find the common ancestor of the old and new revisions and compare
345 baserev=$(git merge-base $oldrev $newrev)
347 if [ "$baserev" = "$newrev" ]; then
348 echo "This update discarded existing revisions and left the branch pointing at"
349 echo "a previous point in the repository history."
351 echo " * -- * -- N ($newrev)"
353 echo " O -- O -- O ($oldrev)"
355 echo "The removed revisions are not necessarilly gone - if another reference"
356 echo "still refers to them they will stay in the repository."
359 echo "This update added new revisions after undoing existing revisions. That is"
360 echo "to say, the old revision is not a strict subset of the new revision. This"
361 echo "situation occurs when you --force push a change and generate a repository"
362 echo "containing something like this:"
364 echo " * -- * -- B -- O -- O -- O ($oldrev)"
366 echo " N -- N -- N ($newrev)"
368 echo "When this happens we assume that you've already had alert emails for all"
369 echo "of the O revisions, and so we here report only the revisions in the N"
370 echo "branch from the common base, B."
376 if [ -z "$rewind_only" ]; then
377 echo "Revisions details."
381 for rev in `git log --pretty=oneline $oldrev..$newrev | perl -e 'while(<>) { push @a, (split)[0] }; print join " ", reverse @a' `
386 git rev-list --pretty -n1 $rev
387 git diff-tree --stat --summary --find-copies-harder $rev | tail -n +2
388 summary_counter=`expr $summary_counter + 1`
392 # XXX: Need a way of detecting whether git rev-list actually outputted
393 # anything, so that we can issue a "no new revisions added by this
398 echo "No new revisions were added by this update."
401 # The diffstat is shown from the old revision to the new revision. This
402 # is to show the truth of what happened in this change. There's no point
403 # showing the stat from the base to the new revision because the base
404 # is effectively a random revision at this point - the user will be
405 # interested in what this revision changed - including the undoing of
406 # previous revisions in the case of non-fast forward updates.
407 if [ $summary_counter -gt 1 ]; then
409 echo "Summary of changes:"
410 git diff-tree --stat --summary --find-copies-harder $oldrev..$newrev
415 # Called for the deletion of a branch
417 generate_delete_branch_email()
422 git show -s --pretty=oneline $oldrev
426 # --------------- Annotated tags
429 # Called for the creation of an annotated tag
431 generate_create_atag_email()
433 echo " at $newrev ($newrev_type)"
439 # Called for the update of an annotated tag (this is probably a rare event
440 # and may not even be allowed)
442 generate_update_atag_email()
444 echo " to $newrev ($newrev_type)"
445 echo " from $oldrev (which is now obsolete)"
451 # Called when an annotated tag is created or changed
453 generate_atag_email()
455 # Use git-for-each-ref to pull out the individual fields from the tag
456 eval $(git for-each-ref --shell --format='
457 tagobject=%(*objectname)
458 tagtype=%(*objecttype)
460 tagged=%(taggerdate)' $refname
463 echo " tagging $tagobject ($tagtype)"
466 # If the tagged object is a commit, then we assume this is a
467 # release, and so we calculate which tag this tag is replacing
468 prevtag=$(git describe --abbrev=0 $newrev^ 2>/dev/null)
470 if [ -n "$prevtag" ]; then
471 echo " replaces $prevtag"
475 echo " length $(git cat-file -s $tagobject) bytes"
478 echo " tagged by $tagger"
484 # Show the content of the tag message; this might contain a change log
485 # or release notes so is worth displaying.
486 git cat-file tag $newrev | sed -e '1,/^$/d'
491 # Only commit tags make sense to have rev-list operations performed
493 if [ -n "$prevtag" ]; then
494 # Show changes since the previous release
495 git rev-list --pretty=short "$prevtag..$newrev" | git shortlog
497 # No previous tag, show all the changes since time began
498 git rev-list --pretty=short $newrev | git shortlog
502 # XXX: Is there anything useful we can do for non-commit objects?
510 # Called for the deletion of an annotated tag
512 generate_delete_atag_email()
517 git show -s --pretty=oneline $oldrev
521 # --------------- General references
524 # Called when any other type of reference is created (most likely a
527 generate_create_general_email()
529 echo " at $newrev ($newrev_type)"
531 generate_general_email
535 # Called when any other type of reference is updated (most likely a
538 generate_update_general_email()
540 echo " to $newrev ($newrev_type)"
543 generate_general_email
547 # Called for creation or update of any other type of reference
549 generate_general_email()
551 # Unannotated tags are more about marking a point than releasing a version;
552 # therefore we don't do the shortlog summary that we do for annotated tags
553 # above - we simply show that the point has been marked, and print the log
554 # message for the marked point for reference purposes
556 # Note this section also catches any other reference type (although there
557 # aren't any) and deals with them in the same way.
560 if [ "$newrev_type" = "commit" ]; then
562 git show --no-color --root -s $newrev
565 # What can we do here? The tag marks an object that is not a commit,
566 # so there is no log for us to display. It's probably not wise to
567 # output git-cat-file as it could be a binary blob. We'll just say how
569 echo "$newrev is a $newrev_type, and is $(git cat-file -s $newrev) bytes long."
574 # Called for the deletion of any other type of reference
576 generate_delete_general_email()
581 git show -s --pretty=oneline $oldrev
585 GITWEB_PUB="http://git.indexdata.com"
586 GITWEB_PRIV="https://gitid.indexdata.com"
588 generate_gitweb_link()
591 proj_dir=`basename $proj_path`
592 gitweb_host=$GITWEB_PUB
593 if echo "$proj_path" | egrep -q "/(private|server)"
594 then gitweb_host=$GITWEB_PRIV
596 echo "$gitweb_host/?p=$proj_dir;a=commitdiff;h=$newrev"
599 # ---------------------------- main()
603 LOGBEGIN="- Log -----------------------------------------------------------------"
604 LOGEND="-----------------------------------------------------------------------"
607 # Set GIT_DIR either from the working directory, or from the environment
609 GIT_DIR=$(git rev-parse --git-dir 2>/dev/null)
610 if [ -z "$GIT_DIR" ]; then
611 echo >&2 "fatal: post-receive: GIT_DIR not set"
615 projectdesc=$(sed -ne '1p' "$GIT_DIR/description")
616 # Check if the description is unchanged from it's default, and shorten it to a
617 # more manageable length if it is
618 if expr "$projectdesc" : "Unnamed repository.*$" >/dev/null
620 projectdesc="UNNAMED PROJECT"
623 recipients=$(git repo-config hooks.mailinglist)
624 announcerecipients=$(git repo-config hooks.announcelist)
625 envelopesender=$(git-repo-config hooks.envelopesender)
628 # Allow dual mode: run from the command line just like the update hook, or if
629 # no arguments are given then run as a hook script
630 if [ -n "$1" -a -n "$2" -a -n "$3" ]; then
631 # Output to the terminal in command line mode - if someone wanted to
632 # resend an email; they could redirect the output to sendmail themselves
633 PAGER= generate_email $2 $3 $1
635 if [ -n "$envelopesender" ]; then
636 envelopesender="-f '$envelopesender'"
639 while read oldrev newrev refname
641 generate_email $oldrev $newrev $refname |
642 /usr/sbin/sendmail -t $envelopesender