# -*- test-case-name: buildbot.test.test_status -*-

from twisted.spread import pb
from twisted.python import components, log as twlog
from twisted.internet import reactor
from twisted.application import strports
from twisted.cred import portal, checkers

from buildbot import interfaces
from zope.interface import Interface, implements
from buildbot.status import builder, base
from buildbot.changes import changes

class IRemote(Interface):
    pass

def makeRemote(obj):
    # we want IRemote(None) to be None, but you can't really do that with
    # adapters, so we fake it
    if obj is None:
        return None
    return IRemote(obj)


class RemoteBuildSet(pb.Referenceable):
    def __init__(self, buildset):
        self.b = buildset

    def remote_getSourceStamp(self):
        return self.b.getSourceStamp()

    def remote_getReason(self):
        return self.b.getReason()

    def remote_getID(self):
        return self.b.getID()

    def remote_getBuilderNames(self):
        return self.b.getBuilderNames()

    def remote_getBuildRequests(self):
        """Returns a list of (builderName, BuildRequest) tuples."""
        return [(br.getBuilderName(), IRemote(br))
                for br in self.b.getBuildRequests()]

    def remote_isFinished(self):
        return self.b.isFinished()

    def remote_waitUntilSuccess(self):
        d = self.b.waitUntilSuccess()
        d.addCallback(lambda res: self)
        return d

    def remote_waitUntilFinished(self):
        d = self.b.waitUntilFinished()
        d.addCallback(lambda res: self)
        return d

    def remote_getResults(self):
        return self.b.getResults()

components.registerAdapter(RemoteBuildSet,
                           interfaces.IBuildSetStatus, IRemote)    


class RemoteBuilder(pb.Referenceable):
    def __init__(self, builder):
        self.b = builder

    def remote_getName(self):
        return self.b.getName()

    def remote_getCategory(self):
        return self.b.getCategory()

    def remote_getState(self):
        state, builds = self.b.getState()
        return (state,
                None, # TODO: remove leftover ETA
                [makeRemote(b) for b in builds])

    def remote_getSlaves(self):
        return [IRemote(s) for s in self.b.getSlaves()]

    def remote_getLastFinishedBuild(self):
        return makeRemote(self.b.getLastFinishedBuild())

    def remote_getCurrentBuilds(self):
        return [IRemote(b) for b in self.b.getCurrentBuilds()]

    def remote_getBuild(self, number):
        return makeRemote(self.b.getBuild(number))

    def remote_getEvent(self, number):
        return IRemote(self.b.getEvent(number))

components.registerAdapter(RemoteBuilder,
                           interfaces.IBuilderStatus, IRemote)    


class RemoteBuildRequest(pb.Referenceable):
    def __init__(self, buildreq):
        self.b = buildreq
        self.observers = []

    def remote_getSourceStamp(self):
        return self.b.getSourceStamp()

    def remote_getBuilderName(self):
        return self.b.getBuilderName()

    def remote_subscribe(self, observer):
        """The observer's remote_newbuild method will be called (with two
        arguments: the RemoteBuild object, and our builderName) for each new
        Build that is created to handle this BuildRequest."""
        self.observers.append(observer)
        def send(bs):
            d = observer.callRemote("newbuild",
                                    IRemote(bs), self.b.getBuilderName())
            d.addErrback(lambda err: None)
        reactor.callLater(0, self.b.subscribe, send)

    def remote_unsubscribe(self, observer):
        # PB (well, at least oldpb) doesn't re-use RemoteReference instances,
        # so sending the same object across the wire twice will result in two
        # separate objects that compare as equal ('a is not b' and 'a == b').
        # That means we can't use a simple 'self.observers.remove(observer)'
        # here.
        for o in self.observers:
            if o == observer:
                self.observers.remove(o)

components.registerAdapter(RemoteBuildRequest,
                           interfaces.IBuildRequestStatus, IRemote)    

