1

"""

     2

    Implementations of the various sources of log data

     3

"""

     4

     5

from twisted.internet import protocol, reactor

     6

from twisted.python import log

     7

     8

from fixbot import fifo

     9

from fixbot.logwatch import message

    10

    11

class LogSource (object) :

    12

    """

    13

        Reads lines of log data from some file or other source.

    14

    """

    15

    16

    def __init__ (self, name, filters) :

    17

        """

    18

            name            - label lines read from this source

    19

            filters         - LogFilter chain to pass lines through

    20

        """

    21

    22

        # set later on

    23

        self.module = None

    24

    25

        # what filters to apply

    26

        self.filters = filters

    27

    28

        # name, for display purposes

    29

        self.name = name

    30

    31

        # used to gather data together into lines

    32

        self.buf = ""

    33

    34

    def setModule (self, module) :

    35

        self.module = module

    36

    37

    def handleError (self, msg) :

    38

        log.err(msg)

    39

        self.module.error(msg)

    40

    41

    def handleData (self, data) :

    42

        """

    43

            Feed binary data into the buffer, processing all lines via handleLine()

    44

        """

    45

    46

        data = self.buf + data

    47

    48

        while "\n" in data :

    49

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

    50

    51

            # full line

    52

            self.handleLine(line)

    53

    54

        self.buf = data

    55

    56

    def handleLine (self, line) :

    57

        """

    58

            Parse given line into a SyslogMessage, and pass it to handleMessage

    59

        """

    60

    61

        # parse

    62

        try :

    63

            msg = message.SyslogMessage(line)

    64

    65

        except Exception, e :

    66

            # log and ignore

    67

            log.err(e, "Invalid syslog message from source %s: %s" % (self.name, line))

    68

    69

        else :

    70

            # handle the structured message

    72

    73

    def handleMessage (self, msg) :

    74

        """

    75

            Process the given SyslogMessage

    76

        """

    79

        log.msg(repr(msg))

    80

    81

        for filter in self.filters :

    82

            # let the filter process the line

    83

            out = filter.match(msg)

    84

    85

            if out :

    86

                # unpack

    87

                type, msg = out

    88

    89

                # positive match, send

    90

                log.msg("\t%s: %s" % (type, msg))

    91

    92

                # drop until we have a module

    93

                if self.module :

    94

                    self.module.sendEvent(type, msg)

    95

    96

                # ok, first hit does it

    97

                break

    98

    99

            elif out is False :

   100

                # negative match, stop processing

   101

                return

   102

   103

            elif out is None :

   104

                # no match

   105

                continue

   106

   107

            else :

   108

                raise ValueError(out)

   109

   110

class File (LogSource, protocol.ProcessProtocol) :

   111

    """

   112

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

   113

    """

   114

   115

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

   116

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

   117

   118

        self.path = path

   119

   120

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

   121

   122

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

   123

   124

    def errReceived (self, data) :

   125

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

   126

   127

    def outReceived (self, data) :

   128

        self.handleData(data)

   129

   130

    def processEnded (self, reason) :

   131

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

   132

   133

class Fifo (LogSource, fifo.Fifo) :

   134

    """

   135

        Stream lines from a fifo object.

   136

    """

   137

   138

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

   139

        LogSource.__init__(self, name, filters)

   140

   141

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

   142

   143

        fifo.Fifo.__init__(self, path)

   144

   145

    def dataReceived (self, data) :

   146

        self.handleData(data)

   147

   148

    def handleEOF (self) :

   149

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

   150

        self.reopen()

   151

   152

    def connectionLost (self, reason) :

   153

        super(Fifo, self).connectionLost(reason)

   154

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

   155

   156

class UnixDatagramSocket (LogSource, protocol.DatagramProtocol) :

   157

    """

   158

        Stream messages from a UNIX datagram socket

   159

    """

   160

   161

    # maximum size of the recieved messages

   162

    # native syslog is 1024, but syslog-ng does better... so 4k

   163

    MAX_PACKET_SIZE = 4096

   164

   165

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

   166

        LogSource.__init__(self, name, filters)

   167

   168

        log.msg("opening unix socket for %s at: %s" % (name, path))

   169

   170

        # open UNIX socket

   171

        reactor.listenUNIXDatagram(path, self, self.MAX_PACKET_SIZE)

   172

   173

    def datagramReceived (self, data, addr) :

   174

        """

   175

            Got message from syslog-ng

   176

        """

   177

   178

        # handle it as a line of data

   179

        self.handleLine(data)

   180