553 lines
15 KiB
Python
Executable file
553 lines
15 KiB
Python
Executable file
#! /usr/bin/env python
|
|
|
|
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"),
|
|
]
|
|
|
|
class State:
|
|
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:
|
|
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 '--pretty=format:%%s (%%h)' -s %s" % 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 '--pretty=format:%%s (%%h)' -s %s" % 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 '--pretty=format:%%s (%%h)' -s %s" % 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()
|