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

     9

    10

class LogSource (object) :

    11

    """

    12

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

    13

    """

    14

    15

    def __init__ (self, name, filters) :

    16

        """

    17

            name            - label lines read from this source

    18

            filters         - LogFilter chain to pass lines through

    19

        """

    20

    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) :

    41

        """

    42

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

    43

        """

    44

    45

        data = self.buf + data

    46

    47

        while "\n" in data :

    48

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

    49

    50

            # full line

    51

            self.handleLine(line)

    52

    53

        self.buf = data

    54

    55

    def handleLine (self, line) :

    56

        """

    57

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

    58

        """

    59

    60

        # parse

    61

        try :

    62

            msg = message.SyslogMessage(line)

    63

    64

        except Exception, e :

    65

            # log and ignore

    66

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

    67

    68

        else :

    69

            # handle the structured message

    70

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

    71

    72

    def handleMessage (self, msg) :

    73

        """

    74

            Process the given SyslogMessage

    75

        """

    76

    77

        # Log incoming lines

    78

        log.msg(repr(msg))

    79

    80

        for filter in self.filters :

    81

            # let the filter process the line

    82

            out = filter.match(msg)

    83

    84

            if out :

    85

                # unpack

    86

                label, msg = out

    87

    88

                # output tag/type

    89

                type = "%s:%s" % (self.name, label)

    90

    91

                # positive match, send

    92

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

    93

    94

                # drop until we have a module

    95

                if self.module :

    96

                    self.module.sendEvent(type, msg)

    97

    98

                # ok, first hit does it

    99

                break

   100

   101

            elif out is False :

   102

                # negative match, stop processing

   103

                return

   104

   105

            elif out is None :

   106

                # no match

   107

                continue

   108

   109

            else :

   110

                raise ValueError(out)

   111

   112

class File (LogSource, protocol.ProcessProtocol) :

   113

    """

   114

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

   115

    """

   116

   117

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

   118

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

   119

   120

        self.path = path

   121

   122

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

   123

   124

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

   125

   126

    def errReceived (self, data) :

   127

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

   128

   129

    def outReceived (self, data) :

   130

        self.handleData(data)

   131

   132

    def processEnded (self, reason) :

   133

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

   134

   135

class Fifo (LogSource, fifo.Fifo) :

   136

    """

   137

        Stream lines from a fifo object.

   138

    """

   139

   140

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

   141

        LogSource.__init__(self, name, filters)

   142

   143

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

   144

   145

        fifo.Fifo.__init__(self, path)

   146

   147

    def dataReceived (self, data) :

   148

        self.handleData(data)

   149

   150

    def handleEOF (self) :

   151

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

   152

        self.reopen()

   153

   154

    def connectionLost (self, reason) :

   155

        super(Fifo, self).connectionLost(reason)

   156

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

   157

   158

class UnixDatagramSocket (LogSource, protocol.DatagramProtocol) :

   159

    """

   160

        Stream messages from a UNIX datagram socket

   161

    """

   162

   163

    # maximum size of the recieved messages

   164

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

   165

    MAX_PACKET_SIZE = 4096

   166

   167

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

   168

        LogSource.__init__(self, name, filters)

   169

   170

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

   171

   172

        # open UNIX socket

   173

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

   174

   175

    def datagramReceived (self, data, addr) :

   176

        """

   177

            Got message from syslog-ng

   178

        """

   179

   180

        # handle it as a line of data

   181

        self.handleLine(data)

   182

   183

    def logPrefix (self) :

   184

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

   185