git.maemo.org Git - dbuscron/blob - dbuscron/parser.py

   1 # encoding: utf-8
   2 from __future__ import with_statement
   3 import os
   4 import re
   5 from dbuscron.bus import DbusBus
   6
   7 def unescape_():
   8     h = '[0-9A-Fa-f]'
   9     r = re.compile(r'\\x('+h+r'{2})|\\u('+h+'{4})')
  10
  11     def unescape(value):
  12         if not (value and
  13                 (r'\x' in value or r'\u' in value)):
  14             return value
  15
  16         return r.sub(
  17             lambda m: chr(int(m.group(1), 16))
  18                 if m.group(1) is not None else
  19                     unichr(int(m.group(2), 16))
  20                         .encode('utf-8'),\
  21             value)
  22     return unescape
  23 unescape = unescape_()
  24
  25 def product(*args):
  26     if args:
  27         head, tail = args[0], args[1:]
  28         for h in head:
  29             for t in product(*tail):
  30                 yield (h,) + t
  31
  32     else:
  33         yield ()
  34
  35 class CrontabParserError(SyntaxError):
  36     def __init__(self, message, lineno, expected=None):
  37         if expected:
  38             if isinstance(expected, (tuple, list)):
  39                 exp = ' (expected %s or %s)' % (', '.join(expected[:-1]), expected[-1])
  40         else:
  41             exp = ''
  42
  43         msg = '%s%s at line %d' % (message, exp, lineno)
  44
  45         SyntaxError.__init__(self, msg)
  46
  47 def CrontabParser(*filenames):
  48     for filename in filenames:
  49         if not os.path.exists(filename):
  50             continue
  51
  52         if os.path.isfile(filename):
  53             parser_class = FileParser
  54
  55         elif os.path.isdir(filename):
  56             parser_class = DirectoryParser
  57
  58         else:
  59             raise SystemError("I can parse only directories or simple files.")
  60
  61         return parser_class(filename)
  62
  63     raise SystemError("Can't find any config file or directory.")
  64
  65 class FileParser(object):
  66     __fields_sep = re.compile(r'\s+')
  67     __envvar_sep = re.compile(r'\s*=\s*')
  68     __fields_chk = {
  69             'bus_'         : None,
  70             'type_'        : ('signal', 'method_call', 'method_return', 'error'),
  71             'sender_'      : None,
  72             'interface_'   : re.compile(r'^[a-zA-Z][a-zA-Z0-9_.]+$'),
  73             'path_'        : re.compile(r'^/[a-zA-Z0-9_/]+$'),
  74             'member_'      : re.compile(r'^[a-zA-Z][a-zA-Z0-9_]+$'),
  75             'destination_' : None,
  76             'args_'        : None,
  77             }
  78     __fields = [
  79             'bus_',
  80             'type_',
  81             'sender_',
  82             'interface_',
  83             'path_',
  84             'member_',
  85             'destination_',
  86             'args_',
  87             ]
  88
  89     def __init__(self, fname):
  90         self._bus = DbusBus()
  91         self._filename = fname
  92         self._environ = dict()
  93
  94     @property
  95     def environ(self):
  96         return self._environ
  97
  98     @property
  99     def filename(self):
 100         return self._filename
 101
 102     def _iterate_file(self, filename):
 103         # bus type sender interface path member destination args command
 104         lineno = 0
 105         with open(filename) as f:
 106             for line in f:
 107                 lineno += 1
 108                 line = line.strip()
 109
 110                 if not line or line.startswith('#'):
 111                     continue
 112
 113                 parts = self.__fields_sep.split(line, 8)
 114                 if len(parts) < 9:
 115                     parts = self.__envvar_sep.split(line, 1)
 116                     if len(parts) == 2:
 117                         self.__environ[parts[0]] = parts[1]
 118                         continue
 119
 120                     raise CrontabParserError('Unexpected number of records', lineno)
 121
 122                 rule = [('s', 'S'), self.__fields_chk['type_'], (None,), (None,), (None,), (None,), (None,), (None,)]
 123
 124                 for p in range(0, 8):
 125                     if parts[p] != '*':
 126                         rule[p] = parts[p].split(',')
 127
 128                 command = parts[8]
 129
 130                 for r in product(*rule):
 131                     r = list(r)
 132                     if r[0] == 'S':
 133                         r[0] = self._bus.system
 134                     elif r[0] == 's':
 135                         r[0] = self._bus.session
 136                     else:
 137                         raise CrontabParserError('Unexpected bus value', lineno, expected=('S', 's', '*'))
 138
 139                     if r[7]:
 140                         r[7] = map(unescape, r[7].split(';'))
 141
 142                     ruled = dict()
 143                     for i, f in enumerate(self.__fields):
 144                         if r[i] is not None and self.__fields_chk[f]:
 145                             if isinstance(self.__fields_chk[f], tuple):
 146                                 if r[i] not in self.__fields_chk[f]:
 147                                     raise CrontabParserError('Unexpected %s value' % (f.strip('_')), lineno,
 148                                             expected=self.__fields_chk[f])
 149                             else:
 150                                 if not self.__fields_chk[f].match(r[i]):
 151                                     raise CrontabParserError('Incorrect %s value' % (f.strip('_')), lineno)
 152                         ruled[f] = r[i]
 153
 154                     yield ruled, command
 155
 156     def __iter__(self):
 157         return self._iterate_file(self._filename)
 158
 159 class DirectoryParser(FileParser):
 160
 161     def __init__(self, dirname, recursive=False):
 162         self.__recursive = recursive
 163         super(DirectoryParser, self).__init__(dirname)
 164
 165     def _dirwalker_plain(self):
 166         for i in os.listdir(self._filename):
 167             f = os.path.join(self._filename, i)
 168             if os.path.isfile(f):
 169                 yield f
 170
 171     def _dirwalker_recursive(self):
 172         for r, d, f in os.walk(self._filename):
 173             for i in f:
 174                 yield os.path.join(r, i)
 175
 176     def __iter__(self):
 177         if self.__recursive:
 178             dirwalker = self._dirwalker_recursive
 179         else:
 180             dirwalker = self._dirwalker_plain
 181
 182         for fname in dirwalker():
 183             for item in self._iterate_file(fname):
 184                 yield item
 185
 186 def OptionsParser(args=None, help=u'', **opts):
 187
 188     from optparse import OptionParser
 189     import dbuscron
 190     parser = OptionParser(usage=help, version="%prog " + dbuscron.__version__)
 191     for opt, desc in opts.iteritems():
 192         names = desc.pop('names')
 193         desc['dest'] = opt
 194         parser.add_option(*names, **desc)
 195
 196     return parser.parse_args(args)[0]
 197