Support cvs via git-shell
[git/git.git] / contrib / hooks / post-receive-email
CommitLineData
4557e0de
AP
1#!/bin/sh
2#
3# Copyright (c) 2007 Andy Parkins
4#
5# An example hook script to mail out commit update information. This hook sends emails
6# listing new revisions to the repository introduced by the change being reported. The
7# rule is that (for branch updates) each commit will appear on one email and one email
8# only.
9#
10# This hook is stored in the contrib/hooks directory. Your distribution will have put
11# this somewhere standard. You should make this script executable then link to it in
12# the repository you would like to use it in. For example, on debian the hook is stored
13# in /usr/share/doc/git-core/contrib/hooks/post-receive-email:
14#
15# chmod a+x post-receive-email
16# cd /path/to/your/repository.git
17# ln -sf /usr/share/doc/git-core/contrib/hooks/post-receive-email hooks/post-receive
18#
19# This hook script assumes it is enabled on the central repository of a project, with
20# all users pushing only to it and not between each other. It will still work if you
21# don't operate in that style, but it would become possible for the email to be from
22# someone other than the person doing the push.
23#
24# Config
25# ------
26# hooks.mailinglist
27# This is the list that all pushes will go to; leave it blank to not send
28# emails for every ref update.
29# hooks.announcelist
30# This is the list that all pushes of annotated tags will go to. Leave it
31# blank to default to the mailinglist field. The announce emails lists the
32# short log summary of the changes since the last annotated tag.
33# hook.envelopesender
34# If set then the -f option is passed to sendmail to allow the envelope sender
35# address to be set
36#
37# Notes
38# -----
39# All emails have their subjects prefixed with "[SCM]" to aid filtering.
40# All emails include the headers "X-Git-Refname", "X-Git-Oldrev",
41# "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and
42# give information for debugging.
43#
44
45# ---------------------------- Functions
46
47#
48# Top level email generation function. This decides what type of update
49# this is and calls the appropriate body-generation routine after outputting
50# the common header
51#
52# Note this function doesn't actually generate any email output, that is taken
53# care of by the functions it calls:
54# - generate_email_header
55# - generate_create_XXXX_email
56# - generate_update_XXXX_email
57# - generate_delete_XXXX_email
58# - generate_email_footer
59#
60generate_email()
61{
62 # --- Arguments
63 oldrev=$(git rev-parse $1)
64 newrev=$(git rev-parse $2)
65 refname="$3"
66
67 # --- Interpret
68 # 0000->1234 (create)
69 # 1234->2345 (update)
70 # 2345->0000 (delete)
71 if expr "$oldrev" : '0*$' >/dev/null
72 then
73 change_type="create"
74 else
75 if expr "$newrev" : '0*$' >/dev/null
76 then
77 change_type="delete"
78 else
79 change_type="update"
80 fi
81 fi
82
83 # --- Get the revision types
84 newrev_type=$(git cat-file -t $newrev 2> /dev/null)
85 oldrev_type=$(git cat-file -t "$oldrev" 2> /dev/null)
86 case "$change_type" in
87 create|update)
88 rev="$newrev"
89 rev_type="$newrev_type"
90 ;;
91 delete)
92 rev="$oldrev"
93 rev_type="$oldrev_type"
94 ;;
95 esac
96
97 # The revision type tells us what type the commit is, combined with
98 # the location of the ref we can decide between
99 # - working branch
100 # - tracking branch
101 # - unannoted tag
102 # - annotated tag
103 case "$refname","$rev_type" in
104 refs/tags/*,commit)
105 # un-annotated tag
106 refname_type="tag"
107 short_refname=${refname##refs/tags/}
108 ;;
109 refs/tags/*,tag)
110 # annotated tag
111 refname_type="annotated tag"
112 short_refname=${refname##refs/tags/}
113 # change recipients
114 if [ -n "$announcerecipients" ]; then
115 recipients="$announcerecipients"
116 fi
117 ;;
118 refs/heads/*,commit)
119 # branch
120 refname_type="branch"
121 short_refname=${refname##refs/heads/}
122 ;;
123 refs/remotes/*,commit)
124 # 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."
129 exit 0
130 ;;
131 *)
132 # Anything else (is there anything else?)
133 echo >&2 "*** Unknown type of update to $refname ($rev_type)"
134 echo >&2 "*** - no email generated"
135 exit 1
136 ;;
137 esac
138
139 # Check if we've got anyone to send to
140 if [ -z "$recipients" ]; then
141 echo >&2 "*** hooks.recipients is not set so no email will be sent"
142 echo >&2 "*** for $refname update $oldrev->$newrev"
143 exit 0
144 fi
145
146 # Email parameters
147 # The committer will be obtained from the latest existing rev; so
148 # for a deletion it will be the oldrev, for the others, then newrev
149 committer=$(git show --pretty=full -s $rev | sed -ne "s/^Commit: //p" |
150 sed -ne 's/\(.*\) </"\1" </p')
151 # The email subject will contain the best description of the ref
152 # that we can build from the parameters
153 describe=$(git describe $rev 2>/dev/null)
154 if [ -z "$describe" ]; then
155 describe=$rev
156 fi
157
158 generate_email_header
159
160 # Call the correct body generation function
161 fn_name=general
162 case "$refname_type" in
163 "tracking branch"|branch)
164 fn_name=branch
165 ;;
166 "annotated tag")
167 fn_name=atag
168 ;;
169 esac
170 generate_${change_type}_${fn_name}_email
171
172 generate_email_footer
173}
174
175generate_email_header()
176{
177 # --- Email (all stdout will be the email)
178 # Generate header
179 cat <<-EOF
4557e0de
AP
180 To: $recipients
181 Subject: ${EMAILPREFIX}$projectdesc $refname_type, $short_refname, ${change_type}d. $describe
182 X-Git-Refname: $refname
183 X-Git-Reftype: $refname_type
184 X-Git-Oldrev: $oldrev
185 X-Git-Newrev: $newrev
186
187 This is an automated email from the git hooks/post-receive script. It was
188 generated because a ref change was pushed to the repository containing
189 the project "$projectdesc".
190
191 The $refname_type, $short_refname has been ${change_type}d
192 EOF
193}
194
195generate_email_footer()
196{
197 cat <<-EOF
198
199
200 hooks/post-receive
a6080a0a 201 --
4557e0de
AP
202 $projectdesc
203 EOF
204}
205
206# --------------- Branches
207
208#
209# Called for the creation of a branch
210#
211generate_create_branch_email()
212{
213 # This is a new branch and so oldrev is not valid
214 echo " at $newrev ($newrev_type)"
215 echo ""
216
217 echo $LOGBEGIN
218 # This shows all log entries that are not already covered by
219 # another ref - i.e. commits that are now accessible from this
220 # ref that were previously not accessible (see generate_update_branch_email
221 # for the explanation of this command)
222 git rev-parse --not --branches | grep -v $(git rev-parse $refname) |
223 git rev-list --pretty --stdin $newrev
224 echo $LOGEND
225}
226
227#
228# Called for the change of a pre-existing branch
229#
230generate_update_branch_email()
231{
232 # Consider this:
233 # 1 --- 2 --- O --- X --- 3 --- 4 --- N
234 #
235 # O is $oldrev for $refname
236 # N is $newrev for $refname
237 # X is a revision pointed to by some other ref, for which we may
238 # assume that an email has already been generated.
239 # In this case we want to issue an email containing only revisions
240 # 3, 4, and N. Given (almost) by
241 #
242 # git-rev-list N ^O --not --all
243 #
244 # The reason for the "almost", is that the "--not --all" will take
245 # precedence over the "N", and effectively will translate to
246 #
247 # git-rev-list N ^O ^X ^N
248 #
249 # So, we need to build up the list more carefully. git-rev-parse will
250 # generate a list of revs that may be fed into git-rev-list. We can get
251 # it to make the "--not --all" part and then filter out the "^N" with:
252 #
253 # git-rev-parse --not --all | grep -v N
254 #
255 # Then, using the --stdin switch to git-rev-list we have effectively
256 # manufactured
257 #
258 # git-rev-list N ^O ^X
259 #
260 # This leaves a problem when someone else updates the repository
261 # while this script is running. Their new value of the ref we're working
262 # on would be included in the "--not --all" output; and as our $newrev
263 # would be an ancestor of that commit, it would exclude all of our
264 # commits. What we really want is to exclude the current value of
265 # $refname from the --not list, rather than N itself. So:
266 #
267 # git-rev-parse --not --all | grep -v $(git-rev-parse $refname)
268 #
269 # Get's us to something pretty safe (apart from the small time between
270 # refname being read, and git-rev-parse running - for that, I give up)
271 #
272 #
273 # Next problem, consider this:
274 # * --- B --- * --- O ($oldrev)
275 # \
276 # * --- X --- * --- N ($newrev)
277 #
278 # That is to say, there is no guarantee that oldrev is a strict subset of
279 # newrev (it would have required a --force, but that's allowed). So, we
280 # can't simply say rev-list $oldrev..$newrev. Instead we find the common
281 # base of the two revs and list from there.
282 #
283 # As above, we need to take into account the presence of X; if another
284 # branch is already in the repository and points at some of the revisions
285 # that we are about to output - we don't want them. The solution is as
286 # before: git-rev-parse output filtered.
287 #
288 # Finally, tags:
289 # 1 --- 2 --- O --- T --- 3 --- 4 --- N
290 #
291 # Tags pushed into the repository generate nice shortlog emails that
292 # summarise the commits between them and the previous tag. However,
293 # those emails don't include the full commit messages that we output
294 # for a branch update. Therefore we still want to output revisions
295 # that have been output on a tag email.
296 #
297 # Luckily, git-rev-parse includes just the tool. Instead of using "--all"
298 # we use "--branches"; this has the added benefit that "remotes/" will
299 # be ignored as well.
300
301 # List all of the revisions that were removed by this update, in a fast forward
302 # update, this list will be empty, because rev-list O ^N is empty. For a non
303 # fast forward, O ^N is the list of removed revisions
8e404f82 304 fast_forward=""
4557e0de
AP
305 rev=""
306 for rev in $(git rev-list $newrev..$oldrev)
307 do
308 revtype=$(git cat-file -t "$rev")
309 echo " discards $rev ($revtype)"
310 done
311 if [ -z "$rev" ]; then
312 fast_forward=1
313 fi
314
315 # List all the revisions from baserev to newrev in a kind of
316 # "table-of-contents"; note this list can include revisions that have
317 # already had notification emails and is present to show the full detail
318 # of the change from rolling back the old revision to the base revision and
319 # then forward to the new revision
320 for rev in $(git rev-list $oldrev..$newrev)
321 do
322 revtype=$(git cat-file -t "$rev")
323 echo " via $rev ($revtype)"
324 done
325
326 if [ -z "$fastforward" ]; then
327 echo " from $oldrev ($oldrev_type)"
328 else
024e5b31
AP
329 # 1. Existing revisions were removed. In this case newrev is a
330 # subset of oldrev - this is the reverse of a fast-forward,
331 # a rewind
332 # 2. New revisions were added on top of an old revision, this is
333 # a rewind and addition.
334
335 # (1) certainly happened, (2) possibly. When (2) hasn't happened,
336 # we set a flag to indicate that no log printout is required.
337
4557e0de 338 echo ""
024e5b31
AP
339
340 # Find the common ancestor of the old and new revisions and compare
341 # it with newrev
342 baserev=$(git merge-base $oldrev $newrev)
343 rewind_only=""
344 if [ "$baserev" = "$newrev" ]; then
345 echo "This update discarded existing revisions and left the branch pointing at"
346 echo "a previous point in the repository history."
347 echo ""
348 echo " * -- * -- N ($newrev)"
349 echo " \\"
350 echo " O -- O -- O ($oldrev)"
351 echo ""
352 echo "The removed revisions are not necessarilly gone - if another reference"
353 echo "still refers to them they will stay in the repository."
354 rewind_only=1
355 else
356 echo "This update added new revisions after undoing existing revisions. That is"
357 echo "to say, the old revision is not a strict subset of the new revision. This"
358 echo "situation occurs when you --force push a change and generate a repository"
359 echo "containing something like this:"
360 echo ""
361 echo " * -- * -- B -- O -- O -- O ($oldrev)"
362 echo " \\"
363 echo " N -- N -- N ($newrev)"
364 echo ""
365 echo "When this happens we assume that you've already had alert emails for all"
366 echo "of the O revisions, and so we here report only the revisions in the N"
367 echo "branch from the common base, B."
368 fi
4557e0de
AP
369 fi
370
371 echo ""
024e5b31
AP
372 if [ -z "$rewind_only" ]; then
373 echo "Those revisions listed above that are new to this repository have"
374 echo "not appeared on any other notification email; so we list those"
375 echo "revisions in full, below."
4557e0de 376
024e5b31
AP
377 echo ""
378 echo $LOGBEGIN
379 git rev-parse --not --branches | grep -v $(git rev-parse $refname) |
380 git rev-list --pretty --stdin $oldrev..$newrev
4557e0de 381
024e5b31
AP
382 # XXX: Need a way of detecting whether git rev-list actually outputted
383 # anything, so that we can issue a "no new revisions added by this
384 # update" message
4557e0de 385
024e5b31
AP
386 echo $LOGEND
387 else
388 echo "No new revisions were added by this update."
389 fi
4557e0de
AP
390
391 # The diffstat is shown from the old revision to the new revision. This
392 # is to show the truth of what happened in this change. There's no point
393 # showing the stat from the base to the new revision because the base
394 # is effectively a random revision at this point - the user will be
395 # interested in what this revision changed - including the undoing of
396 # previous revisions in the case of non-fast forward updates.
397 echo ""
398 echo "Summary of changes:"
399 git diff-tree --stat --summary --find-copies-harder $oldrev..$newrev
400}
401
402#
403# Called for the deletion of a branch
404#
405generate_delete_branch_email()
406{
407 echo " was $oldrev"
408 echo ""
409 echo $LOGEND
410 git show -s --pretty=oneline $oldrev
411 echo $LOGEND
412}
413
414# --------------- Annotated tags
415
416#
417# Called for the creation of an annotated tag
418#
419generate_create_atag_email()
420{
421 echo " at $newrev ($newrev_type)"
422
423 generate_atag_email
424}
425
426#
427# Called for the update of an annotated tag (this is probably a rare event
428# and may not even be allowed)
429#
430generate_update_atag_email()
431{
432 echo " to $newrev ($newrev_type)"
433 echo " from $oldrev (which is now obsolete)"
434
435 generate_atag_email
436}
437
438#
439# Called when an annotated tag is created or changed
440#
441generate_atag_email()
442{
443 # Use git-for-each-ref to pull out the individual fields from the tag
444 eval $(git for-each-ref --shell --format='
445 tagobject=%(*objectname)
446 tagtype=%(*objecttype)
447 tagger=%(taggername)
448 tagged=%(taggerdate)' $refname
449 )
450
451 echo " tagging $tagobject ($tagtype)"
452 case "$tagtype" in
453 commit)
454 # If the tagged object is a commit, then we assume this is a
455 # release, and so we calculate which tag this tag is replacing
456 prevtag=$(git describe --abbrev=0 $newrev^ 2>/dev/null)
457
458 if [ -n "$prevtag" ]; then
459 echo " replaces $prevtag"
460 fi
461 ;;
462 *)
463 echo " length $(git cat-file -s $tagobject) bytes"
464 ;;
465 esac
466 echo " tagged by $tagger"
467 echo " on $tagged"
468
469 echo ""
470 echo $LOGBEGIN
471
472 # Show the content of the tag message; this might contain a change log
473 # or release notes so is worth displaying.
474 git cat-file tag $newrev | sed -e '1,/^$/d'
475
476 echo ""
477 case "$tagtype" in
478 commit)
479 # Only commit tags make sense to have rev-list operations performed
480 # on them
481 if [ -n "$prevtag" ]; then
482 # Show changes since the previous release
483 git rev-list --pretty=short "$prevtag..$newrev" | git shortlog
484 else
485 # No previous tag, show all the changes since time began
486 git rev-list --pretty=short $newrev | git shortlog
487 fi
488 ;;
489 *)
490 # XXX: Is there anything useful we can do for non-commit objects?
491 ;;
492 esac
493
494 echo $LOGEND
495}
496
497#
498# Called for the deletion of an annotated tag
499#
500generate_delete_atag_email()
501{
502 echo " was $oldrev"
503 echo ""
504 echo $LOGEND
505 git show -s --pretty=oneline $oldrev
506 echo $LOGEND
507}
508
509# --------------- General references
510
511#
512# Called when any other type of reference is created (most likely a
513# non-annotated tag)
514#
515generate_create_general_email()
516{
517 echo " at $newrev ($newrev_type)"
518
519 generate_general_email
520}
521
522#
523# Called when any other type of reference is updated (most likely a
524# non-annotated tag)
525#
526generate_update_general_email()
527{
528 echo " to $newrev ($newrev_type)"
529 echo " from $oldrev"
530
531 generate_general_email
532}
533
534#
535# Called for creation or update of any other type of reference
536#
537generate_general_email()
538{
539 # Unannotated tags are more about marking a point than releasing a version;
540 # therefore we don't do the shortlog summary that we do for annotated tags
541 # above - we simply show that the point has been marked, and print the log
542 # message for the marked point for reference purposes
543 #
544 # Note this section also catches any other reference type (although there
545 # aren't any) and deals with them in the same way.
546
547 echo ""
548 if [ "$newrev_type" = "commit" ]; then
549 echo $LOGBEGIN
550 git show --no-color --root -s $newrev
551 echo $LOGEND
552 else
553 # What can we do here? The tag marks an object that is not a commit,
554 # so there is no log for us to display. It's probably not wise to
555 # output git-cat-file as it could be a binary blob. We'll just say how
556 # big it is
557 echo "$newrev is a $newrev_type, and is $(git cat-file -s $newrev) bytes long."
558 fi
559}
560
561#
562# Called for the deletion of any other type of reference
563#
564generate_delete_general_email()
565{
566 echo " was $oldrev"
567 echo ""
568 echo $LOGEND
569 git show -s --pretty=oneline $oldrev
570 echo $LOGEND
571}
572
d1637a07
JM
573send_mail()
574{
575 if [ -n "$envelopesender" ]; then
576 /usr/sbin/sendmail -t -f "$envelopesender"
577 else
578 /usr/sbin/sendmail -t
579 fi
580}
581
4557e0de
AP
582# ---------------------------- main()
583
584# --- Constants
585EMAILPREFIX="[SCM] "
586LOGBEGIN="- Log -----------------------------------------------------------------"
587LOGEND="-----------------------------------------------------------------------"
588
589# --- Config
590# Set GIT_DIR either from the working directory, or from the environment
591# variable.
592GIT_DIR=$(git rev-parse --git-dir 2>/dev/null)
593if [ -z "$GIT_DIR" ]; then
594 echo >&2 "fatal: post-receive: GIT_DIR not set"
595 exit 1
596fi
597
c855195c 598projectdesc=$(sed -ne '1p' "$GIT_DIR/description")
4557e0de
AP
599# Check if the description is unchanged from it's default, and shorten it to a
600# more manageable length if it is
601if expr "$projectdesc" : "Unnamed repository.*$" >/dev/null
602then
603 projectdesc="UNNAMED PROJECT"
604fi
605
606recipients=$(git repo-config hooks.mailinglist)
607announcerecipients=$(git repo-config hooks.announcelist)
608envelopesender=$(git-repo-config hooks.envelopesender)
609
610# --- Main loop
611# Allow dual mode: run from the command line just like the update hook, or if
612# no arguments are given then run as a hook script
613if [ -n "$1" -a -n "$2" -a -n "$3" ]; then
614 # Output to the terminal in command line mode - if someone wanted to
615 # resend an email; they could redirect the output to sendmail themselves
616 PAGER= generate_email $2 $3 $1
617else
4557e0de
AP
618 while read oldrev newrev refname
619 do
d1637a07 620 generate_email $oldrev $newrev $refname | send_mail
4557e0de
AP
621 done
622fi