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

        self.filters = filters

    17

    18

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

    19

        """

    20

            XXX: Match given prog as glob?

    21

        """

    22

    23

        if not glob :

    24

            # ignore

    25

            return None

    26

    27

        # normalize

    28

        prog = prog.strip().lower()

    29

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

    30

    31

        # match

    32

        if fnmatch.fnmatch(prog, glob) :

    33

            return { attr: prog }

    34

        else :

    35

            return False

    36

    37

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

    38

        """

    39

            Match given value against given pattern.

    40

        """

    41

    42

        if not regex :

    43

            # ignore

    44

            return None

    45

    46

        if not value :

    47

            # XXX: optional = match empty string?

    48

            value = ''

    49

        else :

    50

            # normalize; XXX: unicode?

    51

            value = str(value).strip()

    52

    53

        # match

    54

        match = regex.match(value)

    55

    56

        if not match :

    57

            return False

    58

    59

        # as match-values

    60

        matches = match.groupdict()

    61

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

    62

    63

        # TODO match.expand?

    64

    65

        return matches

    66

    67

    def filter (self, item) :

    68

        """

    69

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

    70

        """

    71

    73

        matches = {}

    74

    75

        for attr in self.filters :

    76

            # lookup match-func

    77

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

    78

    79

            # filter

    80

            filter = self.filters[attr]

    81

    82

            # apply match

    83

            if attr in item :

    84

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

    85

            else :

    86

                match = match(attr, filter)

    87

    88

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

    89

    90

            if match :

    91

                # match

    92

                matches.update(match)

    93

    94

            elif match is None :

    95

                # ignore

    96

                continue

    97

    98

            else :

    99

                # reject

   100

                return

   101

   102

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

   103

        if match is None :

   104

            # XXX: empty filter!?

   105

            return True

   106

        else :

   107

            return matches

   108

   109

    def process (self, items) :

   110

        for item in items:

   111

            match = self.filter(item)

   112

   113

            if match :

   114

                yield item

   115

   116

    __call__ = process