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
17 # * Default subject prefix is site name.
20 # This hook is stored in the contrib/hooks directory. Your distribution
21 # will have put this somewhere standard. You should make this script
22 # executable then link to it in the repository you would like to use it in.
23 # For example, on debian the hook is stored in
24 # /usr/share/doc/git-core/contrib/hooks/post-receive-email:
26 # chmod a+x post-receive-email
27 # cd /path/to/your/repository.git
28 # ln -sf /usr/share/doc/git-core/contrib/hooks/post-receive-email hooks/post-receive
30 # This hook script assumes it is enabled on the central repository of a
31 # project, with all users pushing only to it and not between each other. It
32 # will still work if you don't operate in that style, but it would become
33 # possible for the email to be from someone other than the person doing the
39 # This is the list that all pushes will go to; leave it blank to not send
40 # emails for every ref update.
42 # This is the list that all pushes of annotated tags will go to. Leave it
43 # blank to default to the mailinglist field. The announce emails lists
44 # the short log summary of the changes since the last annotated tag.
45 # hooks.envelopesender
46 # If set then the -f option is passed to sendmail to allow the envelope
47 # sender address to be set
49 # All emails have their subjects prefixed with this prefix, or "[SCM]"
50 # if emailprefix is unset, to aid filtering
52 # The shell command used to format each revision in the email, with
53 # "%s" replaced with the commit id. Defaults to "git rev-list -1
54 # --pretty %s", displaying the commit id, author, date and log
55 # message. To list full patches separated by a blank line, you
56 # could set this to "git show -C %s; echo".
57 # To list a gitweb/cgit URL *and* a full patch for each change set, use this:
58 # "t=%s; printf 'http://.../?id=%%s' \$t; echo;echo; git show -C \$t; echo"
59 # Be careful if "..." contains things that will be expanded by shell "eval"
64 # All emails include the headers "X-Git-Refname", "X-Git-Oldrev",
65 # "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and
66 # give information for debugging.
69 # ---------------------------- Functions
72 # Top level email generation function. This decides what type of update
73 # this is and calls the appropriate body-generation routine after outputting
76 # Note this function doesn't actually generate any email output, that is
77 # taken care of by the functions it calls:
78 # - generate_email_header
79 # - generate_create_XXXX_email
80 # - generate_update_XXXX_email
81 # - generate_delete_XXXX_email
82 # - generate_email_footer
87 oldrev
=$
(git rev-parse
$1)
88 newrev
=$
(git rev-parse
$2)
95 if expr "$oldrev" : '0*$' >/dev
/null
99 if expr "$newrev" : '0*$' >/dev
/null
107 # --- Get the revision types
108 newrev_type
=$
(git cat-file
-t $newrev 2> /dev
/null
)
109 oldrev_type
=$
(git cat-file
-t "$oldrev" 2> /dev
/null
)
110 case "$change_type" in
113 rev_type
="$newrev_type"
117 rev_type
="$oldrev_type"
121 # The revision type tells us what type the commit is, combined with
122 # the location of the ref we can decide between
127 case "$refname","$rev_type" in
131 short_refname
=${refname##refs/tags/}
135 refname_type
="annotated tag"
136 short_refname
=${refname##refs/tags/}
138 if [ -n "$announcerecipients" ]; then
139 recipients
="$announcerecipients"
144 refname_type
="branch"
145 short_refname
=${refname##refs/heads/}
147 refs
/remotes
/*,commit
)
149 refname_type
="tracking branch"
150 short_refname
=${refname##refs/remotes/}
151 echo >&2 "*** Push-update of tracking branch, $refname"
152 echo >&2 "*** - no email generated."
156 # Anything else (is there anything else?)
157 echo >&2 "*** Unknown type of update to $refname ($rev_type)"
158 echo >&2 "*** - no email generated"
163 # Check if we've got anyone to send to
164 if [ -z "$recipients" ]; then
165 case "$refname_type" in
167 config_name
="hooks.announcelist"
170 config_name
="hooks.mailinglist"
173 echo >&2 "*** $config_name is not set so no email will be sent"
174 echo >&2 "*** for $refname update $oldrev->$newrev"
179 # The email subject will contain the best description of the ref
180 # that we can build from the parameters
181 describe
=$
(git describe
$rev 2>/dev
/null
)
182 if [ -z "$describe" ]; then
186 generate_email_header
188 # Call the correct body generation function
190 case "$refname_type" in
191 "tracking branch"|branch
)
198 generate_
${change_type}_
${fn_name}_email
200 generate_email_footer
203 generate_email_header
()
205 # --- Email (all stdout will be the email)
209 Subject: ${emailprefix}$projectname $refname_type, $short_refname, ${change_type}d. $describe
210 X-Git-Refname: $refname
211 X-Git-Reftype: $refname_type
212 X-Git-Oldrev: $oldrev
213 X-Git-Newrev: $newrev
215 This is an automated email from the git hooks/post-receive script. It was
216 generated because a ref change was pushed to the repository containing
217 the project $projectname.
219 The $refname_type, $short_refname has been ${change_type}d
223 generate_email_footer
()
235 # --------------- Branches
238 # Called for the creation of a branch
240 generate_create_branch_email
()
242 # This is a new branch and so oldrev is not valid
243 echo " at $newrev ($newrev_type)"
252 # Called for the change of a pre-existing branch
254 generate_update_branch_email
()
257 # 1 --- 2 --- O --- X --- 3 --- 4 --- N
259 # O is $oldrev for $refname
260 # N is $newrev for $refname
261 # X is a revision pointed to by some other ref, for which we may
262 # assume that an email has already been generated.
263 # In this case we want to issue an email containing only revisions
264 # 3, 4, and N. Given (almost) by
266 # git rev-list N ^O --not --all
268 # The reason for the "almost", is that the "--not --all" will take
269 # precedence over the "N", and effectively will translate to
271 # git rev-list N ^O ^X ^N
273 # So, we need to build up the list more carefully. git rev-parse
274 # will generate a list of revs that may be fed into git rev-list.
275 # We can get it to make the "--not --all" part and then filter out
278 # git rev-parse --not --all | grep -v N
280 # Then, using the --stdin switch to git rev-list we have effectively
283 # git rev-list N ^O ^X
285 # This leaves a problem when someone else updates the repository
286 # while this script is running. Their new value of the ref we're
287 # working on would be included in the "--not --all" output; and as
288 # our $newrev would be an ancestor of that commit, it would exclude
289 # all of our commits. What we really want is to exclude the current
290 # value of $refname from the --not list, rather than N itself. So:
292 # git rev-parse --not --all | grep -v $(git rev-parse $refname)
294 # Get's us to something pretty safe (apart from the small time
295 # between refname being read, and git rev-parse running - for that,
299 # Next problem, consider this:
300 # * --- B --- * --- O ($oldrev)
302 # * --- X --- * --- N ($newrev)
304 # That is to say, there is no guarantee that oldrev is a strict
305 # subset of newrev (it would have required a --force, but that's
306 # allowed). So, we can't simply say rev-list $oldrev..$newrev.
307 # Instead we find the common base of the two revs and list from
310 # As above, we need to take into account the presence of X; if
311 # another branch is already in the repository and points at some of
312 # the revisions that we are about to output - we don't want them.
313 # The solution is as before: git rev-parse output filtered.
315 # Finally, tags: 1 --- 2 --- O --- T --- 3 --- 4 --- N
317 # Tags pushed into the repository generate nice shortlog emails that
318 # summarise the commits between them and the previous tag. However,
319 # those emails don't include the full commit messages that we output
320 # for a branch update. Therefore we still want to output revisions
321 # that have been output on a tag email.
323 # Luckily, git rev-parse includes just the tool. Instead of using
324 # "--all" we use "--branches"; this has the added benefit that
325 # "remotes/" will be ignored as well.
327 # List all of the revisions that were removed by this update, in a
328 # fast forward update, this list will be empty, because rev-list O
329 # ^N is empty. For a non fast forward, O ^N is the list of removed
333 for rev in $
(git rev-list
$newrev..
$oldrev)
335 revtype
=$
(git cat-file
-t "$rev")
336 echo " discards $rev ($revtype)"
338 if [ -z "$rev" ]; then
342 # List all the revisions from baserev to newrev in a kind of
343 # "table-of-contents"; note this list can include revisions that
344 # have already had notification emails and is present to show the
345 # full detail of the change from rolling back the old revision to
346 # the base revision and then forward to the new revision
347 for rev in $
(git rev-list
$oldrev..
$newrev)
349 revtype
=$
(git cat-file
-t "$rev")
350 echo " via $rev ($revtype)"
353 if [ "$fast_forward" ]; then
354 echo " from $oldrev ($oldrev_type)"
356 # 1. Existing revisions were removed. In this case newrev
357 # is a subset of oldrev - this is the reverse of a
358 # fast-forward, a rewind
359 # 2. New revisions were added on top of an old revision,
360 # this is a rewind and addition.
362 # (1) certainly happened, (2) possibly. When (2) hasn't
363 # happened, we set a flag to indicate that no log printout
368 # Find the common ancestor of the old and new revisions and
369 # compare it with newrev
370 baserev
=$
(git merge-base
$oldrev $newrev)
372 if [ "$baserev" = "$newrev" ]; then
373 echo "This update discarded existing revisions and left the branch pointing at"
374 echo "a previous point in the repository history."
376 echo " * -- * -- N ($newrev)"
378 echo " O -- O -- O ($oldrev)"
380 echo "The removed revisions are not necessarilly gone - if another reference"
381 echo "still refers to them they will stay in the repository."
384 echo "This update added new revisions after undoing existing revisions. That is"
385 echo "to say, the old revision is not a strict subset of the new revision. This"
386 echo "situation occurs when you --force push a change and generate a repository"
387 echo "containing something like this:"
389 echo " * -- * -- B -- O -- O -- O ($oldrev)"
391 echo " N -- N -- N ($newrev)"
393 echo "When this happens we assume that you've already had alert emails for all"
394 echo "of the O revisions, and so we here report only the revisions in the N"
395 echo "branch from the common base, B."
400 if [ -z "$rewind_only" ]; then
401 echo "Those revisions listed above that are new to this repository have"
402 echo "not appeared on any other notification email; so we list those"
403 echo "revisions in full, below."
409 # XXX: Need a way of detecting whether git rev-list actually
410 # outputted anything, so that we can issue a "no new
411 # revisions added by this update" message
415 echo "No new revisions were added by this update."
418 # The diffstat is shown from the old revision to the new revision.
419 # This is to show the truth of what happened in this change.
420 # There's no point showing the stat from the base to the new
421 # revision because the base is effectively a random revision at this
422 # point - the user will be interested in what this revision changed
423 # - including the undoing of previous revisions in the case of
424 # non-fast forward updates.
426 echo "Summary of changes:"
427 git diff-tree
--stat --summary --find-copies-harder $oldrev..
$newrev
431 # Called for the deletion of a branch
433 generate_delete_branch_email
()
438 git show
-s --pretty=oneline
$oldrev
442 # --------------- Annotated tags
445 # Called for the creation of an annotated tag
447 generate_create_atag_email
()
449 echo " at $newrev ($newrev_type)"
455 # Called for the update of an annotated tag (this is probably a rare event
456 # and may not even be allowed)
458 generate_update_atag_email
()
460 echo " to $newrev ($newrev_type)"
461 echo " from $oldrev (which is now obsolete)"
467 # Called when an annotated tag is created or changed
469 generate_atag_email
()
471 # Use git for-each-ref to pull out the individual fields from the
473 eval $
(git for-each-ref
--shell --format='
474 tagobject=%(*objectname)
475 tagtype=%(*objecttype)
477 tagged=%(taggerdate)' $refname
480 echo " tagging $tagobject ($tagtype)"
484 # If the tagged object is a commit, then we assume this is a
485 # release, and so we calculate which tag this tag is
487 prevtag
=$
(git describe
--abbrev=0 $newrev^
2>/dev
/null
)
489 if [ -n "$prevtag" ]; then
490 echo " replaces $prevtag"
494 echo " length $(git cat-file -s $tagobject) bytes"
497 echo " tagged by $tagger"
503 # Show the content of the tag message; this might contain a change
504 # log or release notes so is worth displaying.
505 git cat-file tag
$newrev |
sed -e '1,/^$/d'
510 # Only commit tags make sense to have rev-list operations
512 if [ -n "$prevtag" ]; then
513 # Show changes since the previous release
514 git rev-list
--pretty=short
"$prevtag..$newrev" | git shortlog
516 # No previous tag, show all the changes since time
518 git rev-list
--pretty=short
$newrev | git shortlog
522 # XXX: Is there anything useful we can do for non-commit
531 # Called for the deletion of an annotated tag
533 generate_delete_atag_email
()
538 git show
-s --pretty=oneline
$oldrev
542 # --------------- General references
545 # Called when any other type of reference is created (most likely a
548 generate_create_general_email
()
550 echo " at $newrev ($newrev_type)"
552 generate_general_email
556 # Called when any other type of reference is updated (most likely a
559 generate_update_general_email
()
561 echo " to $newrev ($newrev_type)"
564 generate_general_email
568 # Called for creation or update of any other type of reference
570 generate_general_email
()
572 # Unannotated tags are more about marking a point than releasing a
573 # version; therefore we don't do the shortlog summary that we do for
574 # annotated tags above - we simply show that the point has been
575 # marked, and print the log message for the marked point for
578 # Note this section also catches any other reference type (although
579 # there aren't any) and deals with them in the same way.
582 if [ "$newrev_type" = "commit" ]; then
584 git show
--no-color --root -s --pretty=medium
$newrev
587 # What can we do here? The tag marks an object that is not
588 # a commit, so there is no log for us to display. It's
589 # probably not wise to output git cat-file as it could be a
590 # binary blob. We'll just say how big it is
591 echo "$newrev is a $newrev_type, and is $(git cat-file -s $newrev) bytes long."
596 # Called for the deletion of any other type of reference
598 generate_delete_general_email
()
603 git show
-s --pretty=oneline
$oldrev
608 # --------------- Miscellaneous utilities
611 # Show new revisions as the user would like to see them in the email.
615 # This shows all log entries that are not already covered by
616 # another ref - i.e. commits that are now accessible from this
617 # ref that were previously not accessible
618 # (see generate_update_branch_email for the explanation of this
621 # Revision range passed to rev-list differs for new vs. updated
623 if [ "$change_type" = create
]
625 # Show all revisions exclusive to this (new) branch.
628 # Branch update; show revisions not part of $oldrev.
629 revspec
=$oldrev..
$newrev
632 other_branches
=$
(git for-each-ref
--format='%(refname)' refs
/heads
/ |
634 git rev-parse
--not $other_branches |
635 if [ -z "$custom_showrev" ]
637 git rev-list
--pretty --stdin $revspec
639 git rev-list
--stdin $revspec |
642 eval $
(printf "$custom_showrev" $onerev)
650 if [ -n "$envelopesender" ]; then
651 /usr
/sbin
/sendmail
-t -f "$envelopesender"
653 /usr
/sbin
/sendmail
-t
657 # ---------------------------- main()
660 LOGBEGIN
="- Log -----------------------------------------------------------------"
661 LOGEND
="-----------------------------------------------------------------------"
666 # Set GIT_DIR either from the working directory, or from the environment
668 GIT_DIR
=$
(git rev-parse
--git-dir 2>/dev
/null
)
669 if [ -z "$GIT_DIR" ]; then
670 echo >&2 "fatal: post-receive: GIT_DIR not set"
674 projectdesc
=$
(sed -ne '1p' "$GIT_DIR/description")
675 # Check if the description is unchanged from it's default, and shorten it to
676 # a more manageable length if it is
677 if expr "$projectdesc" : "Unnamed repository.*$" >/dev
/null
679 projectdesc
="UNNAMED PROJECT"
683 if [ -n "$projectname" ]; then
684 projectname
="$projectname.git"
685 projectboth
="$projectname (\"$projectdesc\")"
687 projectname
="$projectdesc"
688 projectboth
="$projectdesc"
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 "[$cfg_name] ")
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 generate_email
$2 $3 $1 | send_mail
706 while read oldrev newrev refname
708 generate_email
$oldrev $newrev $refname | send_mail