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.
11 # This is Girocco-customized version. No matter what is said below, it has
13 # * Calling with arguments is same as giving them on stdin.
14 # * Optional fourth parameter is project name, used at most places instead
16 # * Optional fifth parameter is email sender.
18 # * Default subject prefix is site name.
19 # * Unsubscribe instructions in email footer.
20 # * Default showrev includes gitweb link and show -C.
21 # * Nicer subject line.
22 # * Limit mail size to 256kb.
25 # This hook is stored in the contrib/hooks directory. Your distribution
26 # will have put this somewhere standard. You should make this script
27 # executable then link to it in the repository you would like to use it in.
28 # For example, on debian the hook is stored in
29 # /usr/share/git-core/contrib/hooks/post-receive-email:
31 # chmod a+x post-receive-email
32 # cd /path/to/your/repository.git
33 # ln -sf /usr/share/git-core/contrib/hooks/post-receive-email hooks/post-receive
35 # This hook script assumes it is enabled on the central repository of a
36 # project, with all users pushing only to it and not between each other. It
37 # will still work if you don't operate in that style, but it would become
38 # possible for the email to be from someone other than the person doing the
44 # This is the list that all pushes will go to; leave it blank to not send
45 # emails for every ref update.
47 # This is the list that all pushes of annotated tags will go to. Leave it
48 # blank to default to the mailinglist field. The announce emails lists
49 # the short log summary of the changes since the last annotated tag.
50 # hooks.envelopesender
51 # If set then the -f option is passed to sendmail to allow the envelope
52 # sender address to be set
54 # All emails have their subjects prefixed with this prefix, or "[SCM]"
55 # if emailprefix is unset, to aid filtering
57 # The shell command used to format each revision in the email, with
58 # "%s" replaced with the commit id. Defaults to "git rev-list -1
59 # --pretty %s", displaying the commit id, author, date and log
60 # message. To list full patches separated by a blank line, you
61 # could set this to "git show -C %s; echo".
62 # To list a gitweb/cgit URL *and* a full patch for each change set, use this:
63 # "t=%s; printf 'http://.../?id=%%s' \$t; echo;echo; git show -C \$t; echo"
64 # Be careful if "..." contains things that will be expanded by shell "eval"
69 # All emails include the headers "X-Git-Refname", "X-Git-Oldrev",
70 # "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and
71 # give information for debugging.
74 # ---------------------------- Functions
77 # Function to prepare for email generation. This decides what type
78 # of update this is and whether an email should even be generated.
83 oldrev
=$
(git rev-parse
$1)
84 newrev
=$
(git rev-parse
$2)
91 if expr "$oldrev" : '0*$' >/dev
/null
95 if expr "$newrev" : '0*$' >/dev
/null
103 # --- Get the revision types
104 newrev_type
=$
(git cat-file
-t $newrev 2> /dev
/null
)
105 oldrev_type
=$
(git cat-file
-t "$oldrev" 2> /dev
/null
)
106 case "$change_type" in
109 rev_type
="$newrev_type"
113 rev_type
="$oldrev_type"
117 # The revision type tells us what type the commit is, combined with
118 # the location of the ref we can decide between
123 case "$refname","$rev_type" in
127 short_refname
=${refname##refs/tags/}
131 refname_type
="annotated tag"
132 short_refname
=${refname##refs/tags/}
134 if [ -n "$announcerecipients" ]; then
135 recipients
="$announcerecipients"
140 refname_type
="branch"
141 short_refname
=${refname##refs/heads/}
143 refs
/remotes
/*,commit
)
145 refname_type
="tracking branch"
146 short_refname
=${refname##refs/remotes/}
147 echo >&2 "*** Push-update of tracking branch, $refname"
148 echo >&2 "*** - no email generated."
151 refs
/mob
/*,commit|refs
/mob
/*,tag
)
153 refname_type
="personal mob ref"
154 short_refname
=${refname##refs/mob/}
155 echo >&2 "*** Push-update of personal mob ref, $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"
186 # Top level email generation function. This calls the appropriate
187 # body-generation routine after outputting the common header.
189 # Note this function doesn't actually generate any email output, that is
190 # taken care of by the functions it calls:
191 # - generate_email_header
192 # - generate_create_XXXX_email
193 # - generate_update_XXXX_email
194 # - generate_delete_XXXX_email
195 # - generate_email_footer
197 # Note also that this function cannot 'exit' from the script; when this
198 # function is running (in hook script mode), the send_mail() function
199 # is already executing in another process, connected via a pipe, and
200 # if this function exits without, whatever has been generated to that
201 # point will be sent as an email... even if nothing has been generated.
206 # The email subject will contain the best description of the ref
207 # that we can build from the parameters
208 describe
=$
(git describe
$rev 2>/dev
/null
)
209 if [ -z "$describe" ]; then
213 generate_email_header
215 # Call the correct body generation function
217 case "$refname_type" in
218 "tracking branch"|branch
)
225 generate_
${change_type}_
${fn_name}_email
227 generate_email_footer
230 generate_email_header
()
232 # --- Email (all stdout will be the email)
234 if [ -n "$emailsender" ]; then
235 echo "From: $emailsender"
239 Subject: ${emailprefix}$projectname $refname_type $short_refname ${change_type}d: $describe
241 Content-Type: text/plain; charset=utf-8
242 Content-Transfer-Encoding: 8bit
244 [ -z "$emailextraheader" ] ||
echo "$emailextraheader"
246 X-Git-Refname: $refname
247 X-Git-Reftype: $refname_type
248 X-Git-Oldrev: $oldrev
249 X-Git-Newrev: $newrev
250 Auto-Submitted: auto-generated
252 This is an automated email from the git hooks/post-receive script. It was
253 generated because a ref change was pushed to the repository containing
254 the project $projectname.
256 The $refname_type, $short_refname has been ${change_type}d
260 generate_email_footer
()
266 $cfg_name automatic notification. Contact project admin $projectowner
267 if you want to unsubscribe, or site admin $cfg_admin if you receive
274 # --------------- Branches
277 # Called for the creation of a branch
279 generate_create_branch_email
()
281 # This is a new branch and so oldrev is not valid
282 echo " at $newrev ($newrev_type)"
291 # Called for the change of a pre-existing branch
293 generate_update_branch_email
()
296 # 1 --- 2 --- O --- X --- 3 --- 4 --- N
298 # O is $oldrev for $refname
299 # N is $newrev for $refname
300 # X is a revision pointed to by some other ref, for which we may
301 # assume that an email has already been generated.
302 # In this case we want to issue an email containing only revisions
303 # 3, 4, and N. Given (almost) by
305 # git rev-list N ^O --not --all
307 # The reason for the "almost", is that the "--not --all" will take
308 # precedence over the "N", and effectively will translate to
310 # git rev-list N ^O ^X ^N
312 # So, we need to build up the list more carefully. git rev-parse
313 # will generate a list of revs that may be fed into git rev-list.
314 # We can get it to make the "--not --all" part and then filter out
317 # git rev-parse --not --all | grep -v N
319 # Then, using the --stdin switch to git rev-list we have effectively
322 # git rev-list N ^O ^X
324 # This leaves a problem when someone else updates the repository
325 # while this script is running. Their new value of the ref we're
326 # working on would be included in the "--not --all" output; and as
327 # our $newrev would be an ancestor of that commit, it would exclude
328 # all of our commits. What we really want is to exclude the current
329 # value of $refname from the --not list, rather than N itself. So:
331 # git rev-parse --not --all | grep -v $(git rev-parse $refname)
333 # Get's us to something pretty safe (apart from the small time
334 # between refname being read, and git rev-parse running - for that,
338 # Next problem, consider this:
339 # * --- B --- * --- O ($oldrev)
341 # * --- X --- * --- N ($newrev)
343 # That is to say, there is no guarantee that oldrev is a strict
344 # subset of newrev (it would have required a --force, but that's
345 # allowed). So, we can't simply say rev-list $oldrev..$newrev.
346 # Instead we find the common base of the two revs and list from
349 # As above, we need to take into account the presence of X; if
350 # another branch is already in the repository and points at some of
351 # the revisions that we are about to output - we don't want them.
352 # The solution is as before: git rev-parse output filtered.
354 # Finally, tags: 1 --- 2 --- O --- T --- 3 --- 4 --- N
356 # Tags pushed into the repository generate nice shortlog emails that
357 # summarise the commits between them and the previous tag. However,
358 # those emails don't include the full commit messages that we output
359 # for a branch update. Therefore we still want to output revisions
360 # that have been output on a tag email.
362 # Luckily, git rev-parse includes just the tool. Instead of using
363 # "--all" we use "--branches"; this has the added benefit that
364 # "remotes/" will be ignored as well.
366 # List all of the revisions that were removed by this update, in a
367 # fast-forward update, this list will be empty, because rev-list O
368 # ^N is empty. For a non-fast-forward, O ^N is the list of removed
372 for rev in $
(git rev-list
$newrev..
$oldrev)
374 revtype
=$
(git cat-file
-t "$rev")
375 echo " discards $rev ($revtype)"
377 if [ -z "$rev" ]; then
381 # List all the revisions from baserev to newrev in a kind of
382 # "table-of-contents"; note this list can include revisions that
383 # have already had notification emails and is present to show the
384 # full detail of the change from rolling back the old revision to
385 # the base revision and then forward to the new revision
386 for rev in $
(git rev-list
$oldrev..
$newrev)
388 revtype
=$
(git cat-file
-t "$rev")
389 echo " via $rev ($revtype)"
392 if [ "$fast_forward" ]; then
393 echo " from $oldrev ($oldrev_type)"
395 # 1. Existing revisions were removed. In this case newrev
396 # is a subset of oldrev - this is the reverse of a
397 # fast-forward, a rewind
398 # 2. New revisions were added on top of an old revision,
399 # this is a rewind and addition.
401 # (1) certainly happened, (2) possibly. When (2) hasn't
402 # happened, we set a flag to indicate that no log printout
407 # Find the common ancestor of the old and new revisions and
408 # compare it with newrev
409 baserev
=$
(git merge-base
$oldrev $newrev)
411 if [ "$baserev" = "$newrev" ]; then
412 echo "This update discarded existing revisions and left the branch pointing at"
413 echo "a previous point in the repository history."
415 echo " * -- * -- N ($newrev)"
417 echo " O -- O -- O ($oldrev)"
419 echo "The removed revisions are not necessarily gone - if another reference"
420 echo "still refers to them they will stay in the repository."
423 echo "This update added new revisions after undoing existing revisions. That is"
424 echo "to say, the old revision is not a strict subset of the new revision. This"
425 echo "situation occurs when you --force push a change and generate a repository"
426 echo "containing something like this:"
428 echo " * -- * -- B -- O -- O -- O ($oldrev)"
430 echo " N -- N -- N ($newrev)"
432 echo "When this happens we assume that you've already had alert emails for all"
433 echo "of the O revisions, and so we here report only the revisions in the N"
434 echo "branch from the common base, B."
439 if [ -z "$rewind_only" ]; then
440 echo "Those revisions listed above that are new to this repository have"
441 echo "not appeared on any other notification email; so we list those"
442 echo "revisions in full, below."
448 # XXX: Need a way of detecting whether git rev-list actually
449 # outputted anything, so that we can issue a "no new
450 # revisions added by this update" message
454 echo "No new revisions were added by this update."
457 # The diffstat is shown from the old revision to the new revision.
458 # This is to show the truth of what happened in this change.
459 # There's no point showing the stat from the base to the new
460 # revision because the base is effectively a random revision at this
461 # point - the user will be interested in what this revision changed
462 # - including the undoing of previous revisions in the case of
463 # non-fast-forward updates.
465 echo "Summary of changes:"
466 git diff-tree
--no-color --stat --summary --find-copies-harder $oldrev..
$newrev
470 # Called for the deletion of a branch
472 generate_delete_branch_email
()
477 git diff-tree
--no-color -s --always --encoding=UTF-8
--pretty=oneline
$oldrev
481 # --------------- Annotated tags
484 # Called for the creation of an annotated tag
486 generate_create_atag_email
()
488 echo " at $newrev ($newrev_type)"
494 # Called for the update of an annotated tag (this is probably a rare event
495 # and may not even be allowed)
497 generate_update_atag_email
()
499 echo " to $newrev ($newrev_type)"
500 echo " from $oldrev (which is now obsolete)"
506 # Called when an annotated tag is created or changed
508 generate_atag_email
()
510 # Use git for-each-ref to pull out the individual fields from the
512 eval $
(git for-each-ref
--shell --format='
513 tagobject=%(*objectname)
514 tagtype=%(*objecttype)
516 tagged=%(taggerdate)' $refname
519 echo " tagging $tagobject ($tagtype)"
523 # If the tagged object is a commit, then we assume this is a
524 # release, and so we calculate which tag this tag is
526 prevtag
=$
(git describe
--abbrev=0 $newrev^
2>/dev
/null
)
528 if [ -n "$prevtag" ]; then
529 echo " replaces $prevtag"
533 echo " length $(git cat-file -s $tagobject) bytes"
536 echo " tagged by $tagger"
542 # Show the content of the tag message; this might contain a change
543 # log or release notes so is worth displaying.
544 git cat-file tag
$newrev |
sed -e '1,/^$/d'
549 # Only commit tags make sense to have rev-list operations
551 if [ -n "$prevtag" ]; then
552 # Show changes since the previous release
553 git shortlog
"$prevtag..$newrev"
555 # No previous tag, show all the changes since time
561 # XXX: Is there anything useful we can do for non-commit
570 # Called for the deletion of an annotated tag
572 generate_delete_atag_email
()
577 git diff-tree
--no-color -s --always --encoding=UTF-8
--pretty=oneline
$oldrev
581 # --------------- General references
584 # Called when any other type of reference is created (most likely a
587 generate_create_general_email
()
589 echo " at $newrev ($newrev_type)"
591 generate_general_email
595 # Called when any other type of reference is updated (most likely a
598 generate_update_general_email
()
600 echo " to $newrev ($newrev_type)"
603 generate_general_email
607 # Called for creation or update of any other type of reference
609 generate_general_email
()
611 # Unannotated tags are more about marking a point than releasing a
612 # version; therefore we don't do the shortlog summary that we do for
613 # annotated tags above - we simply show that the point has been
614 # marked, and print the log message for the marked point for
617 # Note this section also catches any other reference type (although
618 # there aren't any) and deals with them in the same way.
621 if [ "$newrev_type" = "commit" ]; then
623 git diff-tree
--no-color --root -s --always --encoding=UTF-8
--pretty=medium
$newrev
626 # What can we do here? The tag marks an object that is not
627 # a commit, so there is no log for us to display. It's
628 # probably not wise to output git cat-file as it could be a
629 # binary blob. We'll just say how big it is
630 echo "$newrev is a $newrev_type, and is $(git cat-file -s $newrev) bytes long."
635 # Called for the deletion of any other type of reference
637 generate_delete_general_email
()
642 git diff-tree
--no-color -s --always --encoding=UTF-8
--pretty=oneline
$oldrev
647 # --------------- Miscellaneous utilities
650 # Show new revisions as the user would like to see them in the email.
654 # This shows all log entries that are not already covered by
655 # another ref - i.e. commits that are now accessible from this
656 # ref that were previously not accessible
657 # (see generate_update_branch_email for the explanation of this
660 # Revision range passed to rev-list differs for new vs. updated
662 if [ "$change_type" = create
]
664 # Show all revisions exclusive to this (new) branch.
667 # Branch update; show revisions not part of $oldrev.
668 revspec
=$oldrev..
$newrev
671 other_branches
=$
(git for-each-ref
--format='%(refname)' refs
/heads
/ |
673 git rev-parse
--not $other_branches |
674 # if [ -z "$custom_showrev" ]
676 # git rev-list --pretty --stdin $revspec
678 git rev-list
--stdin $revspec |
681 if [ -n "$custom_showrev" ]; then
682 eval $
(printf "$custom_showrev" $onerev)
684 echo "$cfg_gitweburl/$projectname/commit/$onerev"
686 git diff-tree
--no-color -p --always --encoding=UTF-8
--pretty=medium
-C $onerev
697 while IFS
= read line
; do
698 size
=$
((size
+${#line}))
699 if [ $size -gt $1 ]; then
700 echo "...e-mail trimmed, has been too large."
710 if [ -n "$cfg_sender" ]; then
711 "${cfg_sendmail_bin:-/usr/sbin/sendmail}" -i -t -f "$cfg_sender"
713 "${cfg_sendmail_bin:-/usr/sbin/sendmail}" -i -t
717 # ---------------------------- main()
720 LOGBEGIN
="- Log -----------------------------------------------------------------"
721 LOGEND
="-----------------------------------------------------------------------"
726 # Set GIT_DIR either from the working directory, or from the environment
728 GIT_DIR
=$
(git rev-parse
--git-dir 2>/dev
/null
)
729 if [ -z "$GIT_DIR" ]; then
730 echo >&2 "fatal: post-receive: GIT_DIR not set"
734 projectdesc
=$
(sed -ne '1p' "$GIT_DIR/description")
735 # Check if the description is unchanged from it's default, and shorten it to
736 # a more manageable length if it is
737 if expr "$projectdesc" : "Unnamed repository.*$" >/dev
/null
739 projectdesc
="UNNAMED PROJECT"
743 if [ -n "$projectname" ]; then
744 projectname
="$projectname.git"
745 projectboth
="$projectname (\"$projectdesc\")"
746 projectowner
="$(config_get owner)"
748 projectname
="$projectdesc"
749 projectboth
="$projectdesc"
753 emailextraheader
="$6"
755 recipients
=$
(git config hooks.mailinglist
)
756 announcerecipients
=$
(git config hooks.announcelist
)
757 envelopesender
=$
(git config hooks.envelopesender
)
758 emailprefix
=$
(git config hooks.emailprefix ||
echo "[$cfg_name] ")
759 custom_showrev
=$
(git config hooks.showrev
)
762 # Allow dual mode: run from the command line just like the update hook, or
763 # if no arguments are given then run as a hook script
764 if [ -n "$1" -a -n "$2" -a -n "$3" ]; then
765 # Output to the terminal in command line mode - if someone wanted to
766 # resend an email; they could redirect the output to sendmail
768 if prep_for_email
$2 $3 $1; then
769 PAGER
= generate_email | size_limit $
((256*1024)) | send_mail
772 while read oldrev newrev refname
774 prep_for_email
$oldrev $newrev $refname ||
continue
775 PAGER
= generate_email | size_limit $
((256*1024)) | send_mail