Example #1
0
 def updatePrompt(self):
     if self.troveToWatch:
         if self.troveToWatch not in self.state.troves:
             self.troveToWatch = self.state.troves[0]
         state = self.state.getTroveState(*self.troveToWatch)
         state = buildtrove._getStateName(state)
         name = self.troveToWatch[1][0].split(':', 1)[0] # remove :source
         context = self.troveToWatch[1][3]
         d = dict(jobId=self.troveToWatch[0], name=name, state=state,
                  context=(context and '{%s}' % context or ''))
     else:
         d = dict(jobId='(None)', name='(None)', state='', context='')
     if not self.state.jobActive():
         tailing = 'Job %s' % self.state.getJobStateName()
     elif self.watchTroves:
         tailing = 'Details on'
     else:
         tailing = 'Details off'
     d['tailing'] = tailing
     self.prompt = self.promptFormat % d
     self.erasePrompt()
     self.writePrompt()
Example #2
0
 def updatePrompt(self):
     if self.troveToWatch:
         if self.troveToWatch not in self.state.troves:
             self.troveToWatch = self.state.troves[0]
         state = self.state.getTroveState(*self.troveToWatch)
         state = buildtrove._getStateName(state)
         name = self.troveToWatch[1][0].split(':', 1)[0]  # remove :source
         context = self.troveToWatch[1][3]
         d = dict(jobId=self.troveToWatch[0],
                  name=name,
                  state=state,
                  context=(context and '{%s}' % context or ''))
     else:
         d = dict(jobId='(None)', name='(None)', state='', context='')
     if not self.state.jobActive():
         tailing = 'Job %s' % self.state.getJobStateName()
     elif self.watchTroves:
         tailing = 'Details on'
     else:
         tailing = 'Details off'
     d['tailing'] = tailing
     self.prompt = self.promptFormat % d
     self.erasePrompt()
     self.writePrompt()
Example #3
0
 def displayTrove(self, jobId, troveTuple):
     self.display.setTroveToWatch(jobId, troveTuple)
     state = self.state.getTroveState(jobId, troveTuple)
     state = buildtrove._getStateName(state)
Example #4
0
        self._msg('[%d] %s' % (jobId, status))

    def _troveStateUpdated(self, (jobId, troveTuple), state, status):
        state = buildtrove._getStateName(state)
        if troveTuple[3]:
            name = '%s{%s}' % (troveTuple[0], troveTuple[3])
        else:
            name = troveTuple[0]
        self._msg('[%d] - %s - State: %s' % (jobId, name, state))
        if status and self._watchTrove(jobId, troveTuple):
            self._msg('[%d] - %s - %s' % (jobId, name, status))
        self.updatePrompt()

    def _troveLogUpdated(self, (jobId, troveTuple), state, status):
        if self._watchTrove(jobId, troveTuple):
            state = buildtrove._getStateName(state)
            self._msg('[%d] - %s - %s' % (jobId, troveTuple[0], status))

    def _trovePreparingChroot(self, (jobId, troveTuple), host, path):
        if not self._watchTrove(jobId, troveTuple):
            return
        if host == '_local_':
            msg = 'Chroot at %s' % path
        else:
            msg = 'Chroot at Node %s:%s' % (host, path)
        self._msg('[%d] - %s - %s' % (jobId, troveTuple[0], msg))

class OutBuffer(object):
    def __init__(self, fd):
        if fd is None: 
            fd = sys.stdout.fileno()
