taskd/mail.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2007 Andy Parkins
   4 #
   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.
   9 #
  10 # =================
  11 # This is Girocco-customized version. No matter what is said below, it has
  12 # following changes:
  13 # * Calling with arguments is same as giving them on stdin.
  14 # * Optional fourth parameter is project name, used at most places instead
  15 #   of description.
  16 # * Optional fifth parameter is email sender.
  17 # * Load shlib.
  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.
  23 # =================
  24 #
  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:
  30 #
  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
  34 #
  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
  39 # push.
  40 #
  41 # Config
  42 # ------
  43 # hooks.mailinglist
  44 #   This is the list that all pushes will go to; leave it blank to not send
  45 #   emails for every ref update.
  46 # hooks.summaryonly
  47 #   If true do not include the actual diff when showing new commits (the
  48 #   summary information will still be shown).  Default is false.
  49 # hooks.announcelist
  50 #   This is the list that all pushes of annotated tags will go to.  Leave it
  51 #   blank to default to the mailinglist field.  The announce emails lists
  52 #   the short log summary of the changes since the last annotated tag.
  53 # hooks.envelopesender
  54 #   If set then the -f option is passed to sendmail to allow the envelope
  55 #   sender address to be set
  56 # hooks.emailprefix
  57 #   All emails have their subjects prefixed with this prefix, or "[SCM]"
  58 #   if emailprefix is unset, to aid filtering
  59 # hooks.showrev
  60 #   The shell command used to format each revision in the email, with
  61 #   "%s" replaced with the commit id.  Defaults to "git rev-list -1
  62 #   --pretty %s", displaying the commit id, author, date and log
  63 #   message.  To list full patches separated by a blank line, you
  64 #   could set this to "git show -C %s; echo".
  65 #   To list a gitweb/cgit URL *and* a full patch for each change set, use this:
  66 #     "t=%s; printf 'http://.../?id=%%s' \$t; echo;echo; git show -C \$t; echo"
  67 #   Be careful if "..." contains things that will be expanded by shell "eval"
  68 #   or printf.
  69 #
  70 # Notes
  71 # -----
  72 # All emails include the headers "X-Git-Refname", "X-Git-Oldrev",
  73 # "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and
  74 # give information for debugging.
  75 #
  76
  77 # ---------------------------- Functions
  78
  79 #
  80 # Function to output arguments without interpretation followed by \n
  81 #
  82 echol()
  83 {
  84         printf '%s\n' "$*"
  85 }
  86
  87 #
  88 # Function to read a tag's (the single argument) header fields into
  89 #   tagobject    the "object" value
  90 #   tagtype      the "type" value
  91 #   tagtag       the "tag" value
  92 #   taggername   from "tagger" value before first '<'
  93 #   taggerdate   from "tagger" value after '>' but formatted into a date string
  94 #   taggeremail  from "tagger" value between '<' and '>'
  95 # On return all fields will be set (to empty if failure) and the three tagger
  96 # fields will only be set to non-empty if a "tagger" header field is present.
  97 # If the object does not exist or is not a tag the function returns failure.
  98 read_tag_fields()
  99 {
 100         tagobject=
 101         tagtype=
 102         tagtag=
 103         taggername=
 104         taggerdate=
 105         taggeremail=
 106         if _tagfields="$(git cat-file tag "$1" | LC_ALL=C awk -F '[ ]' '
 107                         function quotesh(sv) {
 108                                 gsub(/'\''/, "'\'\\\\\'\''", sv)
 109                                 return "'\''" sv "'\''"
 110                         }
 111                         function trim(sv) {
 112                                 sub(/^[ \t]+/, "", sv)
 113                                 sub(/[ \t]+$/, "", sv)
 114                                 return sv
 115                         }
 116                         function hval(sv) {
 117                                 sub(/^[^ ]* /, "", sv)
 118                                 return sv
 119                         }
 120                         NR==1,/^$/ {
 121                                 if ($1 == "object") to=hval($0)
 122                                 if ($1 == "type") ty=hval($0)
 123                                 if ($1 == "tag") tt=hval($0)
 124                                 if ($1 == "tagger") tr=hval($0)
 125                         }
 126                         END {
 127                                 if (tt == "" || to == "" || ty == "") exit 1
 128                                 print "tagobject=" quotesh(to)
 129                                 print "tagtype=" quotesh(ty)
 130                                 print "tagtag=" quotesh(tt)
 131                                 if (match(tr, /^[ \t]*[^ \t<][^<]*/)) {
 132                                         tn=substr(tr, RSTART, RLENGTH)
 133                                         tr=substr(tr, RSTART + RLENGTH)
 134                                         tn=trim(tn)
 135                                         if (tn != "")
 136                                                 print "taggername=" quotesh(tn)
 137                                         if (match(tr, /^<.*>/)) {
 138                                                 if (RLENGTH > 2)
 139                                                         te=substr(tr, RSTART+1, RLENGTH-2)
 140                                                 tr=substr(tr, RSTART + RLENGTH)
 141                                                 te=trim(te)
 142                                                 if (te != "")
 143                                                         print "taggeremail=" quotesh(te)
 144                                                 if (match(tr, /^[ \t]*[0-9]+([ \t]+[-+]?[0-9][0-9]([0-9][0-9]([0-9][0-9])?)?)[ \t]*$/))
 145                                                         td=trim(tr)
 146                                                 if (td != "")
 147                                                         print "taggerdate=" quotesh(td)
 148                                         }
 149                                 }
 150                         }
 151                         ')"; then
 152                 eval "$_tagfields"
 153                 [ -z "$taggerdate" ] || taggerdate="$(strftime "$sdatefmt" $taggerdate)"
 154                 return 0
 155         fi
 156         return 1
 157 }
 158
 159 #
 160 # Function to prepare for email generation. This decides what type
 161 # of update this is and whether an email should even be generated.
 162 #
 163 prep_for_email()
 164 {
 165         # --- Arguments
 166         oldrev=$(git rev-parse --revs-only "$1" --)
 167         newrev=$(git rev-parse --revs-only "$2" --)
 168         [ "$oldrev" != "$newrev" ] || return 1
 169         scratch="${newrev#????????????????}"
 170         newrev16="${newrev%$scratch}"
 171         refname="$3"
 172
 173         # --- Interpret
 174         # 0000->1234 (create)
 175         # 1234->2345 (update)
 176         # 2345->0000 (delete)
 177         if LC_ALL=C expr "$oldrev" : '0*$' >/dev/null
 178         then
 179                 change_type="create"
 180         else
 181                 if LC_ALL=C expr "$newrev" : '0*$' >/dev/null
 182                 then
 183                         change_type="delete"
 184                 else
 185                         change_type="update"
 186                 fi
 187         fi
 188
 189         # --- Get the revision types
 190         newrev_type=$(git cat-file -t $newrev 2> /dev/null)
 191         oldrev_type=$(git cat-file -t "$oldrev" 2> /dev/null)
 192         case "$change_type" in
 193         create|update)
 194                 rev="$newrev"
 195                 rev_type="$newrev_type"
 196                 ;;
 197         delete)
 198                 rev="$oldrev"
 199                 rev_type="$oldrev_type"
 200                 ;;
 201         esac
 202
 203         # The revision type tells us what type the commit is, combined with
 204         # the location of the ref we can decide between
 205         #  - working branch
 206         #  - tracking branch
 207         #  - unannoted tag
 208         #  - annotated tag
 209         case "$refname","$rev_type" in
 210                 refs/tags/*,commit)
 211                         # un-annotated tag
 212                         refname_type="tag"
 213                         short_refname=${refname##refs/tags/}
 214                         ;;
 215                 refs/tags/*,tag)
 216                         # annotated tag
 217                         refname_type="annotated tag"
 218                         short_refname=${refname##refs/tags/}
 219                         # change recipients
 220                         if [ -n "$announcerecipients" ]; then
 221                                 recipients="$announcerecipients"
 222                         fi
 223                         ;;
 224                 refs/heads/*,commit|refs/heads/*,tag)
 225                         # branch
 226                         refname_type="branch"
 227                         short_refname=${refname##refs/heads/}
 228                         ;;
 229                 refs/remotes/*,commit)
 230                         # tracking branch
 231                         refname_type="tracking branch"
 232                         short_refname=${refname##refs/remotes/}
 233                         echol >&2 "*** Push-update of tracking branch, $refname"
 234                         echol >&2 "***  - no email generated."
 235                         return 1
 236                         ;;
 237                 refs/mob/*,commit|refs/mob/*,tag)
 238                         # personal mob ref
 239                         refname_type="personal mob ref"
 240                         short_refname=${refname##refs/mob/}
 241                         echol >&2 "*** Push-update of personal mob ref, $refname"
 242                         echol >&2 "***  - no email generated."
 243                         return 1
 244                         ;;
 245                 *)
 246                         # Anything else (is there anything else?)
 247                         echol >&2 "*** Unknown type of update to $refname ($rev_type)"
 248                         echol >&2 "***  - no email generated"
 249                         return 1
 250                         ;;
 251         esac
 252
 253         # Check if we've got anyone to send to
 254         if [ -z "$recipients" ]; then
 255                 case "$refname_type" in
 256                         "annotated tag")
 257                                 config_name="hooks.announcelist"
 258                                 ;;
 259                         *)
 260                                 config_name="hooks.mailinglist"
 261                                 ;;
 262                 esac
 263                 echol >&2 "*** $config_name is not set so no email will be sent"
 264                 echol >&2 "*** for $refname update $oldrev->$newrev"
 265                 return 1
 266         fi
 267
 268         return 0
 269 }
 270
 271 #
 272 # Top level email generation function.  This calls the appropriate
 273 # body-generation routine after outputting the common header.
 274 #
 275 # Note this function doesn't actually generate any email output, that is
 276 # taken care of by the functions it calls:
 277 #  - generate_email_header
 278 #  - generate_create_XXXX_email
 279 #  - generate_update_XXXX_email
 280 #  - generate_delete_XXXX_email
 281 #  - generate_email_footer
 282 #
 283 # Note also that this function cannot 'exit' from the script; when this
 284 # function is running (in hook script mode), the send_mail() function
 285 # is already executing in another process, connected via a pipe, and
 286 # if this function exits without, whatever has been generated to that
 287 # point will be sent as an email... even if nothing has been generated.
 288 #
 289 generate_email()
 290 {
 291         # Email parameters
 292         # The email subject will contain the best description of the ref
 293         # that we can build from the parameters
 294         describe=$(git describe $rev 2>/dev/null)
 295         if [ -z "$describe" ]; then
 296                 describe=$rev
 297         fi
 298
 299         generate_email_header
 300
 301         # Call the correct body generation function
 302         fn_name=general
 303         case "$refname_type" in
 304         "tracking branch"|branch)
 305                 fn_name=branch
 306                 ;;
 307         "annotated tag")
 308                 fn_name=atag
 309                 ;;
 310         esac
 311         generate_${change_type}_${fn_name}_email
 312
 313         generate_email_footer
 314 }
 315
 316 generate_email_header()
 317 {
 318         # --- Email (all stdout will be the email)
 319         # Generate header
 320         if [ -n "$emailsender" ]; then
 321                 echol "From: $emailsender"
 322         fi
 323         cat <<-EOF
 324         To: $recipients
 325         Subject: ${emailprefix}$projectname $refname_type $short_refname ${change_type}d: $describe
 326         MIME-Version: 1.0
 327         Content-Type: text/plain; charset=utf-8
 328         Content-Transfer-Encoding: 8bit
 329         EOF
 330         [ -n "$cfg_suppress_x_girocco" ] || echol "X-Girocco: $cfg_gitweburl"
 331         [ -z "$emailextraheader" ] || echol "$emailextraheader"
 332         cat <<-EOF
 333         X-Git-Refname: $refname
 334         X-Git-Reftype: $refname_type
 335         X-Git-Oldrev: $oldrev
 336         X-Git-Newrev: $newrev
 337         Auto-Submitted: auto-generated
 338
 339         This is an automated email from the git hooks/post-receive script. It was
 340         generated because a ref change was pushed to the repository containing
 341         the project $projectname.
 342
 343         The $refname_type, $short_refname has been ${change_type}d
 344         EOF
 345 }
 346
 347 generate_email_footer()
 348 {
 349         SPACE=" "
 350         cat <<-EOF
 351
 352
 353         $cfg_name automatic notification. Contact project admin $projectowner
 354         if you want to unsubscribe, or site admin $cfg_admin if you receive
 355         no reply.
 356         --${SPACE}
 357         $projectboth
 358         EOF
 359 }
 360
 361 # --------------- Branches
 362
 363 #
 364 # Called for the creation of a branch
 365 #
 366 generate_create_branch_email()
 367 {
 368         # This is a new branch and so oldrev is not valid
 369         echol "        at  $newrev ($newrev_type)"
 370         echol ""
 371
 372         echol $LOGBEGIN
 373         show_new_revisions
 374         echol $LOGEND
 375
 376         # The diffstat is shown from an empty tree to the new revision.
 377         # This is to show the truth of what happened in this change.
 378         # Note that since Git 1.5.5 the empty tree object is ALWAYS available
 379         # whether or not it's actually present in the repository.
 380         echol ""
 381         echol "Summary of changes:"
 382         git diff-tree --no-color --stat=72 --summary -B --find-copies-harder 4b825dc642cb6eb9a060e54bf8d69288fbee4904 $newrev
 383 }
 384
 385 #
 386 # Called for the change of a pre-existing branch
 387 #
 388 generate_update_branch_email()
 389 {
 390         # Consider this:
 391         #   1 --- 2 --- O --- X --- 3 --- 4 --- N
 392         #
 393         # O is $oldrev for $refname
 394         # N is $newrev for $refname
 395         # X is a revision pointed to by some other ref, for which we may
 396         #   assume that an email has already been generated.
 397         # In this case we want to issue an email containing only revisions
 398         # 3, 4, and N.  Given (almost) by
 399         #
 400         #  git rev-list N ^O --not --all
 401         #
 402         # The reason for the "almost", is that the "--not --all" will take
 403         # precedence over the "N", and effectively will translate to
 404         #
 405         #  git rev-list N ^O ^X ^N
 406         #
 407         # So, we need to build up the list more carefully.  git rev-parse
 408         # will generate a list of revs that may be fed into git rev-list.
 409         # We can get it to make the "--not --all" part and then filter out
 410         # the "^N" with:
 411         #
 412         #  git rev-parse --not --all | grep -v N
 413         #
 414         # Then, using the --stdin switch to git rev-list we have effectively
 415         # manufactured
 416         #
 417         #  git rev-list N ^O ^X
 418         #
 419         # This leaves a problem when someone else updates the repository
 420         # while this script is running.  Their new value of the ref we're
 421         # working on would be included in the "--not --all" output; and as
 422         # our $newrev would be an ancestor of that commit, it would exclude
 423         # all of our commits.  What we really want is to exclude the current
 424         # value of $refname from the --not list, rather than N itself.  So:
 425         #
 426         #  git rev-parse --not --all | grep -v $(git rev-parse $refname)
 427         #
 428         # Get's us to something pretty safe (apart from the small time
 429         # between refname being read, and git rev-parse running - for that,
 430         # I give up)
 431         #
 432         #
 433         # Next problem, consider this:
 434         #   * --- B --- * --- O ($oldrev)
 435         #          \
 436         #           * --- X --- * --- N ($newrev)
 437         #
 438         # That is to say, there is no guarantee that oldrev is a strict
 439         # subset of newrev (it would have required a --force, but that's
 440         # allowed).  So, we can't simply say rev-list $oldrev..$newrev.
 441         # Instead we find the common base of the two revs and list from
 442         # there.
 443         #
 444         # As above, we need to take into account the presence of X; if
 445         # another branch is already in the repository and points at some of
 446         # the revisions that we are about to output - we don't want them.
 447         # The solution is as before: git rev-parse output filtered.
 448         #
 449         # Finally, tags: 1 --- 2 --- O --- T --- 3 --- 4 --- N
 450         #
 451         # Tags pushed into the repository generate nice shortlog emails that
 452         # summarise the commits between them and the previous tag.  However,
 453         # those emails don't include the full commit messages that we output
 454         # for a branch update.  Therefore we still want to output revisions
 455         # that have been output on a tag email.
 456         #
 457         # Luckily, git rev-parse includes just the tool.  Instead of using
 458         # "--all" we use "--branches"; this has the added benefit that
 459         # "remotes/" will be ignored as well.
 460
 461         # List all of the revisions that were removed by this update, in a
 462         # fast-forward update, this list will be empty, because rev-list O
 463         # ^N is empty.  For a non-fast-forward, O ^N is the list of removed
 464         # revisions
 465         fast_forward=""
 466         rev=""
 467         for rev in $(git rev-list $newrev..$oldrev)
 468         do
 469                 revtype=$(git cat-file -t "$rev")
 470                 echol "  discards  $rev ($revtype)"
 471         done
 472         if [ -z "$rev" ]; then
 473                 fast_forward=1
 474         fi
 475
 476         # List all the revisions from baserev to newrev in a kind of
 477         # "table-of-contents"; note this list can include revisions that
 478         # have already had notification emails and is present to show the
 479         # full detail of the change from rolling back the old revision to
 480         # the base revision and then forward to the new revision
 481         for rev in $(git rev-list $oldrev..$newrev)
 482         do
 483                 revtype=$(git cat-file -t "$rev")
 484                 echol "       via  $rev ($revtype)"
 485         done
 486
 487         if [ "$fast_forward" ]; then
 488                 echol "      from  $oldrev ($oldrev_type)"
 489         else
 490                 #  1. Existing revisions were removed.  In this case newrev
 491                 #     is a subset of oldrev - this is the reverse of a
 492                 #     fast-forward, a rewind
 493                 #  2. New revisions were added on top of an old revision,
 494                 #     this is a rewind and addition.
 495
 496                 # (1) certainly happened, (2) possibly.  When (2) hasn't
 497                 # happened, we set a flag to indicate that no log printout
 498                 # is required.
 499
 500                 echol ""
 501
 502                 # Find the common ancestor of the old and new revisions and
 503                 # compare it with newrev
 504                 baserev=$(git merge-base $oldrev $newrev)
 505                 rewind_only=""
 506                 if [ "$baserev" = "$newrev" ]; then
 507                         echol "This update discarded existing revisions and left the branch pointing at"
 508                         echol "a previous point in the repository history."
 509                         echol ""
 510                         echol " * -- * -- N ($newrev)"
 511                         echol "            \\"
 512                         echol "             O -- O -- O ($oldrev)"
 513                         echol ""
 514                         echol "The removed revisions are not necessarily gone - if another reference"
 515                         echol "still refers to them they will stay in the repository."
 516                         rewind_only=1
 517                 else
 518                         echol "This update added new revisions after undoing existing revisions.  That is"
 519                         echol "to say, the old revision is not a strict subset of the new revision.  This"
 520                         echol "situation occurs when you --force push a change and generate a repository"
 521                         echol "containing something like this:"
 522                         echol ""
 523                         echol " * -- * -- B -- O -- O -- O ($oldrev)"
 524                         echol "            \\"
 525                         echol "             N -- N -- N ($newrev)"
 526                         echol ""
 527                         echol "When this happens we assume that you've already had alert emails for all"
 528                         echol "of the O revisions, and so we here report only the revisions in the N"
 529                         echol "branch from the common base, B."
 530                 fi
 531         fi
 532
 533         echol ""
 534         if [ -z "$rewind_only" ]; then
 535                 echol "Those revisions listed above that are new to this repository have"
 536                 echol "not appeared on any other notification email; so we list those"
 537                 echol "revisions in full, below."
 538
 539                 echol ""
 540                 echol $LOGBEGIN
 541                 show_new_revisions
 542
 543                 # XXX: Need a way of detecting whether git rev-list actually
 544                 # outputted anything, so that we can issue a "no new
 545                 # revisions added by this update" message
 546
 547                 echol $LOGEND
 548         else
 549                 echol "No new revisions were added by this update."
 550         fi
 551
 552         # The diffstat is shown from the old revision to the new revision.
 553         # This is to show the truth of what happened in this change.
 554         # There's no point showing the stat from the base to the new
 555         # revision because the base is effectively a random revision at this
 556         # point - the user will be interested in what this revision changed
 557         # - including the undoing of previous revisions in the case of
 558         # non-fast-forward updates.
 559         echol ""
 560         echol "Summary of changes:"
 561         git diff-tree --no-color --stat=72 --summary -B --find-copies-harder $oldrev..$newrev
 562 }
 563
 564 #
 565 # Called for the deletion of a branch
 566 #
 567 generate_delete_branch_email()
 568 {
 569         echol "       was  $oldrev"
 570         echol ""
 571         echol $LOGBEGIN
 572         git diff-tree --no-color --date=$datefmt -s --abbrev-commit --abbrev=$habbr --always --encoding=UTF-8 --pretty=oneline $oldrev
 573         echol $LOGEND
 574 }
 575
 576 # --------------- Annotated tags
 577
 578 #
 579 # Called for the creation of an annotated tag
 580 #
 581 generate_create_atag_email()
 582 {
 583         echol "        at  $newrev ($newrev_type)"
 584
 585         generate_atag_email
 586 }
 587
 588 #
 589 # Called for the update of an annotated tag (this is probably a rare event
 590 # and may not even be allowed)
 591 #
 592 generate_update_atag_email()
 593 {
 594         echol "        to  $newrev ($newrev_type)"
 595         echol "      from  $oldrev (which is now obsolete)"
 596
 597         generate_atag_email
 598 }
 599
 600 #
 601 # Called when an annotated tag is created or changed
 602 #
 603 generate_atag_email()
 604 {
 605         # Use read_tag_fields to pull out the individual fields from the
 606         # tag and git cat-file --batch-check to fully peel the tag if needed
 607         tagrev="$newrev"
 608         tagrev16="$newrev16"
 609         read_tag_fields "$tagrev"
 610         if [ "$tagtype" = "tag" ]; then
 611                 # fully peel the tag
 612                 peeledobject=
 613                 peeledtype=
 614                 info="$(echo "$tagrev^{}" | git cat-file --batch-check='
 615                 peeledobject=%(objectname)
 616                 peeledtype=%(objecttype)'
 617                 )"
 618                 case "$info" in *type=*) eval "$info";; *)
 619                         peeledtype=missing
 620                 esac
 621         else
 622                 peeledobject="$tagobject"
 623                 peeledtype="$tagtype"
 624         fi
 625
 626         echol "   tagging  $peeledobject ($peeledtype)"
 627         case "$peeledtype" in
 628         commit)
 629
 630                 # If the tagged object is a commit, then we assume this is a
 631                 # release, and so we calculate which tag this tag is
 632                 # replacing
 633                 prevtag=$(git describe --abbrev=0 "$peeledobject^" 2>/dev/null)
 634
 635                 if [ -n "$prevtag" ]; then
 636                         echol "  replaces  $prevtag"
 637                 fi
 638                 ;;
 639         *)
 640                 echol "    length  $(git cat-file -s "$peeledobject" 2>/dev/null) bytes"
 641                 ;;
 642         esac
 643         echol " tagged by  $taggername"
 644         echol "        on  $taggerdate"
 645
 646         echol ""
 647         echol $LOGBEGIN
 648
 649         while
 650                 echol "tag $tagrev"
 651                 echol "Tag:    $tagtag"
 652                 echol "Object: $tagobject ($tagtype)"
 653                 [ -z "$taggername" ] || \
 654                 echol "Tagger: $taggername"
 655                 [ -z "$taggerdate" ] || \
 656                 echol "Date:   $taggerdate"
 657                 echol "URL:    <$projurl/$tagrev16>"
 658                 echol ""
 659
 660                 # Show the content of the tag message; this might contain a change
 661                 # log or release notes so is worth displaying.
 662                 git cat-file tag "$tagrev" | LC_ALL=C sed -e '1,/^$/d;s/^/    /;'
 663                 echol ""
 664                 [ "$tagtype" = "tag" ]
 665         do
 666                 tagrev="$tagobject"
 667                 scratch="${tagrev#????????????????}"
 668                 tagrev16="${tagrev%$scratch}"
 669                 read_tag_fields "$tagrev" || break
 670         done
 671
 672         case "$peeledtype" in
 673         commit)
 674                 # Only commit tags make sense to have rev-list operations
 675                 # performed on them
 676                 if [ -n "$prevtag" ]; then
 677                         # Show changes since the previous release
 678                         git shortlog "$prevtag..$newrev"
 679                 else
 680                         # No previous tag, show all the changes since time
 681                         # began
 682                         git shortlog $newrev
 683                 fi
 684                 ;;
 685         *)
 686                 # XXX: Is there anything useful we can do for non-commit
 687                 # objects?
 688                 ;;
 689         esac
 690
 691         echol $LOGEND
 692 }
 693
 694 #
 695 # Called for the deletion of an annotated tag
 696 #
 697 generate_delete_atag_email()
 698 {
 699         echol "       was  $oldrev"
 700         echol ""
 701         echol $LOGBEGIN
 702         git diff-tree --no-color --date=$datefmt -s --abbrev-commit --abbrev=$habbr --always --encoding=UTF-8 --pretty=oneline $oldrev
 703         echol $LOGEND
 704 }
 705
 706 # --------------- General references
 707
 708 #
 709 # Called when any other type of reference is created (most likely a
 710 # non-annotated tag)
 711 #
 712 generate_create_general_email()
 713 {
 714         echol "        at  $newrev ($newrev_type)"
 715
 716         generate_general_email
 717 }
 718
 719 #
 720 # Called when any other type of reference is updated (most likely a
 721 # non-annotated tag)
 722 #
 723 generate_update_general_email()
 724 {
 725         echol "        to  $newrev ($newrev_type)"
 726         echol "      from  $oldrev"
 727
 728         generate_general_email
 729 }
 730
 731 #
 732 # Called for creation or update of any other type of reference
 733 #
 734 generate_general_email()
 735 {
 736         # Unannotated tags are more about marking a point than releasing a
 737         # version; therefore we don't do the shortlog summary that we do for
 738         # annotated tags above - we simply show that the point has been
 739         # marked, and print the log message for the marked point for
 740         # reference purposes
 741         #
 742         # Note this section also catches any other reference type (although
 743         # there aren't any) and deals with them in the same way.
 744
 745         echol ""
 746         if [ "$newrev_type" = "commit" ]; then
 747                 echol $LOGBEGIN
 748                 git diff-tree --no-color --date=$datefmt --root -s --always --encoding=UTF-8 --format="$pfmt1$projurlesc/$newrev16$pfmt2" $newrev
 749                 echol $LOGEND
 750         else
 751                 # What can we do here?  The tag marks an object that is not
 752                 # a commit, so there is no log for us to display.  It's
 753                 # probably not wise to output git cat-file as it could be a
 754                 # binary blob.  We'll just say how big it is
 755                 echol "$newrev is a $newrev_type, and is $(git cat-file -s $newrev) bytes long."
 756         fi
 757 }
 758
 759 #
 760 # Called for the deletion of any other type of reference
 761 #
 762 generate_delete_general_email()
 763 {
 764         echol "       was  $oldrev"
 765         echol ""
 766         echol $LOGBEGIN
 767         git diff-tree --no-color --date=$datefmt -s --abbrev-commit --abbrev=$habbr --always --encoding=UTF-8 --pretty=oneline $oldrev
 768         echol $LOGEND
 769 }
 770
 771
 772 # --------------- Miscellaneous utilities
 773
 774 #
 775 # Show new revisions as the user would like to see them in the email.
 776 #
 777 show_new_revisions()
 778 {
 779         # This shows all log entries that are not already covered by
 780         # another ref - i.e. commits that are now accessible from this
 781         # ref that were previously not accessible
 782         # (see generate_update_branch_email for the explanation of this
 783         # command)
 784
 785         # Revision range passed to rev-list differs for new vs. updated
 786         # branches.
 787         if [ "$change_type" = create ]
 788         then
 789                 # Show all revisions exclusive to this (new) branch.
 790                 revspec=$newrev
 791         else
 792                 # Branch update; show revisions not part of $oldrev.
 793                 revspec=$oldrev..$newrev
 794         fi
 795
 796         other_branches=$(git for-each-ref --format='%(refname)' refs/heads/ |
 797             LC_ALL=C grep -F -v $refname)
 798         git rev-parse --not $other_branches |
 799 #       if [ -z "$custom_showrev" ]
 800 #       then
 801 #               git rev-list --pretty --stdin $revspec
 802 #       else
 803                 git --no-pager log --stdin --no-color --format=tformat:"%H %p" $revspec |
 804                 LC_ALL=C awk '{print $1 " " NF-1}' |
 805                 while read onerev pcnt
 806                 do
 807                         if [ -n "$custom_showrev" ]; then
 808                                 eval $(printf "$custom_showrev" $onerev)
 809                         else
 810                                 if [ ${summaryonly:-false} = false ]; then
 811                                         if [ ${pcnt:-1} -gt 1 ]; then
 812                                                 opts="-p --cc"
 813                                         else
 814                                                 opts="-p --stat=72 --summary"
 815                                         fi
 816                                 else
 817                                         if [ ${pcnt:-1} -gt 1 ]; then
 818                                                 opts="-s"
 819                                         else
 820                                                 opts="--stat=72 --summary"
 821                                         fi
 822                                 fi
 823                                 scratch="${onerev#????????????????}"
 824                                 onerev16="${onerev%$scratch}"
 825                                 git diff-tree --no-color --date=$datefmt $opts --always --encoding=UTF-8 --format="$pfmt1$projurlesc/$onerev16$pfmt2" --abbrev=$habbr -B -C --root $onerev
 826                                 echo
 827                         fi
 828                 done
 829 #       fi
 830 }
 831
 832
 833 size_limit()
 834 {
 835         size=0
 836         while IFS= read -r line; do
 837                 # Include size of RFC 822 trailing CR+LF on each line
 838                 size=$(($size+${#line}+2))
 839                 if [ $size -gt $1 ]; then
 840                         echol "...e-mail trimmed, has been too large."
 841                         break
 842                 fi
 843                 echol "$line"
 844         done
 845 }
 846
 847
 848 sendmail_to_stdout()
 849 {
 850         cat
 851 }
 852
 853
 854 send_mail()
 855 {
 856         if [ -n "$cfg_sender" ]; then
 857                 "${cfg_sendmail_bin:-/usr/sbin/sendmail}" -i -t -f "$cfg_sender"
 858         else
 859                 "${cfg_sendmail_bin:-/usr/sbin/sendmail}" -i -t
 860         fi
 861 }
 862
 863 # ---------------------------- main()
 864
 865 # --- Constants
 866 LOGBEGIN="- Log -----------------------------------------------------------------"
 867 LOGEND="-----------------------------------------------------------------------"
 868
 869 # --- Config
 870 . @basedir@/shlib.sh
 871
 872 # Git formatting to use
 873 datefmt=rfc2822
 874 habbr=12
 875
 876 # strftime formatting to use (empty is default rfc2822 format)
 877 sdatefmt=
 878
 879 # This is --pretty=medium in two parts with a URL: line added
 880 pfmt1='format:commit %H%nAuthor: %an <%ae>%nDate:   %ad%nURL:    <'
 881 pfmt2='>%n%n%w(0,4,4)%s%n%n%b'
 882
 883 git_add_config core.abbrev=$habbr
 884
 885 # Set GIT_DIR either from the working directory, or from the environment
 886 # variable.
 887 GIT_DIR=$(git rev-parse --git-dir 2>/dev/null)
 888 if [ -z "$GIT_DIR" ]; then
 889         echol >&2 "fatal: post-receive: GIT_DIR not set"
 890         exit 1
 891 fi
 892
 893 projectdesc=
 894 ! [ -s "$GIT_DIR/description" ] || projectdesc=$(LC_ALL=C sed -ne '1p' "$GIT_DIR/description")
 895 # Check if the description is unchanged from it's default, and shorten it to
 896 # a more manageable length if it is
 897 if [ -z "$projectdesc" ] || LC_ALL=C expr "$projectdesc" : "Unnamed repository.*$" >/dev/null
 898 then
 899         projectdesc="UNNAMED PROJECT"
 900 fi
 901
 902 # If --stdout is first argument send all output there instead of mailing
 903 if [ "$1" = "--stdout" ]; then
 904         shift
 905         cfg_sendmail_bin="sendmail_to_stdout"
 906 fi
 907
 908 projectname="${4%.git}"
 909 if [ -n "$projectname" ]; then
 910         projectname="$projectname.git"
 911         projectowner="$(config_get owner)"
 912 else
 913         projectname="$(basename "$PWD")"
 914 fi
 915 projectboth="$projectname (\"$projectdesc\")"
 916 projurl="$cfg_gitweburl/$projectname"
 917 projurlesc="$(printf '%s\n' "$projurl" | sed -e 's/%/%%/g')"
 918
 919 emailsender="$5"
 920 emailextraheader="$6"
 921
 922 recipients=$(git config hooks.mailinglist)
 923 summaryonly=$(git config --bool hooks.summaryonly 2>/dev/null || :)
 924 announcerecipients=$(git config hooks.announcelist)
 925 envelopesender=$(git config hooks.envelopesender)
 926 emailprefix=$(git config hooks.emailprefix || echol "[$cfg_name] ")
 927 custom_showrev=$(git config hooks.showrev)
 928
 929 # --- Main loop
 930 # Allow dual mode: run from the command line just like the update hook, or
 931 # if no arguments are given then run as a hook script
 932 # If --stdout is first argument send all output there instead (handled above)
 933 # Optional 4th (projectname), 5th (sender) and 6th (extra header) arguments
 934 if [ -n "$1" -a -n "$2" -a -n "$3" ]; then
 935         # Handle a single update rather than a batch on stdin
 936         # Output will still be sent to sendmail unless --stdout is used
 937         # Same 3 args as update hook (<refname> <old> <new>)
 938         if prep_for_email $2 $3 $1; then
 939                 PAGER= generate_email | size_limit $((256*1024)) | send_mail
 940         fi
 941 else
 942         # Same input as pre-receive hook (each line is <old> <new> <refname>)
 943         while read oldrev newrev refname
 944         do
 945                 prep_for_email $oldrev $newrev $refname || continue
 946                 PAGER= generate_email | size_limit $((256*1024)) | send_mail
 947         done
 948 fi
 949
 950 exit 0