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

        try :

    62

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

    63

    64

        except ValueError as ex :

    65

            raise ValueError("[%s] %s" % (name, ex))

    66

    67

    @classmethod

    68

    def config_filters (cls, program=None, facility=None, pattern=None, **filters) :

    69

        """

    70

            Return filter expression from given attr/value in config.

    71

        """

    72

    73

        # XXX: get rid of these special cases

    74

        if facility :

    75

            yield 'facility', facility # glob

    76

    77

        if program :

    78

            yield 'prog', program # glob

    79

    80

        if pattern :

    81

            filters['msg'] = pattern

    82

    83

        # generic

    84

        for attr, value in filters.iteritems() :

    85

            try :

    86

                # regex

    87

                yield attr, re.compile(value)

    88

    89

            except re.error as ex :

    90

                raise ValueError("%s: %s" % (attr, ex))

    91

    92

    @classmethod

    93

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

    94

        """

    95

            Build SyslogRule from config options

    96

        """

    97

    98

        if format is not None :

    99

            format = { 'text': format }

   100

        else :

   101

            format = { }

   102

   103

        if irk :

   104

            format['irk'] = irk

   105

   106

        filters = dict(cls.config_filters(**filters))

   107

   108

        filter = SyslogFilter(filters)

   109

   110

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

   111

   112

        return cls(name, rules, filter, format)

   113

   114

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

   115

        self.name = name

   116

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

   117

        self.filter = filter # SyslogFilter

   118

        self.formats = formats or {}

   119

   120

    def match (self, item) :

   121

        """

   122

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

   123

        """

   124

   125

        if self.filter :

   126

            # filter

   127

            matches = self.filter.filter(item)

   128

   129

        else :

   130

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

   131

            return { }

   132

   133

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

   134

   135

        if matches :

   136

            return matches

   137

        else :

   138

            # no match

   139

            return None

   140

   141

    def format (self, item) :

   142

        """

   143

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

   144

        """

   145

   146

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

   147

            value = format.format(**item)

   148

   149

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

   150

   151

            yield attr, value

   152

   153

    def apply (self, item) :

   154

        """

   155

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

   156

   157

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

   158

        """

   159

   160

        log.debug("%s", self)

   161

   162

        # match rule -> matches

   163

        matches = self.match(item)

   164

   165

        if matches is None :

   166

            # skip

   167

            return None, None, None

   168

   169

        # merge matches down

   170

        item = merge(item, matches)

   171

   172

        # recursive sub-rules -> apply

   173

        for rule in self.rules :

   174

            try :

   175

                # pass matches down

   176

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

   177

   178

            except Exception as ex :

   179

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

   180

                continue # XXX: skip?

   181

   182

            if apply :

   183

                # pass apply up

   184

                break

   185

        else :

   186

            # self-match

   187

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

   188

   189

        rules.append(self)

   190

   191

        # formats?

   192

        if self.formats :

   193

            # merge apply up

   194

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

   195

   196

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

   197

   198

        return match, rules, apply

   199

   200

    def __iter__ (self, items) :

   201

        """

   202

            Apply items against our rules, yielding any matches.

   203

        """

   204

   205

        for item in items :

   206

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

   207

   208

            if apply :

   209

                yield apply

   210

   211

    def __str__ (self) :

   212

        return self.name

   213

   214

    def __repr__ (self) :

   215

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

   216