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

    71

            self.handleMessage(msg)

    72

    73

    def handleMessage (self, msg) :

    74

        """

    75

            Process the given SyslogMessage

    76

        """

    77

    78

        # XXX: filters should accept messages...

    79

        line = str(msg)

    80

        log.msg(repr(msg))

    81

    82

        for filter in self.filters :

    83

            # let the filter process the line

    85

    86

            if out :

    87

                # unpack

    88

                type, msg = out

    89

    90

                # positive match, send

    91

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

    92

    93

                # drop until we have a module

    94

                if self.module :

    95

                    self.module.sendEvent(type, msg)

    96

    97

                # ok, first hit does it

    98

                break

    99

   100

            elif out is False :

   101

                # negative match, stop processing

   102

                return

   103

   104

            elif out is None :

   105

                # no match

   106

                continue

   107

   108

            else :

   109

                raise ValueError(out)

   110

   111

class File (LogSource, protocol.ProcessProtocol) :

   112

    """

   113

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

   114

    """

   115

   116

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

   117

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

   118

   119

        self.path = path

   120

   121

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

   122

   123

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

   124

   125

    def errReceived (self, data) :

   126

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

   127

   128

    def outReceived (self, data) :

   129

        self.handleData(data)

   130

   131

    def processEnded (self, reason) :

   132

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

   133

   134

class Fifo (LogSource, fifo.Fifo) :

   135

    """

   136

        Stream lines from a fifo object.

   137

    """

   138

   139

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

   140

        LogSource.__init__(self, name, filters)

   141

   142

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

   143

   144

        fifo.Fifo.__init__(self, path)

   145

   146

    def dataReceived (self, data) :

   147

        self.handleData(data)

   148

   149

    def handleEOF (self) :

   150

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

   151

        self.reopen()

   152

   153

    def connectionLost (self, reason) :

   154

        super(Fifo, self).connectionLost(reason)

   155

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

   156

   157

class UnixDatagramSocket (LogSource, protocol.DatagramProtocol) :

   158

    """

   159

        Stream messages from a UNIX datagram socket

   160

    """

   161

   162

    # maximum size of the recieved messages

   163

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

   164

    MAX_PACKET_SIZE = 4096

   165

   166

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

   167

        LogSource.__init__(self, name, filters)

   168

   169

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

   170

   171

        # open UNIX socket

   172

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

   173

   174

    def datagramReceived (self, data, addr) :

   175

        """

   176

            Got message from syslog-ng

   177

        """

   178

   179

        # handle it as a line of data

   180

        self.handleLine(data)

   181