class RemoteBuild(pb.Referenceable):
    def __init__(self, build):
        self.b = build
        self.observers = []

    def remote_getBuilderName(self):
        return self.b.getBuilder().getName()

    def remote_getNumber(self):
        return self.b.getNumber()

    def remote_getReason(self):
        return self.b.getReason()

    def remote_getChanges(self):
        return [IRemote(c) for c in self.b.getChanges()]

    def remote_getResponsibleUsers(self):
        return self.b.getResponsibleUsers()

    def remote_getSteps(self):
        return [IRemote(s) for s in self.b.getSteps()]

    def remote_getTimes(self):
        return self.b.getTimes()

    def remote_isFinished(self):
        return self.b.isFinished()

    def remote_waitUntilFinished(self):
        # the Deferred returned by callRemote() will fire when this build is
        # finished
        d = self.b.waitUntilFinished()
        d.addCallback(lambda res: self)
        return d

    def remote_getETA(self):
        return self.b.getETA()

    def remote_getCurrentStep(self):
        return makeRemote(self.b.getCurrentStep())

    def remote_getText(self):
        return self.b.getText()

    def remote_getResults(self):
        return self.b.getResults()

    def remote_getLogs(self):
        logs = {}
        for name,log in self.b.getLogs().items():
            logs[name] = IRemote(log)
        return logs

    def remote_subscribe(self, observer, updateInterval=None):
        """The observer will have remote_stepStarted(buildername, build,
        stepname, step), remote_stepFinished(buildername, build, stepname,
        step, results), and maybe remote_buildETAUpdate(buildername, build,
        eta)) messages sent to it."""
        self.observers.append(observer)
        s = BuildSubscriber(observer)
        self.b.subscribe(s, updateInterval)

    def remote_unsubscribe(self, observer):
        # TODO: is the observer automatically unsubscribed when the build
        # finishes? Or are they responsible for unsubscribing themselves
        # anyway? How do we avoid a race condition here?
        for o in self.observers:
            if o == observer:
                self.observers.remove(o)


components.registerAdapter(RemoteBuild,
                           interfaces.IBuildStatus, IRemote)    

class BuildSubscriber:
    def __init__(self, observer):
        self.observer = observer

    def buildETAUpdate(self, build, eta):
        self.observer.callRemote("buildETAUpdate",
                                 build.getBuilder().getName(),
                                 IRemote(build),
                                 eta)

    def stepStarted(self, build, step):
        self.observer.callRemote("stepStarted",
                                 build.getBuilder().getName(),
                                 IRemote(build),
                                 step.getName(), IRemote(step))
        return None

    def stepFinished(self, build, step, results):
        self.observer.callRemote("stepFinished",
                                 build.getBuilder().getName(),
                                 IRemote(build),
                                 step.getName(), IRemote(step),
                                 results)


class RemoteBuildStep(pb.Referenceable):
    def __init__(self, step):
        self.s = step

    def remote_getName(self):
        return self.s.getName()

    def remote_getBuild(self):
        return IRemote(self.s.getBuild())

    def remote_getTimes(self):
        return self.s.getTimes()

    def remote_getExpectations(self):
        return self.s.getExpectations()

    def remote_getLogs(self):
        logs = {}
        for log in self.s.getLogs():
            logs[log.getName()] = IRemote(log)
        return logs

    def remote_isFinished(self):
        return self.s.isFinished()

    def remote_waitUntilFinished(self):
        return self.s.waitUntilFinished() # returns a Deferred

    def remote_getETA(self):
        return self.s.getETA()

    def remote_getText(self):
        return self.s.getText()

    def remote_getResults(self):
        return self.s.getResults()

components.registerAdapter(RemoteBuildStep,
                           interfaces.IBuildStepStatus, IRemote)    

class RemoteSlave:
    def __init__(self, slave):
        self.s = slave

    def remote_getName(self):
        return self.s.getName()
    def remote_getAdmin(self):
        return self.s.getAdmin()
    def remote_getHost(self):
        return self.s.getHost()
    def remote_isConnected(self):
        return self.s.isConnected()

components.registerAdapter(RemoteSlave,
                           interfaces.ISlaveStatus, IRemote)

class RemoteEvent:
    def __init__(self, event):
        self.e = event

    def remote_getTimes(self):
        return self.s.getTimes()
    def remote_getText(self):
        return self.s.getText()

components.registerAdapter(RemoteEvent,
                           interfaces.IStatusEvent, IRemote)

