source: ferringb/src_uri_checker/frontend.py @ marienz@gentoo.org-20060220170847-f0f633c8d1b80da6

#!/usr/bin/env python


"""Fancier frontend to scan."""


import sys
try:
        import cPickle as pickle
except ImportError:
        import pickle


from twisted.python import log, reflect, text as tptext
from twisted.internet import task, reactor

from twisted.conch import stdio
from twisted.conch.insults import insults, window

import base


class TextOutputArea(window.TextOutputArea):

        """Subclass to make the output clean up properly when scrolling up."""

        def render(self, width, height, terminal):
                """Write both our actual data and whitespace where we have none."""
                n = 0
                inputLines = self.text.splitlines()
                outputLines = []
                while inputLines:
                        if self.longLines == self.WRAP:
                                wrappedLines = tptext.greedyWrap(inputLines.pop(0), width)
                                outputLines.extend(wrappedLines or [''])
                        else:
                                outputLines.append(inputLines.pop(0)[:width])
                        if len(outputLines) >= height:
                                break
                for n, line in enumerate(outputLines[:height]):
                        terminal.cursorPosition(0, n)
                        terminal.write(line.ljust(width))
                for n in range(len(outputLines), height):
                        terminal.cursorPosition(0, n)
                        terminal.write(''.ljust(width))


class ScanFrontend(insults.TerminalProtocol):

        """Pretty frontend to the scanner.

        Mercilessly stolen from twisted-conch window.tac.
        """

        width = 80
        height = 50

        def _draw(self):
                """Draw stuff."""
                self.window.draw(self.width, self.height, self.terminal)

        def _redraw(self):
                """Redraw everything."""
                self.window.filthy()
                self._draw()

        def _safeFormat(self, fmtString, crap):
                #There's a way we could make this if not safer at least more
                #informative: perhaps some sort of str/repr wrapper objects
                #could be wrapped around the things inside of 'crap'. That way
                #if the event dict contains an object with a bad __repr__, we
                #can only cry about that individual object instead of the
                #entire event dict.
                try:
                        text = fmtString % crap
                except KeyboardInterrupt:
                        raise
                except:
                        try:
                                text = ('Invalid format string or unformattable object in log message: %r, %s' % (fmtString, crap))
                        except:
                                try:
                                        text = 'UNFORMATTABLE OBJECT WRITTEN TO LOG with fmt %r, MESSAGE LOST' % (fmtString,)
                                except:
                                        text = 'PATHOLOGICAL ERROR IN BOTH FORMAT STRING AND MESSAGE DETAILS, MESSAGE LOST'
                return text

        def log(self, eventDict):
                """Log a message."""
                # Ripped from t.python.log.emit
                edm = eventDict['message']
                if eventDict['isError']:
                        attrs = 'ERROR: ' # self.ERROR
                else:
                        attrs = '' # self.NORMAL
                if not edm:
                        if eventDict['isError'] and eventDict.has_key('failure'):
                                text = eventDict['failure'].getTraceback()
                        elif eventDict.has_key('format'):
                                text = self._safeFormat(eventDict['format'], eventDict)
                        else:
                                # we don't know how to log this
                                return
                else:
                        text = attrs + ' '.join(map(reflect.safe_str, edm)) #+ self.NORMAL
                self.logLines.append(text)
                self.logOut.setText('\n'.join(self.logLines))

        def connectionMade(self):
                """Initialize."""
                if len(sys.argv) != 3:
                        print 'need 2 args: url_dict pickle and file to write failures to'
                        sys.exit(1)
                        return

                # read our hosts pickle
                f = open(sys.argv[1], 'r')
                urlDict = pickle.load(f)
                f.close()

                hosts = base.convertDictToHosts(urlDict)

                self.terminal.eraseDisplay()
                self.terminal.resetPrivateModes([insults.privateModes.CURSOR_MODE])
                self.window = window.TopWindow(self._draw)
                vbox = window.VBox()
                # autosizing log window
                self.logOut = TextOutputArea()
                self.logLines = []
                vbox.addChild(window.ScrolledArea(self.logOut))

                # status output
                self.statusOut = TextOutputArea()
                vbox.addChild(self.statusOut)

                # hosts output
                self.hostsOut = TextOutputArea((80, 3))
                vbox.addChild(window.ScrolledArea(self.hostsOut))

                # set up logging
                log.addObserver(self.log)

                # finalize
                self.window.addChild(vbox)
                self.terminalSize(self.width, self.height)

                # initialize jobProcessor
                self.jobProcessor = base.JobProcessor(hosts)
                logCall = task.LoopingCall(self.printStats)
                logCall.start(0.5)
                hostsCall = task.LoopingCall(self.printHosts)
                hostsCall.start(5)
                def writeStats(arg):
                        """Write our statistics to file."""
                        outFile = open(sys.argv[2], "w")
                        try:
                                base.writeHosts(outFile, self.jobProcessor.hosts)
                        finally:
                                outFile.close()

                def shutDown(arg):
                        """Exit."""
                        logCall.stop()
                        hostsCall.stop()
                        reactor.stop()
                self.jobProcessor.deferred.addErrback(log.err)
                self.jobProcessor.deferred.addCallback(writeStats)
                self.jobProcessor.deferred.addBoth(shutDown)

        def printStats(self):
                """Print current status to an output widget."""
                self.statusOut.setText('\n'.join(self.jobProcessor.stats()))

        def printHosts(self):
                """Print active hosts to our output widget."""
                self.hostsOut.setText('\n'.join(self.jobProcessor.moreStats()))

        def connectionLost(self, reason):
                """Relay a lost connection."""
                insults.TerminalProtocol.connectionLost(self, reason)

        def terminalSize(self, width, height):
                """Adjust to a changed terminal size."""
                self.width = width
                self.height = height
                self.terminal.eraseDisplay()
                self._redraw()

        def unhandledControlSequence(self, seq):
                """Log unhandled input."""
                log.msg('wtf is %r' % seq)

        def keystrokeReceived(self, keyID, modifier):
                """Write and quit on q, pass the rest to the widget machinery."""
                if keyID == 'q':
                        try:
                                outFile = open(sys.argv[2], "w")
                                try:
                                        base.writeHosts(outFile, self.jobProcessor.hosts)
                                finally:
                                        outFile.close()
                        finally:
                                reactor.stop()
                self.window.keystrokeReceived(keyID, modifier)


if __name__ == '__main__':
        # extra logging
        log.startLogging(open('twisted.log', 'w'))
        # this fires up the reactor too
        stdio.runWithProtocol(ScanFrontend)