--- /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
+ &nbs
projects / limn-bak.git / commitdiff