1

from twisted.internet import reactor, protocol

     2

from twisted.python import log

     3

     4

import fifo

     5

     6

class LogSource (object) :

     7

    def __init__ (self, name, filters) :

     8

        # set later on

     9

        self.module = None

    10

    11

        # what filters to apply

    12

        self.filters = filters

    13

    14

        # name, for display purposes

    15

        self.name = name

    16

    17

        # used to gather data together into lines

    18

        self.buf = ""

    19

    20

    def setModule (self, module) :

    21

        self.module = module

    22

    23

    def handleError (self, msg) :

    24

        log.err(msg)

    25

        self.module.error(msg)

    26

    27

    def handleData (self, data) :

    28

        data = self.buf + data

    29

    30

        while "\n" in data :

    31

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

    32

    33

            self.handleLine(line)

    34

    35

        self.buf = data

    36

    37

    def handleLine (self, line) :

    38

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

    39

    40

        for filter in self.filters :

    41

            out = filter.test(line)

    42

    43

            if out :

    44

                log.msg("\t%s: %s" % (filter.event_type, out))

    45

                self.module.sendEvent(filter.event_type, out)

    46

    47

                break

    48

            elif out is False :

    49

                return

    50

            else :  # None

    51

                continue

    52

    53

class File (LogSource, protocol.ProcessProtocol) :

    54

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

    55

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

    56

    57

        self.path = path

    58

    59

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

    60

    61

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

    62

    63

    def errReceived (self, data) :

    64

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

    65

    66

    def outReceived (self, data) :

    67

        self.handleData(data)

    68

    69

    def processEnded (self, reason) :

    70

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

    71

    72

class Fifo (LogSource, fifo.Fifo) :

    73

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

    74

        LogSource.__init__(self, name, filters)

    75

    76

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

    77

    78

        fifo.Fifo.__init__(self, path)

    79

    80

    def dataReceived (self, data) :

    81

        self.handleData(data)

    82

    83

    def handleEOF (self) :

    84

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

    85

        self.reopen()

    86

    87

    def connectionLost (self, reason) :

    88

        super(Fifo, self).connectionLost(reason)

    89

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

    90

    91