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/doc/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/doc/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 # Top level email generation function. This decides what type of update
78 # this is and calls the appropriate body-generation routine after outputting
81 # Note this function doesn't actually generate any email output, that is
82 # taken care of by the functions it calls:
83 # - generate_email_header
84 # - generate_create_XXXX_email
85 # - generate_update_XXXX_email
86 # - generate_delete_XXXX_email
87 # - generate_email_footer
92 oldrev
=$
(git rev-parse
$1)
93 newrev
=$
(git rev-parse
$2)
100 if expr "$oldrev" : '0*$' >/dev
/null
104 if expr "$newrev" : '0*$' >/dev
/null
112 # --- Get the revision types
113 newrev_type
=$
(git cat-file
-t $newrev 2> /dev
/null
)
114 oldrev_type
=$
(git cat-file
-t "$oldrev" 2> /dev
/null
)
115 case "$change_type" in
118 rev_type
="$newrev_type"
122 rev_type
="$oldrev_type"
126 # The revision type tells us what type the commit is, combined with
127 # the location of the ref we can decide between
132 case "$refname","$rev_type" in
136 short_refname
=${refname##refs/tags/}
140 refname_type
="annotated tag"
141 short_refname
=${refname##refs/tags/}
143 if [ -n "$announcerecipients" ]; then
144 recipients
="$announcerecipients"
149 refname_type
="branch"
150 short_refname
=${refname##refs/heads/}
152 refs
/remotes
/*,commit
)
154 refname_type
="tracking branch"
155 short_refname
=${refname##refs/remotes/}
156 echo >&2 "*** Push-update of tracking branch, $refname"
157 echo >&2 "*** - no email generated."
162 # Anything else (is there anything else?)
163 echo >&2 "*** Unknown type of update to $refname ($rev_type)"
164 echo >&2 "*** - no email generated"
169 # Check if we've got anyone to send to
170 if [ -z "$recipients" ]; then
171 case "$refname_type" in
173 config_name
="hooks.announcelist"
176 config_name
="hooks.mailinglist"
179 echo >&2 "*** $config_name is not set so no email will be sent"
180 echo >&2 "*** for $refname update $oldrev->$newrev"
186 # The email subject will contain the best description of the ref
187 # that we can build from the parameters
188 describe
=$
(git describe
$rev 2>/dev
/null
)
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
()
212 # --- Email (all stdout will be the email)
214 if [ -n "$emailsender" ]; then
215 echo "From: $emailsender"
219 Subject: ${emailprefix}$projectname $refname_type $short_refname ${change_type}d: $describe
220 X-Git-Refname: $refname
221 X-Git-Reftype: $refname_type
222 X-Git-Oldrev: $oldrev
223 X-Git-Newrev: $newrev
225 This is an automated email from the git hooks/post-receive script. It was
226 generated because a ref change was pushed to the repository containing
227 the project $projectname.
229 The $refname_type, $short_refname has been ${change_type}d
233 generate_email_footer
()
239 $cfg_name automatic notification. Contact project admin $projectowner
240 if you want to unsubscribe, or site admin $cfg_admin if you receive
247 # --------------- Branches
250 # Called for the creation of a branch
252 generate_create_branch_email
()
254 # This is a new branch and so oldrev is not valid
255 echo " at $newrev ($newrev_type)"
264 # Called for the change of a pre-existing branch
266 generate_update_branch_email
()
269 # 1 --- 2 --- O --- X --- 3 --- 4 --- N
271 # O is $oldrev for $refname
272 # N is $newrev for $refname
273 # X is a revision pointed to by some other ref, for which we may
274 # assume that an email has already been generated.
275 # In this case we want to issue an email containing only revisions
276 # 3, 4, and N. Given (almost) by
278 # git rev-list N ^O --not --all
280 # The reason for the "almost", is that the "--not --all" will take
281 # precedence over the "N", and effectively will translate to
283 # git rev-list N ^O ^X ^N
285 # So, we need to build up the list more carefully. git rev-parse
286 # will generate a list of revs that may be fed into git rev-list.
287 # We can get it to make the "--not --all" part and then filter out
290 # git rev-parse --not --all | grep -v N
292 # Then, using the --stdin switch to git rev-list we have effectively
295 # git rev-list N ^O ^X
297 # This leaves a problem when someone else updates the repository
298 # while this script is running. Their new value of the ref we're
299 # working on would be included in the "--not --all" output; and as
300 # our $newrev would be an ancestor of that commit, it would exclude
301 # all of our commits. What we really want is to exclude the current
302 # value of $refname from the --not list, rather than N itself. So:
304 # git rev-parse --not --all | grep -v $(git rev-parse $refname)
306 # Get's us to something pretty safe (apart from the small time
307 # between refname being read, and git rev-parse running - for that,
311 # Next problem, consider this:
312 # * --- B --- * --- O ($oldrev)
314 # * --- X --- * --- N ($newrev)
316 # That is to say, there is no guarantee that oldrev is a strict
317 # subset of newrev (it would have required a --force, but that's
318 # allowed). So, we can't simply say rev-list $oldrev..$newrev.
319 # Instead we find the common base of the two revs and list from
322 # As above, we need to take into account the presence of X; if
323 # another branch is already in the repository and points at some of
324 # the revisions that we are about to output - we don't want them.
325 # The solution is as before: git rev-parse output filtered.
327 # Finally, tags: 1 --- 2 --- O --- T --- 3 --- 4 --- N
329 # Tags pushed into the repository generate nice shortlog emails that
330 # summarise the commits between them and the previous tag. However,
331 # those emails don't include the full commit messages that we output
332 # for a branch update. Therefore we still want to output revisions
333 # that have been output on a tag email.
335 # Luckily, git rev-parse includes just the tool. Instead of using
336 # "--all" we use "--branches"; this has the added benefit that
337 # "remotes/" will be ignored as well.
339 # List all of the revisions that were removed by this update, in a
340 # fast forward update, this list will be empty, because rev-list O
341 # ^N is empty. For a non fast forward, O ^N is the list of removed
345 for rev in $
(git rev-list
$newrev..
$oldrev)
347 revtype
=$
(git cat-file
-t "$rev")
348 echo " discards $rev ($revtype)"
350 if [ -z "$rev" ]; then
354 # List all the revisions from baserev to newrev in a kind of
355 # "table-of-contents"; note this list can include revisions that
356 # have already had notification emails and is present to show the
357 # full detail of the change from rolling back the old revision to
358 # the base revision and then forward to the new revision
359 for rev in $
(git rev-list
$oldrev..
$newrev)
361 revtype
=$
(git cat-file
-t "$rev")
362 echo " via $rev ($revtype)"
365 if [ "$fast_forward" ]; then
366 echo " from $oldrev ($oldrev_type)"
368 # 1. Existing revisions were removed. In this case newrev
369 # is a subset of oldrev - this is the reverse of a
370 # fast-forward, a rewind
371 # 2. New revisions were added on top of an old revision,
372 # this is a rewind and addition.
374 # (1) certainly happened, (2) possibly. When (2) hasn't
375 # happened, we set a flag to indicate that no log printout
380 # Find the common ancestor of the old and new revisions and
381 # compare it with newrev
382 baserev
=$
(git merge-base
$oldrev $newrev)
384 if [ "$baserev" = "$newrev" ]; then
385 echo "This update discarded existing revisions and left the branch pointing at"
386 echo "a previous point in the repository history."
388 echo " * -- * -- N ($newrev)"
390 echo " O -- O -- O ($oldrev)"
392 echo "The removed revisions are not necessarilly gone - if another reference"
393 echo "still refers to them they will stay in the repository."
396 echo "This update added new revisions after undoing existing revisions. That is"
397 echo "to say, the old revision is not a strict subset of the new revision. This"
398 echo "situation occurs when you --force push a change and generate a repository"
399 echo "containing something like this:"
401 echo " * -- * -- B -- O -- O -- O ($oldrev)"
403 echo " N -- N -- N ($newrev)"
405 echo "When this happens we assume that you've already had alert emails for all"
406 echo "of the O revisions, and so we here report only the revisions in the N"
407 echo "branch from the common base, B."
412 if [ -z "$rewind_only" ]; then
413 echo "Those revisions listed above that are new to this repository have"
414 echo "not appeared on any other notification email; so we list those"
415 echo "revisions in full, below."
421 # XXX: Need a way of detecting whether git rev-list actually
422 # outputted anything, so that we can issue a "no new
423 # revisions added by this update" message
427 echo "No new revisions were added by this update."
430 # The diffstat is shown from the old revision to the new revision.
431 # This is to show the truth of what happened in this change.
432 # There's no point showing the stat from the base to the new
433 # revision because the base is effectively a random revision at this
434 # point - the user will be interested in what this revision changed
435 # - including the undoing of previous revisions in the case of
436 # non-fast forward updates.
438 echo "Summary of changes:"
439 git diff-tree
--stat --summary --find-copies-harder $oldrev..
$newrev
443 # Called for the deletion of a branch
445 generate_delete_branch_email
()
450 git show
-s --pretty=oneline
$oldrev
454 # --------------- Annotated tags
457 # Called for the creation of an annotated tag
459 generate_create_atag_email
()
461 echo " at $newrev ($newrev_type)"
467 # Called for the update of an annotated tag (this is probably a rare event
468 # and may not even be allowed)
470 generate_update_atag_email
()
472 echo " to $newrev ($newrev_type)"
473 echo " from $oldrev (which is now obsolete)"
479 # Called when an annotated tag is created or changed
481 generate_atag_email
()
483 # Use git for-each-ref to pull out the individual fields from the
485 eval $
(git for-each-ref
--shell --format='
486 tagobject=%(*objectname)
487 tagtype=%(*objecttype)
489 tagged=%(taggerdate)' $refname
492 echo " tagging $tagobject ($tagtype)"
496 # If the tagged object is a commit, then we assume this is a
497 # release, and so we calculate which tag this tag is
499 prevtag
=$
(git describe
--abbrev=0 $newrev^
2>/dev
/null
)
501 if [ -n "$prevtag" ]; then
502 echo " replaces $prevtag"
506 echo " length $(git cat-file -s $tagobject) bytes"
509 echo " tagged by $tagger"
515 # Show the content of the tag message; this might contain a change
516 # log or release notes so is worth displaying.
517 git cat-file tag
$newrev |
sed -e '1,/^$/d'
522 # Only commit tags make sense to have rev-list operations
524 if [ -n "$prevtag" ]; then
525 # Show changes since the previous release
526 git rev-list
--pretty=short
"$prevtag..$newrev" | git shortlog
528 # No previous tag, show all the changes since time
530 git rev-list
--pretty=short
$newrev | git shortlog
534 # XXX: Is there anything useful we can do for non-commit
543 # Called for the deletion of an annotated tag
545 generate_delete_atag_email
()
550 git show
-s --pretty=oneline
$oldrev
554 # --------------- General references
557 # Called when any other type of reference is created (most likely a
560 generate_create_general_email
()
562 echo " at $newrev ($newrev_type)"
564 generate_general_email
568 # Called when any other type of reference is updated (most likely a
571 generate_update_general_email
()
573 echo " to $newrev ($newrev_type)"
576 generate_general_email
580 # Called for creation or update of any other type of reference
582 generate_general_email
()
584 # Unannotated tags are more about marking a point than releasing a
585 # version; therefore we don't do the shortlog summary that we do for
586 # annotated tags above - we simply show that the point has been
587 # marked, and print the log message for the marked point for
590 # Note this section also catches any other reference type (although
591 # there aren't any) and deals with them in the same way.
594 if [ "$newrev_type" = "commit" ]; then
596 git show
--no-color --root -s --pretty=medium
$newrev
599 # What can we do here? The tag marks an object that is not
600 # a commit, so there is no log for us to display. It's
601 # probably not wise to output git cat-file as it could be a
602 # binary blob. We'll just say how big it is
603 echo "$newrev is a $newrev_type, and is $(git cat-file -s $newrev) bytes long."
608 # Called for the deletion of any other type of reference
610 generate_delete_general_email
()
615 git show
-s --pretty=oneline
$oldrev
620 # --------------- Miscellaneous utilities
623 # Show new revisions as the user would like to see them in the email.
627 # This shows all log entries that are not already covered by
628 # another ref - i.e. commits that are now accessible from this
629 # ref that were previously not accessible
630 # (see generate_update_branch_email for the explanation of this
633 # Revision range passed to rev-list differs for new vs. updated
635 if [ "$change_type" = create
]
637 # Show all revisions exclusive to this (new) branch.
640 # Branch update; show revisions not part of $oldrev.
641 revspec
=$oldrev..
$newrev
644 other_branches
=$
(git for-each-ref
--format='%(refname)' refs
/heads
/ |
646 git rev-parse
--not $other_branches |
647 # if [ -z "$custom_showrev" ]
649 # git rev-list --pretty --stdin $revspec
651 git rev-list
--stdin $revspec |
654 if [ -n "$custom_showrev" ]; then
655 eval $
(printf "$custom_showrev" $onerev)
657 echo "$cfg_gitweburl/$projectname/commit/$onerev"
670 while IFS
= read line
; do
671 size
=$
((size
+${#line}))
672 if [ $size -gt $1 ]; then
673 echo "...e-mail trimmed, has been too large."
683 if ! IFS
= read header
; then
686 if [ -z "$header" ]; then
689 { echo "$header"; cat; } |
690 if [ -n "$envelopesender" ]; then
691 /usr
/sbin
/sendmail
-t -f "$envelopesender"
693 /usr
/sbin
/sendmail
-t
697 # ---------------------------- main()
700 LOGBEGIN
="- Log -----------------------------------------------------------------"
701 LOGEND
="-----------------------------------------------------------------------"
706 # Set GIT_DIR either from the working directory, or from the environment
708 GIT_DIR
=$
(git rev-parse
--git-dir 2>/dev
/null
)
709 if [ -z "$GIT_DIR" ]; then
710 echo >&2 "fatal: post-receive: GIT_DIR not set"
714 projectdesc
=$
(sed -ne '1p' "$GIT_DIR/description")
715 # Check if the description is unchanged from it's default, and shorten it to
716 # a more manageable length if it is
717 if expr "$projectdesc" : "Unnamed repository.*$" >/dev
/null
719 projectdesc
="UNNAMED PROJECT"
723 if [ -n "$projectname" ]; then
724 projectname
="$projectname.git"
725 projectboth
="$projectname (\"$projectdesc\")"
726 projectowner
="$(config_get owner)"
728 projectname
="$projectdesc"
729 projectboth
="$projectdesc"
734 recipients
=$
(git config hooks.mailinglist
)
735 announcerecipients
=$
(git config hooks.announcelist
)
736 envelopesender
=$
(git config hooks.envelopesender
)
737 emailprefix
=$
(git config hooks.emailprefix ||
echo "[$cfg_name] ")
738 custom_showrev
=$
(git config hooks.showrev
)
741 # Allow dual mode: run from the command line just like the update hook, or
742 # if no arguments are given then run as a hook script
743 if [ -n "$1" -a -n "$2" -a -n "$3" ]; then
744 # Output to the terminal in command line mode - if someone wanted to
745 # resend an email; they could redirect the output to sendmail
747 generate_email
$2 $3 $1 | size_limit $
((256*1024)) | send_mail
749 while read oldrev newrev refname
751 generate_email
$oldrev $newrev $refname | size_limit $
((256*1024)) | send_mail