1

import logging; log = logging.getLogger('pvl.syslog.filter')

     2

     3

import re # XXX

     4

import os.path, fnmatch

     5

     6

class SyslogFilter (object) :

     7

    """

     8

        Match syslog messages fields against given patterns.

     9

    """

    10

    11

    def __init__ (self, **filters) :

    12

        """

    13

            Match using given { field: regex }.

    14

        """

    15

    16

        # drop None's

    17

        self.filters = dict((attr, regex) for attr, regex in filters.iteritems() if regex is not None)

    18

    19

    def match_prog (self, attr, glob, prog=None) :

    20

        """

    21

            XXX: Match given prog as glob?

    22

        """

    23

    24

        if not glob :

    25

            # ignore

    26

            return None

    27

    32

        # normalize

    33

        prog = prog.strip().lower()

    34

        _, prog = os.path.split(prog)

    35

    36

        # match

    37

        if fnmatch.fnmatch(prog, glob) :

    38

            return { attr: prog }

    39

        else :

    40

            return False

    41

    42

    def match (self, attr, regex, value=None) :

    43

        """

    44

            Match given value against given pattern.

    45

        """

    46

    47

        if not regex :

    48

            # ignore

    49

            return None

    50

    51

        if not value :

    52

            # XXX: optional = match empty string?

    53

            value = ''

    54

        else :

    55

            # normalize; XXX: unicode?

    56

            value = str(value).strip()

    57

    58

        # match

    59

        match = regex.match(value)

    60

    61

        if not match :

    62

            return False

    63

    64

        # as match-values

    65

        matches = match.groupdict()

    66

        matches[attr] = match.group(0) # whole match

    67

    68

        # TODO match.expand?

    69

    70

        return matches

    71

    72

    def filter (self, item) :

    73

        """

    74

            Match given item. Returns any matched values (including regexp capture groups) across all fields.

    75

        """

    76

    77

        match = None

    78

        matches = {}

    79

    80

        for attr in self.filters :

    81

            # lookup match-func

    82

            match = getattr(self, 'match_{attr}'.format(attr=attr), self.match)

    83

    84

            # filter

    85

            filter = self.filters[attr]

    86

    87

            # apply match

    88

            if attr in item :

    89

                match = match(attr, filter, item[attr])

    90

            else :

    91

                match = match(attr, filter)

    92

    93

            log.debug("%s: %s", attr, match)

    94

    95

            if match :

    96

                # match

    97

                matches.update(match)

    98

    99

            elif match is None :

   100

                # ignore

   101

                continue

   102

   103

            else :

   104

                # reject

   105

                return

   106

   107

        # XXX: test last match, in case they were all None

   108

        if match is None :

   109

            # XXX: empty filter!?

   110

            return True

   111

        else :

   112

            return matches

   113

   114

    def process (self, items) :

   115

        for item in items:

   116

            match = self.filter(item)

   117

   118

            if match :

   119

                yield item

   120

   121

    __call__ = process

   122

   123

    def __nonzero__ (self) :

   124

        return bool(self.filters)

   125

   126

    def __repr__ (self) :

   127

        return repr(self.filters)