class RemoteLog(pb.Referenceable):
    def __init__(self, log):
        self.l = log

    def remote_getName(self):
        return self.l.getName()

    def remote_isFinished(self):
        return self.l.isFinished()
    def remote_waitUntilFinished(self):
        d = self.l.waitUntilFinished()
        d.addCallback(lambda res: self)
        return d

    def remote_getText(self):
        return self.l.getText()
    def remote_getTextWithHeaders(self):
        return self.l.getTextWithHeaders()
    def remote_getChunks(self):
        return self.l.getChunks()
    # TODO: subscription interface

components.registerAdapter(RemoteLog, builder.LogFile, IRemote)
# TODO: something similar for builder.HTMLLogfile ?

class RemoteChange:
    def __init__(self, change):
        self.c = change

    def getWho(self):
        return self.c.who
    def getFiles(self):
        return self.c.files
    def getComments(self):
        return self.c.comments

components.registerAdapter(RemoteChange, changes.Change, IRemote)


class StatusClientPerspective(base.StatusReceiverPerspective):

    subscribed = None
    client = None

    def __init__(self, status):
        self.status = status # the IStatus
        self.subscribed_to_builders = [] # Builders to which we're subscribed
        self.subscribed_to = [] # everything else we're subscribed to

    def __getstate__(self):
        d = self.__dict__.copy()
        d['client'] = None
        return d

    def attached(self, mind):
        #twlog.msg("StatusClientPerspective.attached")
        return self

    def detached(self, mind):
        twlog.msg("PB client detached")
        self.client = None
        for name in self.subscribed_to_builders:
            twlog.msg(" unsubscribing from Builder(%s)" % name)
            self.status.getBuilder(name).unsubscribe(self)
        for s in self.subscribed_to:
            twlog.msg(" unsubscribe from %s" % s)
            s.unsubscribe(self)
        self.subscribed = None

    def perspective_subscribe(self, mode, interval, target):
        """The remote client wishes to subscribe to some set of events.
        'target' will be sent remote messages when these events happen.
        'mode' indicates which events are desired: it is a string with one
        of the following values:

        'builders': builderAdded, builderRemoved
        'builds': those plus builderChangedState, buildStarted, buildFinished
        'steps': all those plus buildETAUpdate, stepStarted, stepFinished
        'logs': all those plus stepETAUpdate, logStarted, logFinished
        'full': all those plus logChunk (with the log contents)
        

        Messages are defined by buildbot.interfaces.IStatusReceiver .
        'interval' is used to specify how frequently ETAUpdate messages
        should be sent.

        Raising or lowering the subscription level will take effect starting
        with the next build or step."""

        assert mode in ("builders", "builds", "steps", "logs", "full")
        assert target
        twlog.msg("PB subscribe(%s)" % mode)

        self.client = target
        self.subscribed = mode
        self.interval = interval
        self.subscribed_to.append(self.status)
        # wait a moment before subscribing, so the new-builder messages
        # won't appear before this remote method finishes
        reactor.callLater(0, self.status.subscribe, self)
        return None

    def perspective_unsubscribe(self):
        twlog.msg("PB unsubscribe")
        self.status.unsubscribe(self)
        self.subscribed_to.remove(self.status)
        self.client = None

    def perspective_getBuildSets(self):
        """This returns tuples of (buildset, bsid), because that is much more
        convenient for tryclient."""
        return [(IRemote(s), s.getID()) for s in self.status.getBuildSets()]

    def perspective_getBuilderNames(self):
        return self.status.getBuilderNames()

    def perspective_getBuilder(self, name):
        b = self.status.getBuilder(name)
        return IRemote(b)

    def perspective_getSlave(self, name):
        s = self.status.getSlave(name)
        return IRemote(s)

    def perspective_ping(self):
        """Ping method to allow pb clients to validate their connections."""
        return "pong"

    # IStatusReceiver methods, invoked if we've subscribed

    # mode >= builder
    def builderAdded(self, name, builder):
        self.client.callRemote("builderAdded", name, IRemote(builder))
        if self.subscribed in ("builds", "steps", "logs", "full"):
            self.subscribed_to_builders.append(name)
            return self
        return None

    def builderChangedState(self, name, state):
        self.client.callRemote("builderChangedState", name, state, None)
        # TODO: remove leftover ETA argument

    def builderRemoved(self, name):
        if name in self.subscribed_to_builders:
            self.subscribed_to_builders.remove(name)
        self.client.callRemote("builderRemoved", name)

    def buildsetSubmitted(self, buildset):
        # TODO: deliver to client, somehow
        pass

    # mode >= builds
    def buildStarted(self, name, build):
        self.client.callRemote("buildStarted", name, IRemote(build))
        if self.subscribed in ("steps", "logs", "full"):
            self.subscribed_to.append(build)
            return (self, self.interval)
        return None

    def buildFinished(self, name, build, results):
        if build in self.subscribed_to:
            # we might have joined during the build
            self.subscribed_to.remove(build)
        self.client.callRemote("buildFinished",
                               name, IRemote(build), results)

    # mode >= steps
    def buildETAUpdate(self, build, eta):
        self.client.callRemote("buildETAUpdate",
                               build.getBuilder().getName(), IRemote(build),
                               eta)

    def stepStarted(self, build, step):
        # we add some information here so the client doesn't have to do an
        # extra round-trip
        self.client.callRemote("stepStarted",
                               build.getBuilder().getName(), IRemote(build),
                               step.getName(), IRemote(step))
        if self.subscribed in ("logs", "full"):
            self.subscribed_to.append(step)
            return (self, self.interval)
        return None

    def stepFinished(self, build, step, results):
        self.client.callRemote("stepFinished",
                               build.getBuilder().getName(), IRemote(build),
                               step.getName(), IRemote(step),
                               results)
        if step in self.subscribed_to:
            # eventually (through some new subscription method) we could
            # join in the middle of the step
            self.subscribed_to.remove(step)

    # mode >= logs
    def stepETAUpdate(self, build, step, ETA, expectations):
        self.client.callRemote("stepETAUpdate",
                               build.getBuilder().getName(), IRemote(build),
                               step.getName(), IRemote(step),
                               ETA, expectations)

    def logStarted(self, build, step, log):
        # TODO: make the HTMLLog adapter
        rlog = IRemote(log, None)
        if not rlog:
            print "hey, couldn't adapt %s to IRemote" % log
        self.client.callRemote("logStarted",
                               build.getBuilder().getName(), IRemote(build),
                               step.getName(), IRemote(step),
                               log.getName(), IRemote(log, None))
        if self.subscribed in ("full",):
            self.subscribed_to.append(log)
            return self
        return None

    def logFinished(self, build, step, log):
        self.client.callRemote("logFinished",
                               build.getBuilder().getName(), IRemote(build),
                               step.getName(), IRemote(step),
                               log.getName(), IRemote(log, None))
        if log in self.subscribed_to:
            self.subscribed_to.remove(log)

    # mode >= full
    def logChunk(self, build, step, log, channel, text):
        self.client.callRemote("logChunk",
                               build.getBuilder().getName(), IRemote(build),
                               step.getName(), IRemote(step),
                               log.getName(), IRemote(log),
                               channel, text)


class PBListener(base.StatusReceiverMultiService):
    """I am a listener for PB-based status clients."""

    compare_attrs = ["port", "cred"]
    implements(portal.IRealm)

    def __init__(self, port, user="statusClient", passwd="clientpw"):
        base.StatusReceiverMultiService.__init__(self)
        if type(port) is int:
            port = "tcp:%d" % port
        self.port = port
        self.cred = (user, passwd)
        p = portal.Portal(self)
        c = checkers.InMemoryUsernamePasswordDatabaseDontUse()
        c.addUser(user, passwd)
        p.registerChecker(c)
        f = pb.PBServerFactory(p)
        s = strports.service(port, f)
        s.setServiceParent(self)

    def setServiceParent(self, parent):
        base.StatusReceiverMultiService.setServiceParent(self, parent)
        self.setup()

    def setup(self):
        self.status = self.parent.getStatus()

    def requestAvatar(self, avatarID, mind, interface):
        assert interface == pb.IPerspective
        p = StatusClientPerspective(self.status)
        p.attached(mind) # perhaps .callLater(0) ?
        return (pb.IPerspective, p,
                lambda p=p,mind=mind: p.detached(mind))
