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

    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

    28

        # normalize

    29

        prog = prog.strip().lower()

    30

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

    31

    32

        # match

    33

        if fnmatch.fnmatch(prog, glob) :

    34

            return { attr: prog }

    35

        else :

    36

            return False

    37

    38

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

    39

        """

    40

            Match given value against given pattern.

    41

        """

    42

    43

        if not regex :

    44

            # ignore

    45

            return None

    46

    47

        if not value :

    48

            # XXX: optional = match empty string?

    49

            value = ''

    50

        else :

    51

            # normalize; XXX: unicode?

    52

            value = str(value).strip()

    53

    54

        # match

    55

        match = regex.match(value)

    56

    57

        if not match :

    58

            return False

    59

    60

        # as match-values

    61

        matches = match.groupdict()

    62

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

    63

    64

        # TODO match.expand?

    65

    66

        return matches

    67

    68

    def filter (self, item) :

    69

        """

    70

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

    71

        """

    72

    73

        match = None

    74

        matches = {}

    75

    76

        for attr in self.filters :

    77

            # lookup match-func

    78

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

    79

    80

            # filter

    81

            filter = self.filters[attr]

    82

    83

            # apply match

    84

            if attr in item :

    85

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

    86

            else :

    87

                match = match(attr, filter)

    88

    89

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

    90

    91

            if match :

    92

                # match

    93

                matches.update(match)

    94

    95

            elif match is None :

    96

                # ignore

    97

                continue

    98

    99

            else :

   100

                # reject

   101

                return

   102

   103

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

   104

        if match is None :

   105

            # XXX: empty filter!?

   106

            return True

   107

        else :

   108

            return matches

   109

   110

    def process (self, items) :

   111

        for item in items:

   112

            match = self.filter(item)

   113

   114

            if match :

   115

                yield item

   116

   117

    __call__ = process

   118

   119

    def __nonzero__ (self) :

   120

        return bool(self.filters)

   121