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 :

    31

        return SyslogRule('default', formats={ 'default': '{msg}' })

    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

        return cls.config_section(file.name, config)

    48

    49

    @classmethod

    50

    def config_section (cls, name, section) :

    51

        """

    52

            Recursively load Syslogrules from config section.

    53

        """

    54

    55

        rules = [cls.config_section(subsection, section[subsection]) for subsection in section.sections]

    56

        attrs = dict((name, section[name]) for name in section.scalars)

    57

    58

        return cls.config(name, rules=rules, **attrs)

    59

    60

    @classmethod

    61

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

    62

        """

    63

            Build SyslogRule from config options

    64

        """

    65

    66

        if pattern :

    67

            pattern = re.compile(pattern)

    68

    69

        if format :

    70

            format = { name: format }

    71

    72

        filters = dict(

    73

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

    74

        )

    75

    76

        if program :

    77

            filters['prog'] = program

    78

    79

        if pattern :

    80

            filters['msg'] = pattern

    81

    82

        filter = SyslogFilter(**filters)

    83

    84

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

    85

    86

        return cls(name, rules, filter, format)

    87

    88

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

    89

        self.name = name

    90

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

    91

        self.filter = filter # SyslogFilter

    92

        self.formats = formats or {}

    93

    94

    def match (self, item) :

    95

        """

    96

            Match item against our filter, applying any matches.

    97

        """

    98

    99

        if self.filter :

   100

            # filter

   101

            matches = self.filter.filter(item)

   102

   103

        else :

   104

            # match all

   105

            matches = True

   106

   107

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

   108

   109

        if not matches :

   110

            # ignore

   111

            return None

   112

   113

        # apply

   114

        item['rule'] = self

   115

   116

        if matches is True :

   117

            # no-op filter

   118

            pass

   119

        else :

   120

            item.update(matches)

   121

   122

        # XXX: copy, not mutate?

   123

        return item

   124

   125

    def format (self, item) :

   126

        """

   127

            Apply output formats

   128

        """

   129

   130

        out = {}

   131

   132

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

   133

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

   134

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

   135

   136

        return out

   137

   138

    # TODO: __call__?

   139

    def apply (self, item) :

   140

        """

   141

            Match item against ourself, apply against any sub-rules, and return output, if hit.

   142

        """

   143

   144

        item = self.match(item)

   145

   146

        if not item :

   147

            # skip

   148

            return

   149

   150

        # sub-rules

   151

        for rule in self.rules :

   152

            try :

   153

                out = rule.apply(item)

   154

   155

            except Exception as ex :

   156

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

   157

                return # XXX: skip?

   158

   159

            if out :

   160

                # hit

   161

                return out

   162

   163

        # TODO: routing/formatting

   164

        #if self.tag is False :

   165

        #    # drop

   166

        #    return False

   167

   168

        if self.formats :

   169

            # hit

   170

            item.update(self.format(item))

   171

   172

        return item

   173

   174

    def __iter__ (self, items) :

   175

        """

   176

            Apply items against our rules, yielding any matches.

   177

        """

   178

   179

        for item in items :

   180

            match = self.apply(item)

   181

   182

            if match :

   183

                yield match

   184

   185

    def __str__ (self) :

   186

        return self.name

   187

   188

    def __repr__ (self) :

   189

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

   190