path: root/roles/batcave/files/git-notifier

#! /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()