#

# Derived from code from the status/mail.py in buildbot 0.7.9

# Needs python-twitter installed to function.

import twitter

from zope.interface import implements

from twisted.internet import defer, threads

from twisted.mail.smtp import sendmail

from twisted.python import log as twlog

from buildbot import interfaces, util

from buildbot.status import base

from buildbot.status.builder import FAILURE, SUCCESS, WARNINGS

class TwitterNotifier(base.StatusReceiverMultiService):

    compare_attrs = ["twitname", "twitpass", "mode", "categories", "builders",

                     "message"]

    def __init__(self, twitname, twitpass, mode="all", categories=None, builders=None,

                 message="%(buildSlave)s reported build %(buildNumber)s as a %(result)s %(buildUrl)s"):

        """

        @type  twitname

        @param twitname: The twitter user

        @type  twitpass

        @param twitpass: The twitter user's password. 

        @type  mode: string (defaults to all)

        @param mode: one of:

                     - 'all': send mail about all builds, passing and failing

                     - 'failing': only send mail about builds which fail

                     - 'passing': only send mail about builds which succeed

                     - 'problem': only send mail about a build which failed

                     when the previous build passed

        @type  message: string

        @param message: a string to be used as the subject line of the message.

                       - %(buildSlave)s will be replaced with the name of the slave doing the building.

                       - %(projectName)s with the name of the project

                       - %(result)s will be the result of the build

                       - %(buildUrl)s will be the url with the details of the build.

                       - %(revision)s The revision of the change.

        @type  categories: list of strings

        @param categories: a list of category names to serve status

                           information for. Defaults to None (all

                           categories). Use either builders or categories,

                           but not both.

                        builder which provoked the message.

        @type  builders: list of strings

        @param builders: a list of builder names for which mail should be

                         sent. Defaults to None (send mail for all builds).

                         Use either builders or categories, but not both.

        """

        base.StatusReceiverMultiService.__init__(self)

        self.twitname = twitname

        self.twitpass = twitpass

        assert mode in ('all', 'failing', 'problem')

        self.mode = mode

        self.message = message

        self.categories = categories

        self.builders = builders

        self.watched = []

        self.status = None

        # you should either limit on builders or categories, not both

        if self.builders != None and self.categories != None:

            twlog.err("Please specify only builders to ignore or categories to include")

            raise # FIXME: the asserts above do not raise some Exception either

    def setServiceParent(self, parent):

        """

        @type  parent: L{buildbot.master.BuildMaster}

        """

        base.StatusReceiverMultiService.setServiceParent(self, parent)

        self.setup()

    def setup(self):

        self.status = self.parent.getStatus()

        self.status.subscribe(self)

    def disownServiceParent(self):

        self.status.unsubscribe(self)

        for w in self.watched:

            w.unsubscribe(self)

        return base.StatusReceiverMultiService.disownServiceParent(self)

    def builderAdded(self, name, builder):

        # only subscribe to builders we are interested in

        if self.categories != None and builder.category not in self.categories:

            return None

        self.watched.append(builder)

        return self # subscribe to this builder

    def builderRemoved(self, name):

        pass

    def builderChangedState(self, name, state):

        pass

    def buildStarted(self, name, build):

        pass

    def buildFinished(self, name, build, results):

        # here is where we actually do something.

        builder = build.getBuilder()

        if self.builders is not None and name not in self.builders:

            return # ignore this build

        if self.categories is not None and \

               builder.category not in self.categories:

            return # ignore this build

        if self.mode == "failing" and results != FAILURE:

            return

        if self.mode == "passing" and results != SUCCESS:

            return

        if self.mode == "problem":

            if results != FAILURE:

                return

            prev = build.getPreviousBuild()

            if prev and prev.getResults() == FAILURE:

                return

        # for testing purposes, buildMessage returns a Deferred that fires

        # when the mail has been sent. To help unit tests, we return that

        # Deferred here even though the normal IStatusReceiver.buildFinished

        # signature doesn't do anything with it. If that changes (if

        # .buildFinished's return value becomes significant), we need to

        # rearrange this.

        return self.buildMessage(name, build, results)

    def buildMessage(self, name, build, results):

        projectName = self.status.getProjectName()

        buildSlave = build.getSlavename()

        buildUrl = self.status.getURLForThing(build)

        buildNumber  = build.getNumber()

        ss = build.getSourceStamp()

        if ss is None:

            revision = "unavailable"

        else:

            revision = ""

            if ss.revision:

                source += ss.revision

            else:

                revision += "HEAD"

        if results == SUCCESS:

            result = "success"

        elif results == WARNINGS:

            result = "warnings"

        else:

            res = "failure"

        text = self.message % {

            'projectName': projectName,

            'buildSlave':  buildSlave,

            'result': result,

            'revision': revision,

            'buildUrl': buildUrl,

            'buildNumber' : buildNumber,

        }

        d = threads.deferToThread(_sendTwitter, self.twitname, self.twitpass, 

                                  text)

        return d

def _sendTwitter(twitname, twitpass, text):

    api = twitter.Api(twitname, twitpass)

    api.PostUpdate(text)