--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+# 2011-10-31 - This now takes a --subjectformat argument. -otto
+
+import optparse
+import os
+import shutil
+import socket
+import sys
+import subprocess
+import tempfile
+import time
+
+Name = "git-notifier"
+Version = "0.3"
+CacheFile = ".%s.dat" % Name
+Separator = "\n>---------------------------------------------------------------\n"
+NoDiff = "[nodiff]"
+NoMail = "[nomail]"
+
+gitolite = "GL_USER" in os.environ
+whoami = os.environ["LOGNAME"]
+sender = os.environ["GL_USER"] if gitolite else whoami
+
+Options = [
+ # Name, argument, default, help,
+ ("allchanges", True, set(), "branches for which *all* changes are to be reported"),
+ ("debug", False, False, "enable debug output"),
+ ("diff", True, None, "mail out diffs between two revisions"),
+ ("emailprefix", True, "[git]", "Subject prefix for mails"),
+ ("hostname", True, socket.gethostname(), "host where the repository is hosted"),
+ ("log", True, "%s.log" % Name, "set log output"),
+ ("mailinglist", True, whoami, "destination address for mails"),
+ ("manual", True, None, "notifiy for a manually given set of revisions"),
+ ("maxdiffsize", True, 50, "limit the size of diffs in mails (KB)"),
+ ("noupdate", False, False, "do not update the state file"),
+ ("repouri", True, None, "full URI for the repository"),
+ ("sender", True, sender, "sender address for mails"),
+ ("link", True, None, "Link to insert into mail, %s will be replaced with revision"),
+ ("updateonly", False, False, "update state file only, no mails"),
+ ("users", True, None, "location of a user-to-email mapping file"),
+ ("subjectformat", True, "--pretty=format:%s (%h)", "Option to pass to git show to print out subject of a commit email.")
+]
+
+class State(object):
+ def __init__(self):
+ self.clear()
+
+ def clear(self):
+ self.heads = {}
+ self.tags = {}
+ self.revs = set()
+
+ self.reported = set() # Revs reported this run so far.
+
+ def writeTo(self, file):
+ if os.path.exists(CacheFile):
+ try:
+ shutil.move(CacheFile, CacheFile + ".bak")
+ except IOError:
+ pass
+
+ out = open(file, "w")
+ for (head, ref) in self.heads.items():
+ print >>out, "head", head, ref
+ for (tag, ref) in self.tags.items():
+ print >>out, "tag", tag, ref
+ for rev in self.revs:
+ print >>out, "rev", rev
+
+ def readFrom(self, file):
+ self.clear()
+
+ for line in open(file):
+
+ line = line.strip()
+ if not line or line.startswith("#"):
+ continue
+
+ m = line.split()
+
+ if len(m) == 3:
+ (type, key, val) = (m[0], m[1], m[2])
+ else:
+ # No heads.
+ (type, key, val) = (m[0], m[1], "")
+
+ if type == "head":
+ self.heads[key] = val
+ elif type == "tag":
+ self.tags[key] = val
+ elif type == "rev":
+ self.revs.add(key)
+ else:
+ error("unknown type %s in cache file" % type)
+
+class GitConfig(object):
+ def __init__(self, args):
+ self.parseArgs(args)
+ self.maxdiffsize *= 1024 # KBytes to bytes.
+
+ if self.allchanges and not isinstance(self.allchanges, set):
+ self.allchanges = set([head.strip() for head in self.allchanges.split(",")])
+ if not self.debug:
+ self.log = open(self.log, "a")
+ else:
+ self.log = sys.stderr
+
+ if not self.users and "GL_ADMINDIR" in os.environ:
+ users = os.path.join(os.environ["GL_ADMINDIR"], "conf/sender.cfg")
+ if os.path.exists(users):
+ self.users = users
+
+ self.readUsers()
+
+ def parseArgs(self, args):
+ parser = optparse.OptionParser(version=Version)
+ for (name, arg, default, help) in Options:
+ defval = self._git_config(name, default)
+
+ if isinstance(default, int):
+ defval = int(defval)
+ if not arg:
+ defval = bool(defval)
+ if not arg:
+ action = "store_true" if not default else "store_false"
+ parser.add_option("--%s" % name, action=action, dest=name, default=defval, help=help)
+ else:
+ type = "string" if not isinstance(default, int) else "int"
+ parser.add_option("--%s" % name, action="store", type=type, default=defval, dest=name, help=help)
+
+ (options, args) = parser.parse_args(args)
+ if len(args) != 0:
+ parser.error("incorrect number of arguments")
+
+ for (name, arg, default, help) in Options:
+ self.__dict__[name] = options.__dict__[name]
+
+ def readUsers(self):
+ if self.users and os.path.exists(self.users):
+ for line in open(self.users):
+ line = line.strip()
+ if not line or line.startswith("#"):
+ continue
+
+ m = line.split()
+
+ if self.sender == m[0]:
+ self.sender = " ".join(m[1:])
+ break
+
+ def _git_config(self, key, default):
+ cfg = git(["config hooks.%s" % key])
+ return cfg[0] if cfg else default
+
+
+def log(msg):
+ print >>Config.log, "%s - %s" % (time.asctime(), msg)
+
+def error(msg):
+ log("Error: %s" % msg)
+ sys.exit(1)
+
+
+def git(args, stdout_to=subprocess.PIPE, all=False):
+ if isinstance(args, tuple) or isinstance(args, list):
+ args = " ".join(args)
+
+ try:
+ if Config.debug:
+ print >>sys.stderr, "> git " + args
+ except NameError:
+ # Config may not be defined yet.
+ pass
+
+ try:
+ child = subprocess.Popen("git " + args, shell=True, stdin=None, stdout=stdout_to, stderr=subprocess.PIPE)
+ (stdout, stderr) = child.communicate()
+ except OSError, e:
+ error("cannot start git: %s" % str(e))
+
+ if child.returncode != 0 and stderr:
+ msg = ": %s" % stderr if stderr else ""
+ error("git child failed with exit code %d%s" % (child.returncode, msg))
+
+ if stdout_to != subprocess.PIPE:
+ return []
+
+ if not all:
+ return [line.strip() for line in stdout.split("\n") if line]
+ else:
+ return stdout.split("\n")
+
+def getHeads(state):
+ for (rev, head) in [head.split() for head in git("show-ref --heads")]:
+ if head.startswith("refs/heads/"):
+ head = head[11:]
+
+ state.heads[head] = rev
+
+def getTags(state):
+ for (rev, tag) in [head.split() for head in git("show-ref --tags")]:
+ # We are only interested in annotaged tags.
+ type = git("cat-file -t %s" % rev)[0]
+
+ if type == "tag":
+ if tag.startswith("refs/tags/"):
+ tag= tag[10:]
+
+ state.tags[tag] = rev
+
+def getReachableRefs(state):
+ for rev in git(["rev-list"] + state.heads.keys() + state.tags.keys()):
+ state.revs.add(rev)
+
+def getCurrent():
+ state = State()
+ getHeads(state)
+ getTags(state)
+ getReachableRefs(state)
+
+ return state
+
+
+Tmps = []
+
+def makeTmp():
+ global Tmps
+ (fd, fname) = tempfile.mkstemp(prefix="%s-" % Name, suffix=".tmp")
+ Tmps += [fname]
+ return (os.fdopen(fd, "w"), fname)
+
+def deleteTmps():
+ for tmp in Tmps:
+ os.unlink(tmp)
+
+def mailTag(key, value):
+ return "%-11s: %s" % (key, value)
+
+def generateMailHeader(subject):
+ repo = Config.repouri
+ if not repo:
+ if gitolite:
+ # Gitolite version.
+ repo = "ssh://%s@%s/%s" % (whoami, Config.hostname, os.path.basename(os.getcwd()))
+ else:
+ # Standard version.
+ repo = "ssh://%s/%s" % (Config.hostname, os.path.basename(os.getcwd()))
+ if repo.endswith(".git"):
+ repo = repo[0:-4]
+
+ (out, fname) = makeTmp()
+ print >>out, """From: %s
+To: %s
+Subject: %s %s
+X-Git-Repository: %s
+X-Mailer: %s %s
+
+%s
+
+""" % (Config.sender, Config.mailinglist, Config.emailprefix, subject, repo,
+ Name, Version, mailTag("Repository", repo)),
+ return (out, fname)
+
+
+def sendMail(out, fname):
+ out.close()
+
+ if Config.debug:
+ for line in open(fname):
+ print " |", line,
+ print ""
+ else:
+ stdin = subprocess.Popen("/usr/sbin/sendmail -t", shell=True, stdin=subprocess.PIPE).stdin
+ for line in open(fname):
+ print >>stdin, line,
+ stdin.close()
+
+ # Wait a bit in case we're going to send more mails. Otherwise, the mails
+ # get sent back-to-back and are likely to end up with identical timestamps,
+ # which may then make them appear to have arrived in the wrong order.
+ if not Config.debug:
+ time.sleep(2)
+
+def entryAdded(key, value, rev):
+ log("New %s %s" % (key, value))
+
+ (out, fname) = generateMailHeader("%s '%s' created" % (key, value))
+
+ print >>out, mailTag("New %s" % key, value)
+ print >>out, mailTag("Referencing", rev)
+
+ sendMail(out, fname)
+
+def entryDeleted(key, value):
+ log("Deleted %s %s" % (key, value))
+
+ (out, fname) = generateMailHeader("%s '%s' deleted" % (key, value))
+
+ print >>out, mailTag("Deleted %s" % key, value)
+
+ sendMail(out, fname)
+
+# Sends a mail for a notification consistent of two parts: (1) the output of a
+# show command, and (2) the output of a diff command.
+def sendChangeMail(subject, heads, show_cmd, diff_cmd):
+
+ (out, fname) = generateMailHeader(subject)
+
+ multi = "es" if len(heads) > 1 else ""
+ heads = ",".join(heads)
+
+ print >>out, mailTag("On branch%s" % multi, heads)
+
+ if Config.link:
+ url = Config.link.replace("%s", rev)
+ print >>out, ""
+ print >>out, mailTag("Link", url)
+
+ footer = ""
+ show = git(show_cmd)
+
+ for line in show:
+ if NoDiff in line:
+ break
+
+ if NoMail in line:
+ return
+
+ else:
+ (tmp, tname) = makeTmp()
+ diff = git(diff_cmd, stdout_to=tmp)
+ tmp.close()
+
+ size = os.path.getsize(tname)
+
+ if size > Config.maxdiffsize:
+ footer = "\nDiff suppressed because of size. To see it, use:\n\n git %s" % diff_cmd
+ tname = None
+
+ print >>out, Separator
+
+ for line in git(show_cmd, all=True):
+ if line == "---":
+ print >>out, Separator
+ else:
+ print >>out, line
+
+ print >>out, Separator
+
+ if tname:
+ for line in open(tname):
+ print >>out, line,
+
+ print >>out, footer
+
+ if Config.debug:
+ print >>out, "-- "
+ print >>out, "debug: show_cmd = git %s" % show_cmd
+ print >>out, "debug: diff_cmd = git %s" % diff_cmd
+
+ sendMail(out, fname)
+
+# Sends notification for a specific revision.
+def commit(current, rev):
+ if rev in current.reported:
+ # Already reported in this run of the script.
+ log("New revision %s, but already reported this time" % rev)
+
+ log("New revision %s" % rev)
+ current.reported.add(rev)
+
+ heads = [head.split()[-1] for head in git("branch --contains=%s" % rev)]
+
+ if len(set(heads) - Config.allchanges) == 0:
+ # We have reported full diffs for all already.
+ return
+
+ subject = git("show '%s' -s %s" % (Config.subjectformat, rev))
+ subject = "%s: %s" % (",".join(heads), subject[0])
+
+ show_cmd = "show -s --no-color --find-copies-harder --pretty=medium %s" % rev
+ diff_cmd = "diff --patch-with-stat --no-color --find-copies-harder --ignore-space-at-eol ^%s~1 %s " % (rev, rev)
+
+ sendChangeMail(subject, heads, show_cmd, diff_cmd)
+
+# Sends a diff between two revisions.
+def diff(head, first, last):
+ log("Diffing %s..%s" % (first, last))
+
+ subject = git("show '%s' -s %s" % (Config.subjectformat, last))
+ subject = "%s diff: %s" % (head, subject[0])
+
+ heads = [head]
+
+ show_cmd = "show -s --no-color --find-copies-harder --pretty=medium %s" % last
+ diff_cmd = "diff --patch-with-stat -m --no-color --find-copies-harder --ignore-space-at-eol %s %s" % (first, last)
+
+ sendChangeMail(subject, heads, show_cmd, diff_cmd)
+
+# Sends pair-wise diffs for a path of revisions.
+def diffPath(head, revs):
+ last = None
+
+ for rev in revs:
+ if last:
+ diff(head, last, rev)
+ last = rev
+
+# Sends a commit notifications for a set of revisions, independent of whether
+# they already have been reported.
+def reportPath(current, revs):
+ for rev in revs:
+ commit(current, rev)
+
+# Sends a summary mail for a set of revisions.
+def headMoved(head, path):
+ log("Head moved: %s -> %s" % (head, path[-1]))
+
+ subject = git("show '%s' -s %s" % (Config.subjectformat, path[-1]))
+
+ (out, fname) = generateMailHeader("%s's head updated: %s" % (head, subject[0]))
+
+ print >>out, "Branch '%s' now includes:" % head
+ print >>out, ""
+
+ for rev in path:
+ print >>out, " ", git("show -s --pretty=oneline --abbrev-commit %s" % rev)[0]
+
+ sendMail(out, fname)
+
+Config = GitConfig(sys.argv[1:])
+
+log("Running for %s" % os.getcwd())
+
+if Config.debug:
+ for (name, arg, default, help) in Options:
+ print >>sys.stderr, "[Option %s: %s]" % (name, Config.__dict__[name])
+
+cache = State()
+
+if os.path.exists(CacheFile):
+ cache.readFrom(CacheFile)
+ report = (not Config.updateonly)
+else:
+ log("Initial run. Not generating any mails, just recording current state.")
+ report = False
+
+current = getCurrent()
+
+if Config.diff:
+ # Manual diff mode. The argument must be of the form "[old-rev..]new-rev".
+ path = [rev.strip() for rev in Config.diff.split("..")]
+ if len(path) == 1:
+ path = ("%s~2" % path[0], path[0]) # sic! ~2.
+ else:
+ path = ("%s~1" % path[0], path[1])
+
+ revs = git(["rev-list", "--reverse", "--first-parent", "--date-order", path[1], "^%s" % path[0]])
+ diffPath("<manual-diff>", revs)
+
+ sys.exit(0)
+
+if Config.manual:
+ # Manual report mode. The argument must be of the form "[old-rev..]new-rev".
+ path = [rev.strip() for rev in Config.manual.split("..")]
+ if len(path) == 1:
+ path = ("%s~1" % path[0], path[0])
+
+ revs = git(["rev-list", "--reverse", "--date-order", path[1], "^%s" % path[0]])
+ reportPath(current, revs)
+
+ sys.exit(0)
+
+if report:
+ # Check for changes to the set of heads.
+ old = set(cache.heads.keys())
+ new = set(current.heads.keys())
+
+ for head in (new - old):
+ entryAdded("branch", head, current.heads[head])
+
+ for head in (old - new):
+ entryDeleted("branch", head)
+
+ stable_heads = new & old
+ Config.allchanges = Config.allchanges & stable_heads
+
+ # Check tags.
+ old = set(cache.tags.keys())
+ new = set(current.tags.keys())
+
+ for tag in (new - old):
+ entryAdded("tag", tag, current.tags[tag])
+
+ for tag in (old - new):
+ entryDeleted("tag", tag)
+
+ # Do complete reports for the heads we want to see everything for.
+ for head in Config.allchanges:
+ old_rev = cache.heads[head]
+ new_rev = current.heads[head]
+
+ revs = git(["rev-list", "--reverse", "--first-parent", "--date-order", new_rev, "^%s~1" % old_rev])
+ diffPath(head, revs)
+
+ # Check for unreported commits.
+
+ # Sort updates by time.
+ def _key(rev):
+ ts = git("show -s '--pretty=format:%%ct' %s" % rev)
+ return int(ts[0])
+
+ old = set(cache.revs)
+ new = set(current.revs)
+
+ new_revs = new - old
+
+ for rev in sorted(new_revs, key=_key):
+ commit(current, rev)
+
+ # See if heads have moved to include already reported revisions.
+ for head in stable_heads:
+
+ if head in Config.allchanges:
+ # Already done complete diffs.
+ continue
+
+ old_rev = cache.heads[head]
+ new_rev = current.heads[head]
+
+ path = git(["rev-list", "--reverse", "--date-order", new_rev, "^%s" % old_rev])
+
+ if len(set(path) - new_revs):
+ headMoved(head, path)
+
+if not Config.noupdate:
+ current.writeTo(CacheFile)
+
+deleteTmps()
+
--- /dev/null
+#!/bin/sh
+#
+# Copyright (c) 2007 Andy Parkins
+#
+# An example hook script to mail out commit update information. This hook
+# sends emails listing new revisions to the repository introduced by the
+# change being reported. The rule is that (for branch updates) each commit
+# will appear on one email and one email only.
+#
+# This hook is stored in the contrib/hooks directory. Your distribution
+# will have put this somewhere standard. You should make this script
+# executable then link to it in the repository you would like to use it in.
+# For example, on debian the hook is stored in
+# /usr/share/git-core/contrib/hooks/post-receive-email:
+#
+# chmod a+x post-receive-email
+# cd /path/to/your/repository.git
+# ln -sf /usr/share/git-core/contrib/hooks/post-receive-email hooks/post-receive
+#
+# This hook script assumes it is enabled on the central repository of a
+# project, with all users pushing only to it and not between each other. It
+# will still work if you don't operate in that style, but it would become
+# possible for the email to be from someone other than the person doing the
+# push.
+#
+# To help with debugging and use on pre-v1.5.1 git servers, this script will
+# also obey the interface of hooks/update, taking its arguments on the
+# command line. Unfortunately, hooks/update is called once for each ref.
+# To avoid firing one email per ref, this script just prints its output to
+# the screen when used in this mode. The output can then be redirected if
+# wanted.
+#
+# Config
+# ------
+# hooks.mailinglist
+# This is the list that all pushes will go to; leave it blank to not send
+# emails for every ref update.
+# hooks.announcelist
+# This is the list that all pushes of annotated tags will go to. Leave it
+# blank to default to the mailinglist field. The announce emails lists
+# the short log summary of the changes since the last annotated tag.
+# hooks.envelopesender
+# If set then the -f option is passed to sendmail to allow the envelope
+# sender address to be set
+# hooks.emailprefix
+# All emails have their subjects prefixed with this prefix, or "[SCM]"
+# if emailprefix is unset, to aid filtering
+# hooks.showrev
+# The shell command used to format each revision in the email, with
+# "%s" replaced with the commit id. Defaults to "git rev-list -1
+# --pretty %s", displaying the commit id, author, date and log
+# message. To list full patches separated by a blank line, you
+# could set this to "git show -C %s; echo".
+# To list a gitweb/cgit URL *and* a full patch for each change set, use this:
+# "t=%s; printf 'http://.../?id=%%s' \$t; echo;echo; git show -C \$t; echo"
+# Be careful if "..." contains things that will be expanded by shell "eval"
+# or printf.
+# hooks.emailmaxlines
+# The maximum number of lines that should be included in the generated
+# email body. If not specified, there is no limit.
+# Lines beyond the limit are suppressed and counted, and a final
+# line is added indicating the number of suppressed lines.
+# hooks.diffopts
+# Alternate options for the git diff-tree invocation that shows changes.
+# Default is "--stat --summary --find-copies-harder". Add -p to those
+# options to include a unified diff of changes in addition to the usual
+# summary output.
+#
+# Notes
+# -----
+# All emails include the headers "X-Git-Refname", "X-Git-Oldrev",
+# "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and
+# give information for debugging.
+#
+
+# ---------------------------- Functions
+
+#
+# Function to prepare for email generation. This decides what type
+# of update this is and whether an email should even be generated.
+#
+prep_for_email()
+{
+ # --- Arguments
+ oldrev=$(git rev-parse $1)
+ newrev=$(git rev-parse $2)
+ refname="$3"
+ maxlines=$4
+
+ # --- Interpret
+ # 0000->1234 (create)
+ # 1234->2345 (update)
+ # 2345->0000 (delete)
+ if expr "$oldrev" : '0*$' >/dev/null
+ then
+ change_type="create"
+ else
+ if expr "$newrev" : '0*$' >/dev/null
+ then
+ change_type="delete"
+ else
+ change_type="update"
+ fi
+ fi
+
+ # --- Get the revision types
+ newrev_type=$(git cat-file -t $newrev 2> /dev/null)
+ oldrev_type=$(git cat-file -t "$oldrev" 2> /dev/null)
+ case "$change_type" in
+ create|update)
+ rev="$newrev"
+ rev_type="$newrev_type"
+ ;;
+ delete)
+ rev="$oldrev"
+ rev_type="$oldrev_type"
+ ;;
+ esac
+
+ # The revision type tells us what type the commit is, combined with
+ # the location of the ref we can decide between
+ # - working branch
+ # - tracking branch
+ # - unannoted tag
+ # - annotated tag
+ case "$refname","$rev_type" in
+ refs/tags/*,commit)
+ # un-annotated tag
+ refname_type="tag"
+ short_refname=${refname##refs/tags/}
+ ;;
+ 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/}
+ echo >&2 "*** Push-update of tracking branch, $refname"
+ echo >&2 "*** - no email generated."
+ return 1
+ ;;
+ *)
+ # Anything else (is there anything else?)
+ echo >&2 "*** Unknown type of update to $refname ($rev_type)"
+ echo >&2 "*** - no email generated"
+ return 1
+ ;;
+ esac
+
+ # Check if we've got anyone to send to
+ if [ -z "$recipients" ]; then
+ case "$refname_type" in
+ "annotated tag")
+ config_name="hooks.announcelist"
+ ;;
+ *)
+ config_name="hooks.mailinglist"
+ ;;
+ esac
+ echo >&2 "*** $config_name is not set so no email will be sent"
+ echo >&2 "*** for $refname update $oldrev->$newrev"
+ return 1
+ fi
+
+ return 0
+}
+
+#
+# Top level email generation function. This calls the appropriate
+# body-generation routine after outputting the common header.
+#
+# Note this function doesn't actually generate any email output, that is
+# taken care of by the functions it calls:
+# - generate_email_header
+# - generate_create_XXXX_email
+# - generate_update_XXXX_email
+# - generate_delete_XXXX_email
+# - generate_email_footer
+#
+# Note also that this function cannot 'exit' from the script; when this
+# function is running (in hook script mode), the send_mail() function
+# is already executing in another process, connected via a pipe, and
+# if this function exits without, whatever has been generated to that
+# point will be sent as an email... even if nothing has been generated.
+#
+generate_email()
+{
+ # Email parameters
+ # The email subject will contain the best description of the ref
+ # that we can build from the parameters
+ describe=$(git describe $rev 2>/dev/null)
+ if [ -z "$describe" ]; then
+ describe=$rev
+ fi
+
+ generate_email_header
+
+ # Call the correct body generation function
+ fn_name=general
+ case "$refname_type" in
+ "tracking branch"|branch)
+ fn_name=branch
+ ;;
+ "annotated tag")
+ fn_name=atag
+ ;;
+ esac
+
+ if [ -z "$maxlines" ]; then
+ generate_${change_type}_${fn_name}_email
+ else
+ generate_${change_type}_${fn_name}_email | limit_lines $maxlines
+ fi
+
+ generate_email_footer
+}
+
+generate_email_header()
+{
+ # --- Email (all stdout will be the email)
+ # Generate header
+ cat <<-EOF
+ To: $recipients
+ Subject: ${emailprefix}$projectdesc $refname_type $short_refname ${change_type}d. $describe
+ X-Git-Refname: $refname
+ X-Git-Reftype: $refname_type
+ X-Git-Oldrev: $oldrev
+ X-Git-Newrev: $newrev
+
+ The $refname_type, $short_refname has been ${change_type}d
+ EOF
+}
+
+generate_email_footer()
+{
+ SPACE=" "
+ cat <<-EOF
+
+
+ --${SPACE}
+ $projectdesc
+ EOF
+}
+
+# --------------- Branches
+
+#
+# Called for the creation of a branch
+#
+generate_create_branch_email()
+{
+ # This is a new branch and so oldrev is not valid
+ echo " at $newrev ($newrev_type)"
+ echo ""
+
+ echo $LOGBEGIN
+ show_new_revisions
+ echo $LOGEND
+}
+
+#
+# Called for the change of a pre-existing branch
+#
+generate_update_branch_email()
+{
+ # Consider this:
+ # 1 --- 2 --- O --- X --- 3 --- 4 --- N
+ #
+ # O is $oldrev for $refname
+ # N is $newrev for $refname
+ # X is a revision pointed to by some other ref, for which we may
+ # assume that an email has already been generated.
+ # In this case we want to issue an email containing only revisions
+ # 3, 4, and N. Given (almost) by
+ #
+ # git rev-list N ^O --not --all
+ #
+ # The reason for the "almost", is that the "--not --all" will take
+ # precedence over the "N", and effectively will translate to
+ #
+ # git rev-list N ^O ^X ^N
+ #
+ # So, we need to build up the list more carefully. git rev-parse
+ # will generate a list of revs that may be fed into git rev-list.
+ # We can get it to make the "--not --all" part and then filter out
+ # the "^N" with:
+ #
+ # git rev-parse --not --all | grep -v N
+ #
+ # Then, using the --stdin switch to git rev-list we have effectively
+ # manufactured
+ #
+ # git rev-list N ^O ^X
+ #
+ # This leaves a problem when someone else updates the repository
+ # while this script is running. Their new value of the ref we're
+ # working on would be included in the "--not --all" output; and as
+ # our $newrev would be an ancestor of that commit, it would exclude
+ # all of our commits. What we really want is to exclude the current
+ # value of $refname from the --not list, rather than N itself. So:
+ #
+ # git rev-parse --not --all | grep -v $(git rev-parse $refname)
+ #
+ # Get's us to something pretty safe (apart from the small time
+ # between refname being read, and git rev-parse running - for that,
+ # I give up)
+ #
+ #
+ # Next problem, consider this:
+ # * --- B --- * --- O ($oldrev)
+ # \
+ # * --- X --- * --- N ($newrev)
+ #
+ # That is to say, there is no guarantee that oldrev is a strict
+ # subset of newrev (it 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.
+ #
+ # As above, we need to take into account the presence of X; if
+ # another branch is already in the repository and points at some of
+ # the revisions that we are about to output - we don't want them.
+ # The solution is as before: git rev-parse output filtered.
+ #
+ # Finally, tags: 1 --- 2 --- O --- T --- 3 --- 4 --- N
+ #
+ # Tags pushed into the repository generate nice shortlog emails that
+ # summarise the commits between them and the previous tag. However,
+ # those emails don't include the full commit messages that we output
+ # for a branch update. Therefore we still want to output revisions
+ # that have been output on a tag email.
+ #
+ # Luckily, git rev-parse includes just the tool. Instead of using
+ # "--all" we use "--branches"; this has the added benefit that
+ # "remotes/" will be ignored as well.
+
+ # List all of the revisions that were removed by this update, in a
+ # fast-forward update, this list will be empty, because rev-list O
+ # ^N is empty. For a non-fast-forward, O ^N is the list of removed
+ # revisions
+ fast_forward=""
+ rev=""
+ for rev in $(git rev-list $newrev..$oldrev)
+ do
+ revtype=$(git cat-file -t "$rev")
+ echo " discards $rev ($revtype)"
+ done
+ if [ -z "$rev" ]; then
+ fast_forward=1
+ fi
+
+ # List all the revisions from baserev to newrev in a kind of
+ # "table-of-contents"; note this list can include revisions that
+ # have already had notification emails and is present to show the
+ # full detail of the change from rolling back the old revision to
+ # the base revision and then forward to the new revision
+ for rev in $(git rev-list $oldrev..$newrev)
+ do
+ revtype=$(git cat-file -t "$rev")
+ shortrev=$(git log -n 1 --pretty="format:%h" "$rev")
+ author=$(git log -n 1 --pretty="format:%an" "$rev")
+
+ # word wrap the subject line
+ subject=$(git log -n 1 --pretty="format:%s" "$rev" | fold -w 64 -s)
+ # seperate out the 1st subject line so we can align each line
+ subject_line_1=$(echo "${subject}" | sed -n '1p')
+ subject_remaining_lines=$(echo "${subject}" | sed '1d')
+
+ printf " via $revtype $shortrev %20s: %s\n" "$author" "$subject_line_1"
+ echo "${subject_remaining_lines}" | while read line; do
+ printf "%43s %s\n" ' ' "${line}";
+ done
+ done
+
+ if [ "$fast_forward" ]; then
+ shortrev=$(git log -n 1 --pretty="format:%h" "$oldrev")
+ author=$(git log -n 1 --pretty="format:%an" "$oldrev")
+
+ # word wrap the subject line
+ subject=$(git log -n 1 --pretty="format:%s" "$oldrev" | fold -w 64 -s)
+ # seperate out the 1st subject line so we can align each line
+ subject_line_1=$(echo "${subject}" | sed -n '1p')
+ subject_remaining_lines=$(echo "${subject}" | sed '1d')
+
+ printf " from $oldrev_type $shortrev %20s: %s\n" "$author" "$subject_line_1"
+ echo "${subject_remaining_lines}" | while read line; do
+ printf "%43s %s\n" ' ' "${line}";
+ done
+ else
+ # 1. Existing revisions were removed. In this case newrev
+ # is a subset of oldrev - this is the reverse of a
+ # fast-forward, a rewind
+ # 2. New revisions were added on top of an old revision,
+ # this is a rewind and addition.
+
+ # (1) certainly happened, (2) possibly. When (2) hasn't
+ # happened, we set a flag to indicate that no log printout
+ # is required.
+
+ echo ""
+
+ # Find the common ancestor of the old and new revisions and
+ # compare it with newrev
+ baserev=$(git merge-base $oldrev $newrev)
+ rewind_only=""
+ if [ "$baserev" = "$newrev" ]; then
+ echo "This update discarded existing revisions and left the branch pointing at"
+ echo "a previous point in the repository history."
+ echo ""
+ echo " * -- * -- N ($newrev)"
+ echo " \\"
+ echo " O -- O -- O ($oldrev)"
+ echo ""
+ echo "The removed revisions are not necessarilly gone - if another reference"
+ echo "still refers to them they will stay in the repository."
+ rewind_only=1
+ else
+ echo "This update added new revisions after undoing existing revisions. That is"
+ echo "to say, the old revision is not a strict subset of the new revision. This"
+ echo "situation occurs when you --force push a change and generate a repository"
+ echo "containing something like this:"
+ echo ""
+ echo " * -- * -- B -- O -- O -- O ($oldrev)"
+ echo " \\"
+ echo " N -- N -- N ($newrev)"
+ echo ""
+ echo "When this happens we assume that you've already had alert emails for all"
+ echo "of the O revisions, and so we here report only the revisions in the N"
+ echo "branch from the common base, B."
+ fi
+ fi
+
+ # The diffstat is shown from the old revision to the new revision.
+ # This is to show the truth of what happened in this change.
+ # There's no point showing the stat from the base to the new
+ # revision because the base is effectively a random revision at this
+ # point - the user will be interested in what this revision changed
+ # - including the undoing of previous revisions in the case of
+ # non-fast-forward updates.
+ echo ""
+ echo "Summary of changes:"
+ git diff-tree $diffopts $oldrev..$newrev
+
+
+ echo ""
+ if [ -z "$rewind_only" ]; then
+ echo $LOGBEGIN
+ show_new_revisions
+
+ # XXX: Need a way of detecting whether git rev-list actually
+ # outputted anything, so that we can issue a "no new
+ # revisions added by this update" message
+
+ echo $LOGEND
+ else
+ echo "No new revisions were added by this update."
+ fi
+}
+
+#
+# Called for the deletion of a branch
+#
+generate_delete_branch_email()
+{
+ echo " was $oldrev"
+ echo ""
+ echo $LOGEND
+ git show -s --pretty=oneline $oldrev
+ echo $LOGEND
+}
+
+# --------------- Annotated tags
+
+#
+# Called for the creation of an annotated tag
+#
+generate_create_atag_email()
+{
+ echo " at $newrev ($newrev_type)"
+
+ generate_atag_email
+}
+
+#
+# Called for the update of an annotated tag (this is probably a rare event
+# and may not even be allowed)
+#
+generate_update_atag_email()
+{
+ echo " to $newrev ($newrev_type)"
+ echo " from $oldrev (which is now obsolete)"
+
+ generate_atag_email
+}
+
+#
+# Called when an annotated tag is created or changed
+#
+generate_atag_email()
+{
+ # Use git for-each-ref to pull out the individual fields from the
+ # tag
+ eval $(git for-each-ref --shell --format='
+ tagobject=%(*objectname)
+ tagtype=%(*objecttype)
+ tagger=%(taggername)
+ tagged=%(taggerdate)' $refname
+ )
+
+ echo " tagging $tagobject ($tagtype)"
+ case "$tagtype" in
+ commit)
+
+ # If the tagged object is a commit, then we assume this is a
+ # release, and so we calculate which tag this tag is
+ # replacing
+ prevtag=$(git describe --abbrev=0 $newrev^ 2>/dev/null)
+
+ if [ -n "$prevtag" ]; then
+ echo " replaces $prevtag"
+ fi
+ ;;
+ *)
+ echo " length $(git cat-file -s $tagobject) bytes"
+ ;;
+ esac
+ echo " tagged by $tagger"
+ echo " on $tagged"
+
+ echo ""
+ echo $LOGBEGIN
+
+ # Show the content of the tag message; this might contain a change
+ # log or release notes so is worth displaying.
+ git cat-file tag $newrev | sed -e '1,/^$/d'
+
+ echo ""
+ case "$tagtype" in
+ commit)
+ # Only commit tags make sense to have rev-list operations
+ # performed on them
+ if [ -n "$prevtag" ]; then
+ # Show changes since the previous release
+ git rev-list --pretty=short "$prevtag..$newrev" | git shortlog
+ else
+ # No previous tag, show all the changes since time
+ # began
+ git rev-list --pretty=short $newrev | git shortlog
+ fi
+ ;;
+ *)
+ # XXX: Is there anything useful we can do for non-commit
+ # objects?
+ ;;
+ esac
+
+ echo $LOGEND
+}
+
+#
+# Called for the deletion of an annotated tag
+#
+generate_delete_atag_email()
+{
+ echo " was $oldrev"
+ echo ""
+ echo $LOGEND
+ git show -s --pretty=oneline $oldrev
+ echo $LOGEND
+}
+
+# --------------- General references
+
+#
+# Called when any other type of reference is created (most likely a
+# non-annotated tag)
+#
+generate_create_general_email()
+{
+ echo " at $newrev ($newrev_type)"
+
+ generate_general_email
+}
+
+#
+# Called when any other type of reference is updated (most likely a
+# non-annotated tag)
+#
+generate_update_general_email()
+{
+ echo " to $newrev ($newrev_type)"
+ echo " from $oldrev"
+
+ generate_general_email
+}
+
+#
+# Called for creation or update of any other type of reference
+#
+generate_general_email()
+{
+ # 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.
+
+ echo ""
+ if [ "$newrev_type" = "commit" ]; then
+ echo $LOGBEGIN
+ git show --no-color --root -s --pretty=medium $newrev
+ echo $LOGEND
+ else
+ # What can we do here? The tag marks an object that is not
+ # a commit, so there is no log for us to display. It's
+ # probably not wise to output git cat-file as it could be a
+ # binary blob. We'll just say how big it is
+ echo "$newrev is a $newrev_type, and is $(git cat-file -s $newrev) bytes long."
+ fi
+}
+
+#
+# Called for the deletion of any other type of reference
+#
+generate_delete_general_email()
+{
+ echo " was $oldrev"
+ echo ""
+ echo $LOGEND
+ git show -s --pretty=oneline $oldrev
+ echo $LOGEND
+}
+
+
+# --------------- Miscellaneous utilities
+
+#
+# Show new revisions as the user would like to see them in the email.
+#
+show_new_revisions()
+{
+ # 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
+ # (see generate_update_branch_email for the explanation of this
+ # command)
+
+ # Revision range passed to rev-list differs for new vs. updated
+ # branches.
+ if [ "$change_type" = create ]
+ then
+ # Show all revisions exclusive to this (new) branch.
+ revspec=$newrev
+ else
+ # Branch update; show revisions not part of $oldrev.
+ revspec=$oldrev..$newrev
+ fi
+
+ other_branches=$(git for-each-ref --format='%(refname)' refs/heads/ |
+ grep -F -v $refname)
+ git rev-parse --not $other_branches |
+ if [ -z "$custom_showrev" ]
+ then
+ git rev-list --pretty --stdin $revspec
+ else
+ git rev-list --stdin $revspec |
+ while read onerev
+ do
+ eval $(printf "$custom_showrev" $onerev)
+ done
+ fi
+}
+
+
+limit_lines()
+{
+ lines=0
+ skipped=0
+ while IFS="" read -r line; do
+ lines=$((lines + 1))
+ if [ $lines -gt $1 ]; then
+ skipped=$((skipped + 1))
+ else
+ printf "%s\n" "$line"
+ fi
+ done
+ if [ $skipped -ne 0 ]; then
+ echo "... $skipped lines suppressed ..."
+ fi
+}
+
+
+send_mail()
+{
+ if [ -n "$envelopesender" ]; then
+ /usr/sbin/sendmail -t -f "$envelopesender"
+ else
+ /usr/sbin/sendmail -t
+ fi
+}
+
+# ---------------------------- main()
+
+# --- Constants
+LOGBEGIN="- Log -----------------------------------------------------------------"
+LOGEND="-----------------------------------------------------------------------"
+
+# --- Config
+# Set GIT_DIR either from the working directory, or from the environment
+# variable.
+GIT_DIR=$(git rev-parse --git-dir 2>/dev/null)
+if [ -z "$GIT_DIR" ]; then
+ echo >&2 "fatal: post-receive: GIT_DIR not set"
+ exit 1
+fi
+
+projectdesc=$(sed -ne '1p' "$GIT_DIR/description" 2>/dev/null)
+# Check if the description is unchanged from it's default, and shorten it to
+# a more manageable length if it is
+if expr "$projectdesc" : "Unnamed repository.*$" >/dev/null
+then
+ projectdesc="UNNAMED PROJECT"
+fi
+
+recipients=$(git config hooks.mailinglist)
+announcerecipients=$(git config hooks.announcelist)
+envelopesender=$(git config hooks.envelopesender)
+emailprefix=$(git config hooks.emailprefix || echo '[SCM] ')
+custom_showrev=$(git config hooks.showrev)
+maxlines=$(git config hooks.emailmaxlines)
+diffopts=$(git config hooks.diffopts)
+: ${diffopts:="--stat --summary --find-copies-harder"}
+
+# --- Main loop
+# Allow dual mode: run from the command line just like the update hook, or
+# if no arguments are given then run as a hook script
+if [ -n "$1" -a -n "$2" -a -n "$3" ]; then
+ # Output to the terminal in command line mode - if someone wanted to
+ # resend an email; they could redirect the output to sendmail
+ # themselves
+ prep_for_email $1 $2 $3 && PAGER= generate_email
+else
+ while read oldrev newrev refname
+ do
+ prep_for_email $oldrev $newrev $refname || continue
+ generate_email $maxlines | send_mail
+ done
+fi
\ No newline at end of file
projects / kraken-ui-hooks.git / commitdiff