6

from twisted.python import log

     7

     8

from fixbot import fifo

     9

    10

class LogSource (object) :

    15

    def __init__ (self, name, filters) :

    21

        # set later on

    22

        self.module = None

    23

    24

        # what filters to apply

    25

        self.filters = filters

    26

    27

        # name, for display purposes

    28

        self.name = name

    29

    30

        # used to gather data together into lines

    31

        self.buf = ""

    32

    33

    def setModule (self, module) :

    34

        self.module = module

    35

    36

    def handleError (self, msg) :

    37

        log.err(msg)

    38

        self.module.error(msg)

    39

    40

    def handleData (self, data) :

    45

        data = self.buf + data

    46

    47

        while "\n" in data :

    48

            line, data = data.split("\n", 1)

    49

    50

            self.handleLine(line)

    51

    52

        self.buf = data

    53

    54

    def handleLine (self, line) :

    55

        log.msg("Matching line `%s'..." % line)

    56

    57

        for filter in self.filters :

    58

            # let the filter process the line

    59

            out = filter.test(line)

    60

    61

            if out :

    65

                # positive match, send

    73

                break

    74

    75

            elif out is False :

    76

                # negative match, stop processing

    77

                return

    78

    80

                # no match

    81

                continue

    82

    86

class File (LogSource, protocol.ProcessProtocol) :

    87

    """

    88

        Stream lines from a regular file using /usr/bin/tail -f

    89

    """

    90

    91

    def __init__ (self, name, path, filters) :

    92

        super(File, self).__init__(name, filters)

    93

    94

        self.path = path

    95

    96

        log.msg("spawning tail process for %s:%s" % (name, path))

    97

    98

        reactor.spawnProcess(self, "/usr/bin/tail", ["tail", "-n0", "--follow=name", path])

    99

   100

    def errReceived (self, data) :

   101

        self.handleError("tail for %s: %s" % (self.name, data))

   102

   103

    def outReceived (self, data) :

   104

        self.handleData(data)

   105

   106

    def processEnded (self, reason) :

   107

        self.handleError("tail process for %s quit: %s" % (self.name, reason.getErrorMessage()))

   108

   109

class Fifo (LogSource, fifo.Fifo) :

   110

    """

   111

        Stream lines from a fifo object.

   112

    """

   113

   114

    def __init__ (self, name, path, filters) :

   115

        LogSource.__init__(self, name, filters)

   116

   117

        log.msg("opening fifo for %s:%s" % (name, path))

   118

   119

        fifo.Fifo.__init__(self, path)

   120

   121

    def dataReceived (self, data) :

   122

        self.handleData(data)

   123

   124

    def handleEOF (self) :

   125

        self.handleError("!!! EOF on fifo %s, re-opening" % self.name)

   126

        self.reopen()

   127

   128

    def connectionLost (self, reason) :

   129

        super(Fifo, self).connectionLost(reason)

   130

        self.handleError("lost fifo for %s: %s" % (self.name, reason.getErrorMessage()))

   131

   132