templates/hooks--update - git - Git at Google


            
            #!/bin/sh

            
            #

            
            # An example hook script to mail out commit update information.

            
            # It can also blocks tags that aren't annotated.

            
            # Called by git-receive-pack with arguments: refname sha1-old sha1-new

            
            #

            
            # To enable this hook, make this file executable by "chmod +x update".

            
            #

            
            # Config

            
            # ------

            
            # hooks.mailinglist

            
            #   This is the list that all pushes will go to; leave it blank to not send

            
            #   emails frequently.  The log email will list every log entry in full between

            
            #   the old ref value and the new ref value.

            
            # hooks.announcelist

            
            #   This is the list that all pushes of annotated tags will go to.  Leave it

            
            #   blank to just use the mailinglist field.  The announce emails list the

            
            #   short log summary of the changes since the last annotated tag

            
            # hooks.allowunannotated

            
            #   This boolean sets whether unannotated tags will be allowed into the

            
            #   repository.  By default they won't be.

            
            #

            
            # Notes

            
            # -----

            
            # All emails have their subjects prefixed with "[SCM]" to aid filtering.

            
            # All emails include the headers "X-Git-Refname", "X-Git-Oldrev",

            
            # "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and info.


            # --- Constants

            
            EMAILPREFIX="[SCM] "

            
            LOGBEGIN="- Log -----------------------------------------------------------------"

            
            LOGEND="-----------------------------------------------------------------------"

            
            DATEFORMAT="%F %R %z"


            # --- Command line

            
            refname="$1"

            
            oldrev="$2"

            
            newrev="$3"


            # --- Safety check

            
            if [ -z "$GIT_DIR" ]; then

            
            	echo "Don't run this script from the command line." >&2

            
            	echo " (if you want, you could supply GIT_DIR then run" >&2

            
            	echo "  $0 <ref> <oldrev> <newrev>)" >&2

            
            	exit 1

            
            fi


            if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then

            
            	echo "Usage: $0 <ref> <oldrev> <newrev>" >&2

            
            	exit 1

            
            fi


            # --- Config

            
            projectdesc=$(cat $GIT_DIR/description)

            
            recipients=$(git-repo-config hooks.mailinglist)

            
            announcerecipients=$(git-repo-config hooks.announcelist)

            
            allowunannotated=$(git-repo-config --bool hooks.allowunannotated)


            # --- Check types

            
            newrev_type=$(git-cat-file -t "$newrev")


            case "$refname","$newrev_type" in

            
            	refs/tags/*,commit)

            
            		# un-annotated tag

            
            		refname_type="tag"

            
            		short_refname=${refname##refs/tags/}

            
            		if [ $allowunannotated != "true" ]; then

            
            			echo "*** The un-annotated tag, $short_refname is not allowed in this repository" >&2

            
            			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2

            
            			exit 1

            
            		fi

            
            		;;

            
            	refs/tags/*,tag)

            
            		# annotated tag

            
            		refname_type="annotated tag"

            
            		short_refname=${refname##refs/tags/}

            
            		# change recipients

            
            		if [ -n "$announcerecipients" ]; then

            
            			recipients="$announcerecipients"

            
            		fi

            
            		;;

            
            	refs/heads/*,commit)

            
            		# branch

            
            		refname_type="branch"

            
            		short_refname=${refname##refs/heads/}

            
            		;;

            
            	refs/remotes/*,commit)

            
            		# tracking branch

            
            		refname_type="tracking branch"

            
            		short_refname=${refname##refs/remotes/}

            
            		# Should this even be allowed?

            
            		echo "*** Push-update of tracking branch, $refname.  No email generated." >&2

            
            		exit 0

            
            		;;

            
            	*)

            
            		# Anything else (is there anything else?)

            
            		echo "*** Update hook: unknown type of update, \"$newrev_type\", to ref $refname" >&2

            
            		exit 1

            
            		;;

            
            esac


            # Check if we've got anyone to send to

            
            if [ -z "$recipients" ]; then

            
            	# If the email isn't sent, then at least give the user some idea of what command

            
            	# would generate the email at a later date

            
            	echo "*** No recipients found - no email will be sent, but the push will continue" >&2

            
            	echo "*** for $0 $1 $2 $3" >&2

            
            	exit 0

            
            fi


            # --- Email parameters

            
            committer=$(git show --pretty=full -s $newrev | grep "^Commit: " | sed -e "s/^Commit: //")

            
            describe=$(git describe $newrev 2>/dev/null)

            
            if [ -z "$describe" ]; then

            
            	describe=$newrev

            
            fi


            # --- Email (all stdout will be the email)

            
            (

            
            # Generate header

            
            cat <<-EOF

            
            From: $committer

            
            To: $recipients

            
            Subject: ${EMAILPREFIX}$projectdesc $refname_type, $short_refname now at $describe

            
            X-Git-Refname: $refname

            
            X-Git-Reftype: $refname_type

            
            X-Git-Oldrev: $oldrev

            
            X-Git-Newrev: $newrev


            Hello,


            This is an automated email from the git hooks/update script, it was

            
            generated because a ref change was pushed to the repository.


            Updating $refname_type, $short_refname,

            
            EOF


            case "$refname_type" in

            
            	"tracking branch"|branch)

            
            		if expr "$oldrev" : '0*$' >/dev/null

            
            		then

            
            			# If the old reference is "0000..0000" then this is a new branch

            
            			# and so oldrev is not valid

            
            			echo "  as a new  $refname_type"

            
            		    echo "        to  $newrev ($newrev_type)"

            
            			echo ""

            
            			echo $LOGBEGIN

            
            			# This shows all log entries that are not already covered by

            
            			# another ref - i.e. commits that are now accessible from this

            
            			# ref that were previously not accessible

            
            			git-rev-parse --not --all | git-rev-list --stdin --pretty $newref

            
            			echo $LOGEND

            
            		else

            
            			# oldrev is valid

            
            			oldrev_type=$(git-cat-file -t "$oldrev")


            			# Now the problem is for cases like this:

            
            			#   * --- * --- * --- * (oldrev)

            
            			#          \

            
            			#           * --- * --- * (newrev)

            
            			# i.e. there is no guarantee that newrev is a strict subset

            
            			# of oldrev - (would have required a force, but that's allowed).

            
            			# So, we can't simply say rev-list $oldrev..$newrev.  Instead

            
            			# we find the common base of the two revs and list from there

            
            			baserev=$(git-merge-base $oldrev $newrev)


            			# Commit with a parent

            
            			for rev in $(git-rev-list $newrev ^$baserev)

            
            			do

            
            				revtype=$(git-cat-file -t "$rev")

            
            				echo "       via  $rev ($revtype)"

            
            			done

            
            			if [ "$baserev" = "$oldrev" ]; then

            
            				echo "      from  $oldrev ($oldrev_type)"

            
            			else

            
            				echo "  based on  $baserev"

            
            				echo "      from  $oldrev ($oldrev_type)"

            
            				echo ""

            
            				echo "This ref update crossed a branch point; i.e. the old rev is not a strict subset"

            
            				echo "of the new rev.  This occurs, when you --force push a change in a situation"

            
            				echo "like this:"

            
            				echo ""

            
            				echo " * -- * -- B -- O -- O -- O ($oldrev)"

            
            				echo "            \\"

            
            				echo "             N -- N -- N ($newrev)"

            
            				echo ""

            
            				echo "Therefore, we assume that you've already had alert emails for all of the O"

            
            				echo "revisions, and now give you all the revisions in the N branch from the common"

            
            				echo "base, B ($baserev), up to the new revision."

            
            			fi

            
            			echo ""

            
            			echo $LOGBEGIN

            
            			git-rev-list --pretty $newrev ^$baserev

            
            			echo $LOGEND

            
            			echo ""

            
            			echo "Diffstat:"

            
            			git-diff-tree --no-color --stat -M -C --find-copies-harder $newrev ^$baserev

            
            		fi

            
            		;;

            
            	"annotated tag")

            
            		# Should we allow changes to annotated tags?

            
            		if expr "$oldrev" : '0*$' >/dev/null

            
            		then

            
            			# If the old reference is "0000..0000" then this is a new atag

            
            			# and so oldrev is not valid

            
            			echo "        to  $newrev ($newrev_type)"

            
            		else

            
            			echo "        to  $newrev ($newrev_type)"

            
            			echo "      from  $oldrev"

            
            		fi


            		# If this tag succeeds another, then show which tag it replaces

            
            		prevtag=$(git describe $newrev^ 2>/dev/null | sed 's/-g.*//')

            
            		if [ -n "$prevtag" ]; then

            
            			echo "  replaces  $prevtag"

            
            		fi


            		# Read the tag details

            
            		eval $(git cat-file tag $newrev | \

            
            			sed -n '4s/tagger \([^>]*>\)[^0-9]*\([0-9]*\).*/tagger="\1" ts="\2"/p')

            
            		tagged=$(date --date="1970-01-01 00:00:00 +0000 $ts seconds" +"$DATEFORMAT")


            		echo " tagged by  $tagger"

            
            		echo "        on  $tagged"


            		echo ""

            
            		echo $LOGBEGIN

            
            		echo ""


            		if [ -n "$prevtag" ]; then

            
            			git rev-list --pretty=short "$prevtag..$newrev" | git shortlog

            
            		else

            
            			git rev-list --pretty=short $newrev | git shortlog

            
            		fi


            		echo $LOGEND

            
            		echo ""

            
            		;;

            
            	*)

            
            		# By default, unannotated tags aren't allowed in; if

            
            		# they are though, it's debatable whether we would even want an

            
            		# email to be generated; however, I don't want to add another config

            
            		# option just for that.

            
            		#

            
            		# Unannotated tags are more about marking a point than releasing

            
            		# a version; therefore we don't do the shortlog summary that we

            
            		# do for annotated tags above - we simply show that the point has

            
            		# been marked, and print the log message for the marked point for

            
            		# reference purposes

            
            		#

            
            		# Note this section also catches any other reference type (although

            
            		# there aren't any) and deals with them in the same way.

            
            		if expr "$oldrev" : '0*$' >/dev/null

            
            		then

            
            			# If the old reference is "0000..0000" then this is a new tag

            
            			# and so oldrev is not valid

            
            			echo "  as a new  $refname_type"

            
            			echo "        to  $newrev ($newrev_type)"

            
            		else

            
            			echo "        to  $newrev ($newrev_type)"

            
            			echo "      from  $oldrev"

            
            		fi

            
            		echo ""

            
            		echo $LOGBEGIN

            
            		git-show --no-color --root -s $newrev

            
            		echo $LOGEND

            
            		echo ""

            
            		;;

            
            esac


            # Footer

            
            cat <<-EOF


            hooks/update

            
            ---

            
            Git Source Code Management System

            
            $0 $1 \\

            
              $2 \\

            
              $3

            
            EOF

            
            #) | cat >&2

            
            ) | /usr/sbin/sendmail -t


            # --- Finished

            
            exit 0
	#!/bin/sh
	#
	# An example hook script to mail out commit update information.
	# It can also blocks tags that aren't annotated.
	# Called by git-receive-pack with arguments: refname sha1-old sha1-new
	#
	# To enable this hook, make this file executable by "chmod +x update".
	#
	# Config
	# ------
	# hooks.mailinglist
	# This is the list that all pushes will go to; leave it blank to not send
	# emails frequently. The log email will list every log entry in full between
	# the old ref value and the new ref value.
	# hooks.announcelist
	# This is the list that all pushes of annotated tags will go to. Leave it
	# blank to just use the mailinglist field. The announce emails list the
	# short log summary of the changes since the last annotated tag
	# hooks.allowunannotated
	# This boolean sets whether unannotated tags will be allowed into the
	# repository. By default they won't be.
	#
	# Notes
	# -----
	# All emails have their subjects prefixed with "[SCM]" to aid filtering.
	# All emails include the headers "X-Git-Refname", "X-Git-Oldrev",
	# "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and info.

	# --- Constants
	EMAILPREFIX="[SCM] "
	LOGBEGIN="- Log -----------------------------------------------------------------"
	LOGEND="-----------------------------------------------------------------------"
	DATEFORMAT="%F %R %z"

	# --- Command line
	refname="$1"
	oldrev="$2"
	newrev="$3"

	# --- Safety check
	if [ -z "$GIT_DIR" ]; then
	echo "Don't run this script from the command line." >&2
	echo " (if you want, you could supply GIT_DIR then run" >&2
	echo " $0 <ref> <oldrev> <newrev>)" >&2
	exit 1
	fi

	if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
	echo "Usage: $0 <ref> <oldrev> <newrev>" >&2
	exit 1
	fi

	# --- Config
	projectdesc=$(cat $GIT_DIR/description)
	recipients=$(git-repo-config hooks.mailinglist)
	announcerecipients=$(git-repo-config hooks.announcelist)
	allowunannotated=$(git-repo-config --bool hooks.allowunannotated)

	# --- Check types
	newrev_type=$(git-cat-file -t "$newrev")

	case "$refname","$newrev_type" in
	refs/tags/*,commit)
	# un-annotated tag
	refname_type="tag"
	short_refname=${refname##refs/tags/}
	if [ $allowunannotated != "true" ]; then
	echo "*** The un-annotated tag, $short_refname is not allowed in this repository" >&2
	echo "*** Use 'git tag [ -a \| -s ]' for tags you want to propagate." >&2
	exit 1
	fi
	;;
	refs/tags/*,tag)
	# annotated tag
	refname_type="annotated tag"
	short_refname=${refname##refs/tags/}
	# change recipients
	if [ -n "$announcerecipients" ]; then
	recipients="$announcerecipients"
	fi
	;;
	refs/heads/*,commit)
	# branch
	refname_type="branch"
	short_refname=${refname##refs/heads/}
	;;
	refs/remotes/*,commit)
	# tracking branch
	refname_type="tracking branch"
	short_refname=${refname##refs/remotes/}
	# Should this even be allowed?
	echo "*** Push-update of tracking branch, $refname. No email generated." >&2
	exit 0
	;;
	*)
	# Anything else (is there anything else?)
	echo "*** Update hook: unknown type of update, \"$newrev_type\", to ref $refname" >&2
	exit 1
	;;
	esac

	# Check if we've got anyone to send to
	if [ -z "$recipients" ]; then
	# If the email isn't sent, then at least give the user some idea of what command
	# would generate the email at a later date
	echo "*** No recipients found - no email will be sent, but the push will continue" >&2
	echo "*** for $0 $1 $2 $3" >&2
	exit 0
	fi

	# --- Email parameters
	committer=$(git show --pretty=full -s $newrev \| grep "^Commit: " \| sed -e "s/^Commit: //")
	describe=$(git describe $newrev 2>/dev/null)
	if [ -z "$describe" ]; then
	describe=$newrev
	fi

	# --- Email (all stdout will be the email)
	(
	# Generate header
	cat <<-EOF
	From: $committer
	To: $recipients
	Subject: ${EMAILPREFIX}$projectdesc $refname_type, $short_refname now at $describe
	X-Git-Refname: $refname
	X-Git-Reftype: $refname_type
	X-Git-Oldrev: $oldrev
	X-Git-Newrev: $newrev

	Hello,

	This is an automated email from the git hooks/update script, it was
	generated because a ref change was pushed to the repository.

	Updating $refname_type, $short_refname,
	EOF

	case "$refname_type" in
	"tracking branch"\|branch)
	if expr "$oldrev" : '0*$' >/dev/null
	then
	# If the old reference is "0000..0000" then this is a new branch
	# and so oldrev is not valid
	echo " as a new $refname_type"
	echo " to $newrev ($newrev_type)"
	echo ""
	echo $LOGBEGIN
	# This shows all log entries that are not already covered by
	# another ref - i.e. commits that are now accessible from this
	# ref that were previously not accessible
	git-rev-parse --not --all \| git-rev-list --stdin --pretty $newref
	echo $LOGEND
	else
	# oldrev is valid
	oldrev_type=$(git-cat-file -t "$oldrev")

	# Now the problem is for cases like this:
	# * --- * --- * --- * (oldrev)
	# \
	# * --- * --- * (newrev)
	# i.e. there is no guarantee that newrev is a strict subset
	# of oldrev - (would have required a force, but that's allowed).
	# So, we can't simply say rev-list $oldrev..$newrev. Instead
	# we find the common base of the two revs and list from there
	baserev=$(git-merge-base $oldrev $newrev)

	# Commit with a parent
	for rev in $(git-rev-list $newrev ^$baserev)
	do
	revtype=$(git-cat-file -t "$rev")
	echo " via $rev ($revtype)"
	done
	if [ "$baserev" = "$oldrev" ]; then
	echo " from $oldrev ($oldrev_type)"
	else
	echo " based on $baserev"
	echo " from $oldrev ($oldrev_type)"
	echo ""
	echo "This ref update crossed a branch point; i.e. the old rev is not a strict subset"
	echo "of the new rev. This occurs, when you --force push a change in a situation"
	echo "like this:"
	echo ""
	echo " * -- * -- B -- O -- O -- O ($oldrev)"
	echo " \\"
	echo " N -- N -- N ($newrev)"
	echo ""
	echo "Therefore, we assume that you've already had alert emails for all of the O"
	echo "revisions, and now give you all the revisions in the N branch from the common"
	echo "base, B ($baserev), up to the new revision."
	fi
	echo ""
	echo $LOGBEGIN
	git-rev-list --pretty $newrev ^$baserev
	echo $LOGEND
	echo ""
	echo "Diffstat:"
	git-diff-tree --no-color --stat -M -C --find-copies-harder $newrev ^$baserev
	fi
	;;
	"annotated tag")
	# Should we allow changes to annotated tags?
	if expr "$oldrev" : '0*$' >/dev/null
	then
	# If the old reference is "0000..0000" then this is a new atag
	# and so oldrev is not valid
	echo " to $newrev ($newrev_type)"
	else
	echo " to $newrev ($newrev_type)"
	echo " from $oldrev"
	fi

	# If this tag succeeds another, then show which tag it replaces
	prevtag=$(git describe $newrev^ 2>/dev/null \| sed 's/-g.*//')
	if [ -n "$prevtag" ]; then
	echo " replaces $prevtag"
	fi

	# Read the tag details
	eval $(git cat-file tag $newrev \| \
	sed -n '4s/tagger \([^>]>\)[^0-9]\([0-9]\)./tagger="\1" ts="\2"/p')
	tagged=$(date --date="1970-01-01 00:00:00 +0000 $ts seconds" +"$DATEFORMAT")

	echo " tagged by $tagger"
	echo " on $tagged"

	echo ""
	echo $LOGBEGIN
	echo ""

	if [ -n "$prevtag" ]; then
	git rev-list --pretty=short "$prevtag..$newrev" \| git shortlog
	else
	git rev-list --pretty=short $newrev \| git shortlog
	fi

	echo $LOGEND
	echo ""
	;;
	*)
	# By default, unannotated tags aren't allowed in; if
	# they are though, it's debatable whether we would even want an
	# email to be generated; however, I don't want to add another config
	# option just for that.
	#
	# Unannotated tags are more about marking a point than releasing
	# a version; therefore we don't do the shortlog summary that we
	# do for annotated tags above - we simply show that the point has
	# been marked, and print the log message for the marked point for
	# reference purposes
	#
	# Note this section also catches any other reference type (although
	# there aren't any) and deals with them in the same way.
	if expr "$oldrev" : '0*$' >/dev/null
	then
	# If the old reference is "0000..0000" then this is a new tag
	# and so oldrev is not valid
	echo " as a new $refname_type"
	echo " to $newrev ($newrev_type)"
	else
	echo " to $newrev ($newrev_type)"
	echo " from $oldrev"
	fi
	echo ""
	echo $LOGBEGIN
	git-show --no-color --root -s $newrev
	echo $LOGEND
	echo ""
	;;
	esac

	# Footer
	cat <<-EOF

	hooks/update
	---
	Git Source Code Management System
	$0 $1 \\
	$2 \\
	$3
	EOF
	#) \| cat >&2
	) \| /usr/sbin/sendmail -t

	# --- Finished
	exit 0