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.logwatch import fifo, message

     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

    47

    def handleData (self, data) :

    48

        """

    49

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

    50

        """

    51

    52

        data = self.buf + data

    53

    54

        while "\n" in data :

    55

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

    56

    57

            # full line

    58

            self.handleLine(line)

    59

    60

        self.buf = data

    61

    62

    def handleLine (self, line) :

    63

        """

    64

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

    65

        """

    66

    67

        # parse

    68

        try :

    69

            msg = message.SyslogMessage(line)

    70

    71

        except Exception, e :

    72

            # log and ignore

    73

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

    74

    75

        else :

    76

            # handle the structured message

    77

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

    78

    79

    def handleMessage (self, msg) :

    80

        """

    81

            Process the given SyslogMessage

    82

        """

    83

    84

        # Log incoming lines

    85

        log.msg(repr(msg))

    86

    87

        for filter in self.filters :

    88

            # let the filter process the line

    89

            out = filter.match(msg)

    90

    91

            if out :

    92

                # unpack

    93

                label, msg = out

    94

    95

                # output tag/type

    96

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

    97

    98

                # positive match, send

    99

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

   100

   101

                # drop until we have a module

   102

                if self.module :

   103

                    self.module.sendEvent(type, msg)

   104

   105

                # ok, first hit does it

   106

                break

   107

   108

            elif out is False :

   109

                # negative match, stop processing

   110

                return

   111

   112

            elif out is None :

   113

                # no match

   114

                continue

   115

   116

            else :

   117

                raise ValueError(out)

   118

   122

class File (LogSource, protocol.ProcessProtocol) :

   123

    """

   124

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

   125

    """

   126

   127

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

   128

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

   129

   130

        self.path = path

   131

   132

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

   133

   134

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

   135

   136

    def errReceived (self, data) :

   137

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

   138

   139

    def outReceived (self, data) :

   140

        self.handleData(data)

   141

   142

    def processEnded (self, reason) :

   143

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

   144

   145

class Fifo (LogSource, fifo.Fifo) :

   146

    """

   147

        Stream lines from a fifo object.

   148

    """

   149

   150

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

   151

        LogSource.__init__(self, name, filters)

   152

   153

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

   154

   155

        fifo.Fifo.__init__(self, path)

   156

   157

    def dataReceived (self, data) :

   158

        self.handleData(data)

   159

   160

    def handleEOF (self) :

   161

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

   163

   164

class UnixDatagramSocket (LogSource, protocol.DatagramProtocol) :

   165

    """

   166

        Stream messages from a UNIX datagram socket

   167

    """

   168

   169

    # maximum size of the recieved messages

   170

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

   171

    MAX_PACKET_SIZE = 4096

   172

   173

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

   174

        LogSource.__init__(self, name, filters)

   175

   176

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

   177

   178

        # open UNIX socket

   179

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

   180

   181

    def datagramReceived (self, data, addr) :

   182

        """

   183

            Got message from syslog-ng

   184

        """

   185

   186

        # handle it as a line of data

   187

        self.handleLine(data)

   188

   189