Example #5
0
class JobLogDisplay(_AbstractDisplay):
    def __init__(self,
                 client,
                 showBuildLogs=True,
                 out=None,
                 exitOnFinish=None):
        _AbstractDisplay.__init__(self,
                                  client,
                                  out=out,
                                  showBuildLogs=showBuildLogs,
                                  exitOnFinish=exitOnFinish)
        self.buildingTroves = {}
        self.lastLogPoll = 0

    def _tailBuildLog(self, jobId, troveTuple):
        mark = self.buildingTroves.get((jobId, troveTuple), [0])[0]
        self.buildingTroves[jobId, troveTuple] = [mark, True]
        self.out.write('Tailing %s build log:\n\n' % troveTuple[0])

    def _stopTailing(self, jobId, troveTuple):
        mark = self.buildingTroves.get((jobId, troveTuple), [0])[0]
        self.buildingTroves[jobId, troveTuple] = [mark, False]

    def _serveLoopHook(self):
        if not self.buildingTroves:
            return
        now = time.time()
        if now - self.lastLogPoll < 1:
            return
        self.lastLogPoll = now
        for (jobId, troveTuple), (mark, tail) in self.buildingTroves.items():
            if not tail:
                continue
            try:
                moreData, data, mark = self.client.getTroveBuildLog(
                    jobId, troveTuple, mark)
            except:
                moreData = True
                data = ''
            self.out.write(data)
            if not moreData:
                del self.buildingTroves[jobId, troveTuple]
            else:
                self.buildingTroves[jobId, troveTuple][0] = mark

    def _jobTrovesSet(self, jobId, troveData):
        self._msg('[%d] - job troves set' % jobId)

    def _jobStateUpdated(self, jobId, state, status):
        _AbstractDisplay._jobStateUpdated(self, jobId, state, status)
        state = buildjob._getStateName(state)
        if self._isFinished():
            self._serveLoopHook()
        self._msg('[%d] - State: %s' % (jobId, state))
        if status:
            self._msg('[%d] - %s' % (jobId, status))

    def _jobLogUpdated(self, jobId, state, status):
        self._msg('[%d] %s' % (jobId, status))

    def _troveStateUpdated(self, (jobId, troveTuple), state, status):
        isBuilding = (state in (buildtrove.TROVE_STATE_BUILDING,
                                buildtrove.TROVE_STATE_RESOLVING))
        state = buildtrove._getStateName(state)
        self._msg('[%d] - %s - State: %s' % (jobId, troveTuple[0], state))
        if status:
            self._msg('[%d] - %s - %s' % (jobId, troveTuple[0], status))
        if isBuilding and self.showBuildLogs:
            self._tailBuildLog(jobId, troveTuple)
        else:
            self._stopTailing(jobId, troveTuple)
Example #6
0
        self._msg('[%d] %s' % (jobId, status))

    def _troveStateUpdated(self, (jobId, troveTuple), state, status):
        isBuilding = (state in (buildtrove.TROVE_STATE_BUILDING,
                                buildtrove.TROVE_STATE_RESOLVING))
        state = buildtrove._getStateName(state)
        self._msg('[%d] - %s - State: %s' % (jobId, troveTuple[0], state))
        if status:
            self._msg('[%d] - %s - %s' % (jobId, troveTuple[0], status))
        if isBuilding and self.showBuildLogs:
            self._tailBuildLog(jobId, troveTuple)
        else:
            self._stopTailing(jobId, troveTuple)

    def _troveLogUpdated(self, (jobId, troveTuple), state, status):
        state = buildtrove._getStateName(state)
        self._msg('[%d] - %s - %s' % (jobId, troveTuple[0], status))

    def _trovePreparingChroot(self, (jobId, troveTuple), host, path):
        if host == '_local_':
            msg = 'Chroot at %s' % path
        else:
            msg = 'Chroot at Node %s:%s' % (host, path)
        self._msg('[%d] - %s - %s' % (jobId, troveTuple[0], msg))

    def _primeOutput(self, jobId):
        logMark = 0
        while True:
            newLogs = self.client.getJobLogs(jobId, logMark)
            if not newLogs:
                break
Example #7
0
 def displayTrove(self, jobId, troveTuple):
     self.display.setTroveToWatch(jobId, troveTuple)
     state = self.state.getTroveState(jobId, troveTuple)
     state = buildtrove._getStateName(state)
