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

            log.callWithLogger(self, self.handleMessage, msg)

    72

    73

    def handleMessage (self, msg) :

    74

        """

    75

            Process the given SyslogMessage

    76

        """

    77

    78

        # Log incoming lines

    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

    91

    92

                # positive match, send

    93

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

    94

    95

                # drop until we have a module

    96

                if self.module :

    97

                    self.module.sendEvent(type, msg)

    98

    99

                # ok, first hit does it

   100

                break

   101

   102

            elif out is False :

   103

                # negative match, stop processing

   104

                return

   105

   106

            elif out is None :

   107

                # no match

   108

                continue

   109

   110

            else :

   111

                raise ValueError(out)

   112

   113

class File (LogSource, protocol.ProcessProtocol) :

   114

    """

   115

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

   116

    """

   117

   118

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

   119

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

   120

   121

        self.path = path

   122

   123

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

   124

   125

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

   126

   127

    def errReceived (self, data) :

   128

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

   129

   130

    def outReceived (self, data) :

   131

        self.handleData(data)

   132

   133

    def processEnded (self, reason) :

   134

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

   135

   136

class Fifo (LogSource, fifo.Fifo) :

   137

    """

   138

        Stream lines from a fifo object.

   139

    """

   140

   141

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

   142

        LogSource.__init__(self, name, filters)

   143

   144

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

   145

   146

        fifo.Fifo.__init__(self, path)

   147

   148

    def dataReceived (self, data) :

   149

        self.handleData(data)

   150

   151

    def handleEOF (self) :

   152

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

   153

        self.reopen()

   154

   155

    def connectionLost (self, reason) :

   156

        super(Fifo, self).connectionLost(reason)

   157

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

   158

   159

class UnixDatagramSocket (LogSource, protocol.DatagramProtocol) :

   160

    """

   161

        Stream messages from a UNIX datagram socket

   162

    """

   163

   164

    # maximum size of the recieved messages

   165

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

   166

    MAX_PACKET_SIZE = 4096

   167

   168

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

   169

        LogSource.__init__(self, name, filters)

   170

   171

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

   172

   173

        # open UNIX socket

   174

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

   175

   176

    def datagramReceived (self, data, addr) :

   177

        """

   178

            Got message from syslog-ng

   179

        """

   180

   181

        # handle it as a line of data

   182

        self.handleLine(data)

   183

   184

    def logPrefix (self) :

   185

        return "LogSource(%s)" % (self.name, )

   186