vmm: comparison VirtualMailManager/Config.py

equal deleted inserted replaced

-:84e6e898e6c5
+:33f727efa7c4
 from cStringIO import StringIO# TODO: move interactive stff to cli
 from VirtualMailManager import exec_ok, get_unicode, is_dir
 from VirtualMailManager.constants.ERROR import CONF_ERROR
 from VirtualMailManager.Exceptions import VMMConfigException
+_ = lambda msg: msg
 class BadOptionError(Error):
 """Raised when a option isn't in the format 'section.option'."""
 pass
 `dget()`
 Like `LazyConfig.pget()`, but returns the option's default, from
 `LazyConfig._cfg['sectionname']['optionname'].default`, if the
 option is not configured in a ini-like configuration file.
-`set()` differs from `RawConfigParser`'s `set()` method. `set()` takes
+`set()` differs from `RawConfigParser`'s `set()` method. `set()`
-the `section` and `option` arguments combined to a single string in the
+takes the `section` and `option` arguments combined to a single
-form "section.option".
+string in the form "section.option".
 """
 def __init__(self):
 RawConfigParser.__init__(self)
 self._modified = False
+# sample _cfg dict.  Create your own in your derived class.
 self._cfg = {
 'sectionname': {
-'optionname': LazyConfigOption(int, 1, self.getint)
+'optionname': LazyConfigOption(int, 1, self.getint),
 }
 }
-"""sample _cfg dictionary. Create your own in your derived class."""
 def bool_new(self, value):
 """Converts the string `value` into a `bool` and returns it.
 | '1', 'on', 'yes' and 'true' will become `True`
 else:
 raise ConfigValueError(_(u"Not a boolean: '%s'") %
 get_unicode(value))
 def getboolean(self, section, option):
-"""Returns the boolean value of the option, in the given section.
+"""Returns the boolean value of the option, in the given
+section.
 For a boolean True, the value must be set to '1', 'on', 'yes',
 'true' or True. For a boolean False, the value must set to '0',
 'off', 'no', 'false' or False.
