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={ 'text': '{msg}' })

    32

    33

def merge (*dicts, **kwargs) :

    34

    return dict((k, v) for d in (dicts + (kwargs, )) for k, v in d.iteritems())

    35

    36

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

    37

class SyslogRule (object) :

    38

    """

    39

        A named SyslogFilter with sub-rules.

    40

    """

    41

    42

    @classmethod

    43

    def load (cls, file) :

    44

        """

    45

            Load SyslogRule from file.

    46

        """

    47

    48

        config = configobj.ConfigObj(file)

    49

    50

        return cls.config_section(file.name, config)

    51

    52

    @classmethod

    53

    def config_section (cls, name, section) :

    54

        """

    55

            Recursively load Syslogrules from config section.

    56

        """

    57

    58

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

    59

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

    60

    61

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

    62

    63

    @classmethod

    64

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

    65

        """

    66

            Build SyslogRule from config options

    67

        """

    68

    69

        if format is not None :

    70

            format = { 'text': format }

    71

        else :

    72

            format = { }

    73

    74

        if irk :

    75

            format['irk'] = irk

    76

    77

        filters = dict(

    78

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

    79

        )

    80

    81

        if facility :

    82

            filters['facility'] = facility # glob

    83

    84

        if program :

    85

            filters['prog'] = program # glob

    86

    87

        if pattern :

    88

            filters['msg'] = re.compile(pattern)

    89

    90

        filter = SyslogFilter(**filters)

    91

    92

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

    93

    94

        return cls(name, rules, filter, format)

    95

    96

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

    97

        self.name = name

    98

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

    99

        self.filter = filter # SyslogFilter

   100

        self.formats = formats or {}

   101

   102

    def match (self, item) :

   103

        """

   104

            Match item against our filter, returning match-dict (empty?) or None.

   105

        """

   106

   107

        if self.filter :

   108

            # filter

   109

            matches = self.filter.filter(item)

   110

   111

        else :

   112

            # match all, we probably have sub-rules that we're interested in

   113

            return { }

   114

   115

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

   116

   117

        if matches :

   118

            return matches

   119

        else :

   120

            # no match

   121

            return None

   122

   123

    def format (self, item) :

   124

        """

   125

            Apply our output formats to given base apply, yielding (unique) attr, value tuples.

   126

        """

   127

   128

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

   129

            value = format.format(**item)

   130

   131

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

   132

   133

            yield attr, value

   134

   135

    def apply (self, item) :

   136

        """

   137

            Recursively match item against ourself and sub-rules. Returns applied output.

   138

   139

            Matches are passed down the tree, and applies are passed up.

   140

        """

   141

   142

        log.debug("%s", self)

   143

   144

        # match rule -> matches

   145

        matches = self.match(item)

   146

   147

        if matches is None :

   148

            # skip

   149

            return None, None, None

   150

   151

        # merge matches down

   152

        item = merge(item, matches)

   153

   154

        # recursive sub-rules -> apply

   155

        for rule in self.rules :

   156

            try :

   157

                # pass matches down

   158

                match, rules, apply = rule.apply(item)

   159

   160

            except Exception as ex :

   161

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

   162

                continue # XXX: skip?

   163

   164

            if apply :

   165

                # pass apply up

   166

                break

   167

        else :

   168

            # self-match

   169

            match, rules, apply = item, [], { }

   170

   171

        rules.append(self)

   172

   173

        # formats?

   174

        if self.formats :

   175

            # merge apply up

   176

            apply = merge(dict(self.format(item)), apply)

   177

   178

        log.debug("%s: %s", '/'.join(str(rule) for rule in rules), apply)

   179

   180

        return match, rules, apply

   181

   182

    def __iter__ (self, items) :

   183

        """

   184

            Apply items against our rules, yielding any matches.

   185

        """

   186

   187

        for item in items :

   188

            match, rules, apply = self.apply(item)

   189

   190

            if apply :

   191

                yield apply

   192

   193

    def __str__ (self) :

   194

        return self.name

   195

   196

    def __repr__ (self) :

   197

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

   198