Example #8
0
class JobLogDisplay(_AbstractDisplay):
    def __init__(self, client, state, out=None):
        _AbstractDisplay.__init__(self, client, out)
        self.troveToWatch = None
        self.watchTroves = False
        self.buildingTroves = {}
        self.state = state
        self.lastLen = 0
        self.promptFormat = '%(jobId)s %(name)s%(context)s - %(state)s - (%(tailing)s) ([h]elp)>'
        self.updatePrompt()

    def close(self):
        self.out.write('\n')
        self.out.flush()

    def _msg(self, msg, *args):
        self.erasePrompt()
        self.out.write('[%s] %s\n' % (time.strftime('%X'), msg))
        self.writePrompt()

    def updatePrompt(self):
        if self.troveToWatch:
            if self.troveToWatch not in self.state.troves:
                self.troveToWatch = self.state.troves[0]
            state = self.state.getTroveState(*self.troveToWatch)
            state = buildtrove._getStateName(state)
            name = self.troveToWatch[1][0].split(':', 1)[0]  # remove :source
            context = self.troveToWatch[1][3]
            d = dict(jobId=self.troveToWatch[0],
                     name=name,
                     state=state,
                     context=(context and '{%s}' % context or ''))
        else:
            d = dict(jobId='(None)', name='(None)', state='', context='')
        if not self.state.jobActive():
            tailing = 'Job %s' % self.state.getJobStateName()
        elif self.watchTroves:
            tailing = 'Details on'
        else:
            tailing = 'Details off'
        d['tailing'] = tailing
        self.prompt = self.promptFormat % d
        self.erasePrompt()
        self.writePrompt()

    def erasePrompt(self):
        self.out.write('\r%s\r' % (' ' * self.lastLen))

    def writePrompt(self):
        self.out.write(self.prompt)
        self.lastLen = len(self.prompt)
        self.out.flush()

    def setWatchTroves(self, watchTroves=True):
        self.watchTroves = watchTroves
        self.updatePrompt()

    def getWatchTroves(self):
        return self.watchTroves

    def setTroveToWatch(self, jobId, troveTuple):
        self.troveToWatch = jobId, troveTuple
        self.updatePrompt()

    def _watchTrove(self, jobId, troveTuple):
        if not self.watchTroves:
            return False
        return self.troveToWatch == (jobId, troveTuple)

    def displayTroveStates(self):
        if not self.troveToWatch:
            return
        self.erasePrompt()
        job = self.client.getJob(self.troveToWatch[0])
        query.displayTrovesByState(job, out=self.out)
        self.writePrompt()

    def setPrompt(self, promptFormat):
        self.promptFormat = promptFormat
        self.updatePrompt()

    def updateBuildLog(self, jobId, troveTuple):
        if not self._watchTrove(jobId, troveTuple):
            return
        mark = self.getMark(jobId, troveTuple)
        if mark is None:
            return
        try:
            moreData, data, mark = self.client.getTroveBuildLog(
                jobId, troveTuple, mark)
        except:
            return
        if data and data != '\n':
            self.erasePrompt()
            if data[0] == '\n':
                # we've already got a \n because we've cleared
                # the prompt.
                data = data[1:]
            self.out.write(data)
            if data[-1] != '\n':
                self.out.write('\n')
            self.writePrompt()
        if not moreData:
            mark = None
        self.setMark(jobId, troveTuple, mark)

    def getMark(self, jobId, troveTuple):
        if (jobId, troveTuple) not in self.buildingTroves:
            # display max 80 lines of back log
            self.buildingTroves[jobId, troveTuple] = -80
        return self.buildingTroves[jobId, troveTuple]

    def setMark(self, jobId, troveTuple, mark):
        self.buildingTroves[jobId, troveTuple] = mark

    def _jobTrovesSet(self, jobId, troveList):
        self._msg('[%d] - job troves set' % jobId)
        self.troveToWatch = jobId, troveList[0]
        self.updatePrompt()

    def _jobStateUpdated(self, jobId, state, status):
        _AbstractDisplay._jobStateUpdated(self, jobId, state, status)
        state = buildjob._getStateName(state)
        if self._isFinished() and self.troveToWatch:
            self.updateBuildLog(*self.troveToWatch)
        self._msg('[%d] - State: %s' % (jobId, state))
        if status:
            self._msg('[%d] - %s' % (jobId, status))
        self.updatePrompt()

    def _jobLogUpdated(self, jobId, state, status):
        self._msg('[%d] %s' % (jobId, status))

    def _troveStateUpdated(self, (jobId, troveTuple), state, status):
        state = buildtrove._getStateName(state)
        if troveTuple[3]:
            name = '%s{%s}' % (troveTuple[0], troveTuple[3])
        else:
            name = troveTuple[0]
        self._msg('[%d] - %s - State: %s' % (jobId, name, state))
        if status and self._watchTrove(jobId, troveTuple):
            self._msg('[%d] - %s - %s' % (jobId, name, status))
        self.updatePrompt()