1

from pvl.syslog.filter import SyslogFilter

     2

     3

import re

     4

     5

import optparse, sys

     6

import configobj

     7

     8

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

     9

    10

def parser (parser) :

    11

    """

    12

        Optparse option group.

    13

    """

    14

    15

    syslog_rules = optparse.OptionGroup(parser, "Syslog rules")

    16

    17

    syslog_rules.add_option('--syslog-rules', metavar='FILE',

    18

            help="Load syslog rules from file")

    19

    20

    return syslog_rules

    21

    22

def apply (options) :

    23

    """

    24

        Build SyslogRules from options.

    25

    """

    26

    27

    if options.syslog_rules :

    28

        return SyslogRule.load(open(options.syslog_rules))

    29

    30

    else :

    32

    33

# TODO: combine SyslogRule/Rules into one heirarchial SyslogRule -type?

    34

class SyslogRule (object) :

    35

    """

    36

        A named SyslogFilter with sub-rules.

    37

    """

    38

    39

    @classmethod

    40

    def load (cls, file) :

    41

        """

    42

            Load SyslogRule from file.

    43

        """

    44

    45

        config = configobj.ConfigObj(file)

    46

    47

        # TODO: sub-sections -> rules?

    48

        rules = [cls.config(section, **dict(config[section])) for section in config.sections]

    49

    50

        return cls.config(file.name, rules=rules, **dict((name, config[name]) for name in config.scalars))

    51

    52

    @classmethod

    53

    def config (cls, name, format=None, program=None, pattern=None, rules=None, **filters) :

    54

        """

    55

            Build SyslogRule from config options

    56

        """

    57

    58

        if pattern :

    59

            pattern = re.compile(pattern)

    60

    61

        if format :

    62

            format = { name: format }

    63

    64

        filters = dict(

    65

            (attr, re.compile(regex)) for attr, regex in filters.iteritems()

    66

        )

    67

    68

        if program :

    69

            filters['prog'] = program

    70

    71

        if pattern :

    72

            filters['msg'] = pattern

    73

    74

        filter = SyslogFilter(**filters)

    75

    76

        return cls(name, rules, filter, format)

    77

    78

    def __init__ (self, name, rules=None, filter=None, formats=None) :

    79

        log.debug("%s: %s", name, filter)

    80

    81

        self.name = name

    82

        self.rules = rules or [] # sub-rules

    83

        self.filter = filter # SyslogFilter

    84

        self.formats = formats

    85

    86

    def match (self, item) :

    87

        """

    88

            Match item against our filter, applying any matches.

    89

        """

    90

    91

        if self.filter :

    92

            # filter

    93

            matches = self.filter.filter(item)

    94

    95

        else :

    96

            # match all

    97

            matches = True

    98

    99

        log.debug("%s: %s", self, matches)

   100

   101

        if not matches :

   102

            # ignore

   103

            return None

   104

   105

        # apply

   106

        item['rule'] = self

   107

   108

        if matches is True :

   109

            # no-op filter

   110

            pass

   111

        else :

   112

            item.update(matches)

   113

   114

        # XXX: copy, not mutate?

   115

        return item

   116

   117

    def format (self, item) :

   118

        """

   119

            Apply output formats

   120

        """

   121

   122

        for attr, format in self.formats.iteritems() :

   123

            value = item[attr] = format.format(**item)

   124

            log.debug("%s: %s: %s", self, attr, value)

   125

   126

        return item

   127

   128

    # TODO: __call__?

   129

    def apply (self, item) :

   130

        """

   131

            Match item against ourselfs, apply against any sub-rules, and return XXX

   132

        """

   133

   134

        item = self.match(item)

   135

   136

        if not item :

   137

            return

   138

   139

        # sub-rules

   140

        for rule in self.rules :

   141

            try :

   142

                match = rule.apply(item)

   143

   144

            except Exception as ex :

   145

                log.exception("rule %s: %r", rule, item)

   146

                return # XXX: skip?

   147

   148

            if match is None :

   149

                continue

   150

            else :

   151

                item = match

   152

   153

        # TODO: routing/formatting

   154

        #if self.tag is False :

   155

        #    # drop

   156

        #    return False

   157

   158

        if self.formats :

   159

            item = self.format(item)        

   160

   161

        return item

   162

   163

    def __iter__ (self, items) :

   164

        """

   165

            Apply items against our rules, yielding any matches.

   166

        """

   167

   168

        for item in items :

   169

            match = self.apply(item)

   170

   171

            if match :

   172

                yield match

   173

   174

    def __str__ (self) :

   175

        return self.name

   176

   177

    def __repr__ (self) :

   178

        return 'SyslogRule({self.name}, ...)'.format(self=self)

   179