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

    @classmethod

    12

    def build (cls, **filters) :

    13

        """

    14

            Match using given non-None fields.

    15

        """

    16

    17

        # drop None's

    18

        return cls(dict((attr, regex) for attr, regex in filters.iteritems() if regex is not None))

    19

    20

    def __init__ (self, filters) :

    21

        """

    22

            Match using given { field: regex }.

    23

        """

    24

    25

        self.filters = filters

    26

    27

    def match_glob (self, attr, glob, value=None) :

    28

        """

    29

            Match prog as glob.

    30

        """

    31

    32

        if not glob :

    33

            return { attr: value }

    34

    35

        if not value :

    36

            # require

    37

            return False

    38

    39

        # normalize

    40

        value = value.strip()

    41

    42

        # match

    43

        if fnmatch.fnmatch(value, glob) :

    44

            return { attr: value }

    45

        else :

    46

            return False

    47

    48

    match_facility = match_glob

    49

    50

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

    51

        """

    52

            Match prog as glob.

    53

        """

    54

    55

        if prog :

    56

            # normalize

    57

            prog = prog.strip().lower()

    58

    59

            if prog.startswith('/') :

    60

                # leaves postfix/* intact, but fixes /usr/bin/cron

    61

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

    62

    63

        # match

    64

        return self.match_glob(attr, glob, prog)

    65

    66

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

    67

    68

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

    69

        """

    70

            Match given value against given pattern.

    71

        """

    72

    73

        if not regex :

    74

            return { attr: value }

    75

    76

        if not value :

    77

            # XXX: optional = match empty string?

    78

            value = ''

    79

        else :

    80

            # normalize; XXX: unicode?

    81

            value = str(value).strip()

    82

    83

        # match

    84

        match = regex.match(value)

    85

    86

        if not match :

    87

            return False

    88

    89

        # as match-values

    90

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

    91

        matches.update(match.groupdict())

    92

    93

        # TODO match.expand?

    94

    95

        return matches

    96

    97

    def filter (self, item) :

    98

        """

    99

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

   100

        """

   101

   102

        match = None

   103

        matches = {}

   104

   105

        for attr in self.filters :

   106

            # filter

   107

            filter = self.filters[attr]

   108

   109

            # lookup match-func

   110

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

   111

   112

            if match :

   113

                pass

   114

   115

            elif isinstance(filter, self.REGEX_TYPE) :

   116

                match = self.match_regex

   117

   118

            else :

   119

                match = self.match_glob

   120

   121

            # apply match

   122

            if attr in item :

   123

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

   124

            else :

   125

                match = match(attr, filter)

   126

   127

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

   128

   129

            if match :

   130

                # match

   131

                matches.update(match)

   132

   133

            else :

   134

                # reject

   135

                return

   136

   137

        # test last match

   138

        if match is None :

   139

            # empty filter -> all None

   140

            return True

   141

        else :

   142

            return matches

   143

   144

    def process (self, items) :

   145

        for item in items:

   146

            match = self.filter(item)

   147

   148

            if match :

   149

                yield item

   150

   151

    __call__ = process

   152

   153

    def __nonzero__ (self) :

   154

        return bool(self.filters)

   155

   156

    def __repr__ (self) :

   157

        return repr(self.filters)