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_glob (self, attr, glob, value=None) :

    20

        """

    21

            Match prog as glob.

    22

        """

    23

    24

        if not value :

    25

            # require

    26

            return False

    27

    28

        # normalize

    29

        value = value.strip()

    30

    31

        # match

    32

        if fnmatch.fnmatch(value, glob) :

    33

            return { attr: value }

    34

        else :

    35

            return False

    36

    37

    match_facility = match_glob

    38

    39

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

    40

        """

    41

            Match prog as glob.

    42

        """

    43

    44

        if prog :

    45

            # normalize

    46

            prog = prog.strip().lower()

    51

    52

        # match

    53

        return self.match_glob(attr, glob, prog)

    54

    55

    REGEX_TYPE = type(re.compile(''))

    56

    57

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

    58

        """

    59

            Match given value against given pattern.

    60

        """

    61

    62

        if not value :

    63

            # XXX: optional = match empty string?

    64

            value = ''

    65

        else :

    66

            # normalize; XXX: unicode?

    67

            value = str(value).strip()

    68

    69

        # match

    70

        match = regex.match(value)

    71

    72

        if not match :

    73

            return False

    74

    75

        # as match-values

    76

        matches = { attr: match.group(0) } # whole match

    77

        matches.update(match.groupdict())

    78

    79

        # TODO match.expand?

    80

    81

        return matches

    82

    83

    def filter (self, item) :

    84

        """

    85

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

    86

        """

    87

    88

        match = None

    89

        matches = {}

    90

    91

        for attr in self.filters :

    92

            # filter

    93

            filter = self.filters[attr]

    94

    95

            if not filter :

    96

                # ignore

    97

                continue

    98

    99

            # lookup match-func

   100

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

   101

   102

            if match :

   103

                pass

   104

   105

            elif isinstance(filter, self.REGEX_TYPE) :

   106

                match = self.match_regex

   107

   108

            else :

   109

                match = self.match_glob

   110

   111

            # apply match

   112

            if attr in item :

   113

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

   114

            else :

   115

                match = match(attr, filter)

   116

   117

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

   118

   119

            if match :

   120

                # match

   121

                matches.update(match)

   122

   123

            else :

   124

                # reject

   125

                return

   126

   127

        # test last match

   128

        if match is None :

   129

            # empty filter -> all None

   130

            return True

   131

        else :

   132

            return matches

   133

   134

    def process (self, items) :

   135

        for item in items:

   136

            match = self.filter(item)

   137

   138

            if match :

   139

                yield item

   140

   141

    __call__ = process

   142

   143

    def __nonzero__ (self) :

   144

        return bool(self.filters)

   145

   146

    def __repr__ (self) :

   147

        return repr(self.filters)