1 #!/usr/bin/env python

     2 

     3 """

     4     Syslog -> Irk

     5 """

     6 

     7 __version__ = '0.0'

     8 

     9 import pvl.args

    10 import pvl.syslog.args

    11 import pvl.syslog.rule

    12 import pvl.irk

    13 

    14 import logging, optparse

    15 

    16 log = logging.getLogger('main')

    17 

    18 def parse_options (argv) :

    19     """

    20         Parse command-line arguments.

    21     """

    22 

    23     prog = argv[0]

    24 

    25     parser = optparse.OptionParser(

    26             prog        = prog,

    27             usage       = '%prog: [options]',

    28             version     = __version__,

    29 

    30             # module docstring

    31             description = __doc__,

    32     )

    33     

    34     # options

    35     parser.add_option_group(pvl.args.parser(parser))

    36 

    37     # input

    38     parser.add_option_group(pvl.syslog.args.parser(parser))

    39     parser.add_option_group(pvl.syslog.rule.parser(parser))

    40     parser.add_option_group(pvl.irk.parser(parser, connect=None))

    41 

    42     parser.add_option('--irker-target', metavar='IRC',

    43             help="Irker target URL")

    44 

    45     # parse

    46     options, args = parser.parse_args(argv[1:])

    47     

    48     # apply

    49     pvl.args.apply(options, prog, rootok=False)

    50 

    51     return options, args

    52 

    53 def apply_irker (irker) :

    54     """

    55         Handle irker activity.

    56     """

    57 

    58     for msg in irker.irk :

    59         log.info("irk: %s", msg)

    60  

    61 def apply_syslog (options, syslog, rules, irker) :

    62     """

    63         Handle syslog activity.

    64     """

    65 

    66     # syslogs

    67     for item in syslog :

    68         match, rulepath, apply = rules.apply(item)

    69         

    70         log.debug("%s: %s: %s", item, rulepath, apply)

    71         

    72         target = apply.get('irk', options.irker_target)

    73         

    74         tag = '/'.join(str(rule) for rule in reversed(rulepath[:-1]))

    75         text = apply.get('text')

    76         

    77         log.info("%s: %s: %s", target, tag, text)

    78 

    79         if not text :

    80             # XXX: plain irk = ... in rule is broken, as it always applies, and skips any further rules

    81             continue

    82         

    83         if irker and target :

    84             irker[target]('[' + tag + '] ' + text)

    85         else :

    86             print tag, text

    87 

    88 def close_irker (irker) :

    89     """

    90         Shutdown irker before quitting.

    91 

    92         XXX: irker.close() to disconnect?

    93     """

    94     

    95     log.info("Shutting down IRK...")

    96 

    97     for target in list(irker) :

    98         log.warn("%s", target)

    99         del irker[target]

   100 

   101 def close_syslog (syslog) :

   102     """

   103         Shutdown syslog before quitting

   104     """

   105     

   106     # XXX: do all sources support close()?

   107     log.warn("%s", syslog)

   108     syslog.close()

   109 

   110 def main (argv) :

   111     options, args = parse_options(argv)

   112     

   113     # no args

   114     if args :

   115         log.error("Usage: pvl.irker-syslog [options]")

   116         return 2

   117     

   118     # setup

   119     log.info("Open syslog...")

   120     syslog = pvl.syslog.args.apply(options)

   121     

   122     log.info("Load rules...")

   123     rules = pvl.syslog.rule.apply(options)

   124 

   125     log.info("Connect IRK..")

   126     irker = pvl.irk.apply(options)

   127     

   128     if options.irker_target :

   129         # pre-join target

   130         irker[options.irker_target]

   131 

   132     log.info("Process syslog messages...")

   133 

   134     # customized mainloop that supports irker.irk

   135     while True :

   136         try :

   137             # TODO: seprate IrkError, to not confuse irk write vs syslog read eof

   138             apply_syslog(options, syslog, rules, irker)

   139 

   140         except EOFError as ex :

   141             log.error("syslog: EOF")

   142 

   143             close_irker(irker)

   144             

   145             # 0 is controlled exit

   146             return 0

   147 

   148         except pvl.irk.IrkError as ex :

   149             log.error("irker: %s", ex)

   150 

   151             # XXX: copy-pasta

   152             close_syslog(syslog)

   153             return 0

   154 

   155         # quit unless we have something to poll

   156         if not syslog.poll :

   157             break

   158 

   159         # is irk pollable?

   160         if irker.irk.recv :

   161             reading = (irker.irk, )

   162         else :

   163             reading = ()

   164         

   165         poll = syslog.select(syslog.poll, reading=reading) or () # timeout -> ()

   166         

   167         if irker.irk in poll :

   168             # irks?

   169             try :

   170                 apply_irker(irker)

   171 

   172             except EOFError :

   173                 log.error("irk: EOF")

   174                 

   175                 close_syslog(syslog)

   176 

   177                 # exit 0, so as to restart sooner

   178                 # XXX: maybe use a special exit code instead?

   179                 return 0

   180      

   181     # done

   182     log.info("Exiting...")

   183     return 0

   184 

   185 if __name__ == '__main__':

   186     import sys

   187 

   188     sys.exit(main(sys.argv))