/usr/bin/git-notifier

#! /usr/bin/env python

import getpass
import optparse
import os
import shutil
import socket
import subprocess
import sys
import tempfile
import time

VERSION   = "0.41-6"  # Filled in automatically.

Name      = "git-notifier"
CacheFile = ".%s.dat" % Name
Separator = "\n>---------------------------------------------------------------\n"
NoDiff    = "[nodiff]"
NoMail    = "[nomail]"

gitolite = "GL_USER" in os.environ

if "LOGNAME" in os.environ:
    whoami = os.environ["LOGNAME"]
else:
    whoami = getpass.getuser()

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, "notify for a manually given set of revisions"),
    ("maxdiffsize", True, 50, "limit the size of diffs in mails (KB)"),
    ("mailsubjectlen", True, None, "limit the length of mail subjects (number of chars)"),
    ("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"),
    ("replyto", True, None, "email address for reply-to header"),
    ("mergediffs", True, set(), "branches for which complete merge diffs are to be included"),
    ]

class State:
    def __init__(self):
        self.clear()

    def clear(self):
        self.heads = {}
        self.tags = {}
        self.revs = set()
        self.diffs = 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

        # No longer used.
        #
        # for rev in self.diffs:
        #     print >>out, "diff", 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)

            elif type == "diff":
                self.diffs.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 self.mergediffs and not isinstance(self.mergediffs, set):
            self.mergediffs = set([head.strip() for head in self.mergediffs.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):
    if Config.mailsubjectlen:
        try:
            maxlen = int(Config.mailsubjectlen)
            if len(subject) > maxlen:
                subject = subject[:maxlen] + " ..."
        except ValueError:
            pass

    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()

    replyto = "Reply-To: %s\n" % Config.replyto if Config.replyto else ""

    print >>out, """From: %s
To: %s
Subject: %s %s
%sX-Git-Repository: %s
X-Mailer: %s %s

%s

""" % (Config.sender, Config.mailinglist, Config.emailprefix, subject, replyto, 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(rev, subject, heads, show_cmd, diff_cmd, stat_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)
        url = url.replace("%r", os.path.basename(os.getcwd()))
        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:
            (tmp, tname) = makeTmp()
            diff = git(stat_cmd, stdout_to=tmp)
            tmp.close()
            footer = "\nDiff suppressed because of size. To see it, use:\n\n    git %s" % diff_cmd

    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
        print >>out, "debug: stat_cmd = git %s" % stat_cmd

    sendMail(out, fname)

# Sends notification for a specific revision.
def commit(current, rev, force=False, subject_head=None):
    if rev in current.reported and not force:
        # Already reported in this run of the script.
        log("Flagged revision %s for notification, but already reported this time" % rev)
        return

    log("New revision %s" % rev)
    current.reported.add(rev)

    heads = [head.split()[-1] for head in git("branch --contains=%s" % rev)]
    if not subject_head:
        subject_head = ",".join(heads)

    merge_diff = "--cc"

    for head in heads:
        if head in Config.allchanges or head in Config.mergediffs:
            merge_diff = "-m"

    subject = git("show '--pretty=format:%%s (%%h)' -s %s" % rev)
    
    subject = "%s: %s" % (subject_head, subject[0])

    show_cmd = "show -s --no-color --find-copies-harder --pretty=medium %s" % rev
    diff_cmd = "diff-tree --root --patch-with-stat --no-color --find-copies-harder --ignore-space-at-eol %s %s" % (merge_diff, rev)
    stat_cmd = "diff-tree --root --stat --no-color --find-copies-harder --ignore-space-at-eol %s" % rev

    sendChangeMail(rev, subject, heads, show_cmd, diff_cmd, stat_cmd)

# Sends a diff between two revisions.
#
# Only used in manual mode now.
def diff(head, first, last):
    # We record a pseudo-revision to avoid sending the same diff twice.
    rev = "%s-%s" % (head, last)
    if not rev in current.diffs:
        log("New diff revision %s" % rev)
        current.diffs.add(rev)

    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)
    stat_cmd = "diff --stat -m --no-color --find-copies-harder --ignore-space-at-eol %s %s" % (first, last)

    sendChangeMail(last, subject, heads, show_cmd, diff_cmd, stat_cmd)

# Sends pair-wise diffs for a path of revisions. Also records all revision on
# the path as seen.
#
# Only used in manual mode now.
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.
def reportPath(current, revs, force=False, subject_head=None):
    if not revs:
        return

    # Sort updates by time.
    revs = git("rev-list --no-walk --reverse --date-order %s" % " ".join(revs))

    for rev in revs:
        commit(current, rev, force=force, subject_head=subject_head)

# 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, no reporting of changes")
    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 --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, force=True)

    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)

    # Notify for unreported commits.
    old = set(cache.revs)
    new = set(current.revs)
    new_revs = (new - old)
    reportPath(current, new_revs)

    # Do reports for the heads we want to see everything for.
    for head in stable_heads:
        old_rev = cache.heads[head]
        new_rev = current.heads[head]
        path = git(["rev-list", "--reverse --date-order", new_rev, "^%s" % old_rev])

        if head in Config.allchanges:
            # Want to see all commits for this head, even if already reported
            # in the past for some other. So we record these separately.
            reportPath(current, path, subject_head=head)
        else:
            # Just send a summary for heads that now include some new stuff.
            if len(set(path) - new_revs):
                headMoved(head, path)

if not Config.noupdate:
    current.writeTo(CacheFile)

deleteTmps()
git-notifier 0.41-6-1 / usr / bin / git-notifier