-If the option has another value assigned this method will raise a
+If the option has another value assigned this method will raise
-ValueError.
+a ValueError.
 """
 # if the setting was modified it may be still a boolean value lets see
 tmp = self.get(section, option)
 if isinstance(tmp, bool):
 return tmp
 if not tmp.lower() in self._boolean_states:
-raise ValueError, 'Not a boolean: %s' % tmp
+raise ValueError('Not a boolean: %s' % tmp)
 return self._boolean_states[tmp.lower()]
 def _get_section_option(self, section_option):
-"""splits ``section_option`` (section\ **.**\ option) in two parts
+"""splits ``section_option`` (section.option) in two parts and
-and returns them as list ``[section, option]``, if:
+returns them as list ``[section, option]``, if:
 * it likes the format of ``section_option``
 * the ``section`` is known
 * the ``option`` is known
 Else one of the following exceptions will be thrown:
 * `BadOptionError`
 * `NoSectionError`
 * `NoOptionError`
 """
 sect_opt = section_option.lower().split('.')
 # TODO: cache it
 if len(sect_opt) != 2:# do we need a regexp to check the format?
 raise BadOptionError(
 if not sect_opt[1] in self._cfg[sect_opt[0]]:
 raise NoOptionError(sect_opt[1], sect_opt[0])
 return sect_opt
 def items(self, section):
-"""returns an iterable that returns key, value ``tuples`` from the
+"""returns an iterable that returns key, value ``tuples`` from
-given ``section``."""
+the given ``section``.
+"""
 if section in self._sections:# check if the section was parsed
-d2 = self._sections[section]
+sect = self._sections[section]
 elif not section in self._cfg:
 raise NoSectionError(section)
 else:
 return ((k, self._cfg[section][k].default) \
 for k in self._cfg[section].iterkeys())
 # still here? Get defaults and merge defaults with configured setting
-d = dict((k, self._cfg[section][k].default) \
+defaults = dict((k, self._cfg[section][k].default) \
 for k in self._cfg[section].iterkeys())
-d.update(d2)
+defaults.update(sect)
-if '__name__' in d:
+if '__name__' in defaults:
-del d['__name__']
+del defaults['__name__']
-return d.iteritems()
+return defaults.iteritems()
 def dget(self, option):
 """Returns the value of the `option`.
 If the option could not be found in the configuration file, the
 returned.
 Arguments:
 `option` : string
-the configuration option in the form
+the configuration option in the form "section.option"
-"``section``\ **.**\ ``option``"
 Throws a `NoDefaultError`, if no default value was passed to
 `LazyConfigOption.__init__()` for the `option`.
 """
 section, option = self._get_section_option(option)
 try:
 return self._cfg[section][option].getter(section, option)
 except (NoSectionError, NoOptionError):
 def set(self, option, value):
 """Set the `value` of the `option`.
 Throws a `ValueError` if `value` couldn't be converted using
-`LazyConfigOption.cls`"""
+`LazyConfigOption.cls`.
+"""
 section, option = self._get_section_option(option)
 val = self._cfg[section][option].cls(value)
 if self._cfg[section][option].validate:
 val = self._cfg[section][option].validate(val)
 if not RawConfigParser.has_section(self, section):
 def has_section(self, section):
 """Checks if `section` is a known configuration section."""
 return section.lower() in self._cfg
 def has_option(self, option):
-"""Checks if the option (section.option) is a known configuration
+"""Checks if the option (section.option) is a known
-option."""
+configuration option.
+"""
 try:
 self._get_section_option(option)
 return True
 except(BadOptionError, NoSectionError, NoOptionError):
 return False
 """A simple container class for configuration settings.
 `LazyConfigOption` instances are required by `LazyConfig` instances,
 and instances of classes derived from `LazyConfig`, like the
 `Config` class.
 """
 __slots__ = ('__cls', '__default', '__getter', '__validate')
 def __init__(self, cls, default, getter, validate=None):
 """Creates a new `LazyConfigOption` instance.
 Arguments:
 `cls` : type
 The class/type of the option's value
 `default`
-Default value of the option. Use ``None`` if the option should not
+Default value of the option. Use ``None`` if the option should
-have a default value.
+not have a default value.
 `getter` : callable
-A method's name of `RawConfigParser` and derived classes, to get a
+A method's name of `RawConfigParser` and derived classes, to
-option's value, e.g. `self.getint`.
+get a option's value, e.g. `self.getint`.
 `validate` : NoneType or a callable
-None or any method, that takes one argument, in order to check the
+None or any method, that takes one argument, in order to
-value, when `LazyConfig.set()` is called.
+check the value, when `LazyConfig.set()` is called.
 """
 self.__cls = cls
 if not default is None:# enforce the type of the default value
 self.__default = self.__cls(default)
 else:
 validate.__class__.__name__)
 self.__validate = validate
 @property
 def cls(self):
-"""The class of the option's value e.g. `str`, `unicode` or `bool`"""
+"""The class of the option's value e.g. `str`, `unicode` or
+`bool`.
+"""
 return self.__cls
 @property
 def default(self):
 """The option's default value, may be `None`"""
 Arguments:
 `filename` : str
 path to the configuration file
 """
 LazyConfig.__init__(self)
-self._cfgFileName = filename
+self._cfg_filename = filename
-self._cfgFile = None
+self._cfg_file = None
 self.__missing = {}
 LCO = LazyConfigOption
 bool_t = self.bool_new
 self._cfg = {
 'account': {
 'delete_directory': LCO(bool_t, False, self.getboolean),
-'directory_mode':   LCO(int,    448,   self.getint),
+'directory_mode': LCO(int, 448, self.getint),
-'disk_usage':       LCO(bool_t, False, self.getboolean),
+'disk_usage': LCO(bool_t, False, self.getboolean),
-'password_length':  LCO(int,    8,     self.getint),
+'password_length': LCO(int, 8, self.getint),
-'random_password':  LCO(bool_t, False, self.getboolean),
+'random_password': LCO(bool_t, False, self.getboolean),
-'imap' :            LCO(bool_t, True,  self.getboolean),
+'imap': LCO(bool_t, True, self.getboolean),
-'pop3' :            LCO(bool_t, True,  self.getboolean),
+'pop3': LCO(bool_t, True, self.getboolean),
-'sieve':            LCO(bool_t, True,  self.getboolean),
+'sieve': LCO(bool_t, True, self.getboolean),
-'smtp' :            LCO(bool_t, True,  self.getboolean),
+'smtp': LCO(bool_t, True, self.getboolean),
 },
 'bin': {
-'dovecotpw': LCO(str, '/usr/sbin/dovecotpw', self.get, exec_ok),
+'dovecotpw': LCO(str, '/usr/sbin/dovecotpw', self.get,
-'du':        LCO(str, '/usr/bin/du',        self.get, exec_ok),
+exec_ok),
-'postconf':  LCO(str, '/usr/sbin/postconf', self.get, exec_ok),
+'du': LCO(str, '/usr/bin/du', self.get, exec_ok),
+'postconf': LCO(str, '/usr/sbin/postconf', self.get, exec_ok),
 },
 'database': {
 'host': LCO(str, 'localhost', self.get),
-'name': LCO(str, 'mailsys',   self.get),
+'name': LCO(str, 'mailsys', self.get),
-'pass': LCO(str, None,        self.get),
+'pass': LCO(str, None, self.get),
-'user': LCO(str, None,        self.get),
+'user': LCO(str, None, self.get),
 },
 'domain': {
-'auto_postmaster':  LCO(bool_t, True,  self.getboolean),
+'auto_postmaster': LCO(bool_t, True, self.getboolean),
 'delete_directory': LCO(bool_t, False, self.getboolean),
-'directory_mode':   LCO(int,    504,   self.getint),
+'directory_mode': LCO(int, 504, self.getint),
-'force_deletion':   LCO(bool_t, False, self.getboolean),
+'force_deletion': LCO(bool_t, False, self.getboolean),
 },
 'maildir': {
 'folders': LCO(str, 'Drafts:Sent:Templates:Trash', self.get),
-'name':    LCO(str, 'Maildir',                     self.get),
+'name': LCO(str, 'Maildir', self.get),
 },
 'misc': {
-'base_directory':  LCO(str, '/srv/mail', self.get, is_dir),
+'base_directory': LCO(str, '/srv/mail', self.get, is_dir),
-'dovecot_version': LCO(int, 12,          self.getint),
+'dovecot_version': LCO(int, 12, self.getint),
-'gid_mail':        LCO(int, 8,           self.getint),
+'gid_mail': LCO(int, 8, self.getint),
-'password_scheme': LCO(str, 'CRAM-MD5',  self.get,
+'password_scheme': LCO(str, 'CRAM-MD5', self.get,
 self.known_scheme),
-'transport':       LCO(str, 'dovecot:',  self.get),
+'transport': LCO(str, 'dovecot:', self.get),
 },
 }
-def configure(self, sections):
-raise NotImplementedError
 def load(self):
 """Loads the configuration, read only.
-Raises a VMMConfigException if the configuration syntax is invalid.
+Raises a VMMConfigException if the configuration syntax is
+invalid.
 """
 try:
-self._cfgFile = open(self._cfgFileName, 'r')
+self._cfg_file = open(self._cfg_filename, 'r')
-self.readfp(self._cfgFile)
+self.readfp(self._cfg_file)
-except (MissingSectionHeaderError, ParsingError), e:
+except (MissingSectionHeaderError, ParsingError), err:
-raise VMMConfigException(str(e), CONF_ERROR)
+raise VMMConfigException(str(err), CONF_ERROR)
 finally:
-if self._cfgFile and not self._cfgFile.closed:
+if self._cfg_file and not self._cfg_file.closed:
-self._cfgFile.close()
+self._cfg_file.close()
 def check(self):
 """Performs a configuration check.
 Raises a VMMConfigException if the check fails.
 """
 # TODO: There are only two settings w/o defaults.
 #       So there is no need for cStringIO
-if not self.__chkCfg():
+if not self.__chk_cfg():
 errmsg = StringIO()
 errmsg.write(_(u'Missing options, which have no default value.\n'))
 errmsg.write(_(u'Using configuration file: %s\n') %
-self._cfgFileName)
+self._cfg_filename)
 for section, options in self.__missing.iteritems():
 errmsg.write(_(u'* Section: %s\n') % section)
 for option in options:
 errmsg.write((u'    %s\n') % option)
 raise VMMConfigException(errmsg.getvalue(), CONF_ERROR)
 """Converts `scheme` to upper case and checks if is known by
 Dovecot (listed in VirtualMailManager.SCHEMES).
 Throws a `ConfigValueError` if the scheme is not listed in
 VirtualMailManager.SCHEMES.
 """
 scheme = scheme.upper()
 # TODO: VMM.SCHEMES
 def unicode(self, section, option):
-"""Returns the value of the `option` from `section`, converted to
+"""Returns the value of the `option` from `section`, converted
-Unicode."""
+to Unicode.
+"""
 return get_unicode(self.get(section, option))
-def __chkCfg(self):
+def __chk_cfg(self):
-"""Checks all section's options for settings w/o a default value.
+"""Checks all section's options for settings w/o a default
+value.
-Returns `True` if everything is fine, else `False`."""
+Returns `True` if everything is fine, else `False`.
+"""
 errors = False
 for section in self._cfg.iterkeys():
 missing = []
 for option, value in self._cfg[section].iteritems():
 if (value.default is None and
 not RawConfigParser.has_option(self, section, option)):
 missing.append(option)
 errors = True
 if missing:
 self.__missing[section] = missing
 return not errors
+del _

branch	v0.6.x
changeset 215	33f727efa7c4
parent 211	0b129678cfe1
child 216	0c8c053b451c