text: # This file is part of Buildbot.  Buildbot is free software: you can
  # redistribute it and/or modify it under the terms of the GNU General Public
  # License as published by the Free Software Foundation, version 2.
  #
  # This program is distributed in the hope that it will be useful, but WITHOUT
  # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  # FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  # details.
  #
  # You should have received a copy of the GNU General Public License along with
  # this program; if not, write to the Free Software Foundation, Inc., 51
  # Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  #
  # Copyright Buildbot Team Members
  
  
  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 logfile, 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() # note: passes along the Deferred
  
      def remote_getBuildRequests(self):
          """Returns a list of (builderName, BuildRequest) tuples."""
          d = self.b.getBuilderNamesAndBuildRequests()
          def add_remote(buildrequests):
              for k,v in buildrequests.iteritems():
                  buildrequests[k] = IRemote(v)
              return buildrequests.items()
          d.addCallback(add_remote)
          return d
  
      def remote_isFinished(self):
          return self.b.isFinished()
  
      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):
          # note that this now returns a Deferred
          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, logfile.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."""
          d = self.status.getBuildSets()
          def make_remotes(buildsets):
              return [(IRemote(s), s.id) for s in buildsets]
          d.addCallback(make_remotes)
          return d
  
      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))
  