vmm: comparison VirtualMailManager/Config.py

equal deleted inserted replaced

-:d0425225ce52
+:6e1ef32fbd82
 from shutil import copy2
 from ConfigParser import (Error, MissingSectionHeaderError, NoOptionError,
 NoSectionError, ParsingError, RawConfigParser)
-from cStringIO import StringIO
+from cStringIO import StringIO# TODO: move interactive stff to cli
-from __main__ import os, ENCODING, ERR, get_unicode, w_std
+import VirtualMailManager.constants.ERROR as ERR
-from Exceptions import VMMConfigException
+from VirtualMailManager import ENCODING, exec_ok, get_unicode, is_dir
+from VirtualMailManager.cli import w_std# move to cli
+from VirtualMailManager.Exceptions import VMMConfigException
 class BadOptionError(Error):
 """Raised when a option isn't in the format 'section.option'."""
 pass
 option, section))
 class LazyConfig(RawConfigParser):
 """The **lazy** derivate of the `RawConfigParser`.
 There are two additional getters:
 `LazyConfig.pget()`
 The polymorphic getter, which returns a option's value with the
 appropriate type.
 `LazyConfig.dget()`
 Like `LazyConfig.pget()`, but returns the option's default, from
 Else one of the following exceptions will be thrown:
 * `BadOptionError`
 * `NoSectionError`
 * `NoOptionError`
 """
 sect_opt = section_option.lower().split('.')
 if len(sect_opt) != 2:# do we need a regexp to check the format?
 raise BadOptionError(
 _(u'Bad format: “%s” - expected: section.option') % \
 get_unicode(section_option))
 if '__name__' in d: del d['__name__']
 return d.iteritems()
 def dget(self, option):
 """Returns the value of the `option`.
 If the option could not be found in the configuration file, the
 configured default value, from ``LazyConfig._cfg`` will be
 returned.
 Arguments:
 `option` : string
 the configuration option in the form
 "``section``\ **.**\ ``option``"
 Throws a `NoDefaultError`, if no default value was passed to
 section, option = self.__get_section_option(option)
 return self._cfg[section][option].getter(section, option)
 def set(self, option, value):
 """Set the value of an option.
 Throws a ``ValueError`` if `value` couldn't be converted to
 ``LazyConfigOption.cls``"""
 section, option = self.__get_section_option(option)
 val = self._cfg[section][option].cls(value)
 if not self._cfg[section][option].validate is None:
 RawConfigParser.set(self, section, option, val)
 self._modified = True
 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 option."""
 try:
 self.__get_section_option(option)
 return True
 except(BadOptionError, NoSectionError, NoOptionError):
 return False
 class LazyConfigOption(object):
 """A simple container class for configuration settings.
 def __init__(self, filename):
 """Creates a new Config instance
 Arguments:
 ``filename``
 path to the configuration file
 """
 LazyConfig.__init__(self)
 self.__cfgFileName = filename
 'pop3' :            LCO(bool_t, True,  self.get_boolean),
 'sieve':            LCO(bool_t, True,  self.get_boolean),
 'smtp' :            LCO(bool_t, True,  self.get_boolean),
 },
 'bin': {
-'dovecotpw': LCO(str, '/usr/sbin/dovecotpw', self.get,
+'dovecotpw': LCO(str, '/usr/sbin/dovecotpw', self.get, exec_ok),
-self.exec_ok),
+'du':        LCO(str, '/usr/bin/du',        self.get, exec_ok),
-'du':        LCO(str, '/usr/bin/du', self.get, self.exec_ok),
+'postconf':  LCO(str, '/usr/sbin/postconf', self.get, exec_ok),
-'postconf':  LCO(str, '/usr/sbin/postconf', self.get,
-self.exec_ok),
 },
 'database': {
 'host': LCO(str, 'localhost', self.get),
 'name': LCO(str, 'mailsys',   self.get),
 'pass': LCO(str, None,        self.get),
 'maildir': {
 'folders': LCO(str, 'Drafts:Sent:Templates:Trash', self.get),
 'name':    LCO(str, 'Maildir',                     self.get),
 },
 'misc': {
-'base_directory':  LCO(str, '/srv/mail', self.get, self.is_dir),
+'base_directory':  LCO(str, '/srv/mail', self.get, is_dir),
 'dovecot_version': LCO(int, 12,          self.getint),
 'gid_mail':        LCO(int, 8,           self.getint),
 'password_scheme': LCO(str, 'CRAM-MD5',  self.get,
 self.known_scheme),
 'transport':       LCO(str, 'dovecot:',  self.get),
 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():
 errmsg = StringIO()
 errmsg.write(_(u'Missing options, which have no default value.\n'))
 errmsg.write(_(u'Using configuration file: %s\n') %\
 self.__cfgFileName)
 def getsections(self):
 """Returns an iterator object for all configuration sections."""
 return self._cfg.iterkeys()
-def is_dir(self, path):
-"""Checks if ``path`` is a directory.
-Throws a `ConfigValueError` if ``path`` is not a directory.
-"""
-path = self.__expand_path(path)
-if not os.path.isdir(path):
-raise ConfigValueError(_(u'“%s” is not a directory') % \
-get_unicode(path))
-return path
-def exec_ok(self, binary):
-"""Checks if the ``binary`` exists and if it is executable.
-Throws a `ConfigValueError` if the ``binary`` isn't a file or is
-not executable.
-"""
-binary = self.__expand_path(binary)
-if not os.path.isfile(binary):
-raise ConfigValueError(_(u'“%s” is not a file') % \
-get_unicode(binary))
-if not os.access(binary, os.X_OK):
-raise ConfigValueError(_(u'File is not executable: “%s”') % \
-get_unicode(binary))
-return binary
 def known_scheme(self, scheme):
 """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
 """Interactive method for configuring all options in the given sections
 Arguments:
 sections -- list of strings with section names
 """
+# TODO: Derivate CliConfig from Config an move the interactive
+#       stuff to CliConfig
 input_fmt = _(u'Enter new value for option %(option)s \
 [%(current_value)s]: ')
 failures = 0
 w_std(_(u'Using configuration file: %s\n') % self.__cfgFileName)
 if self._modified:
 self.__saveChanges()
 def __saveChanges(self):
 """Writes changes to the configuration file."""
+# TODO: Move interactive stuff to CliConfig
 copy2(self.__cfgFileName, self.__cfgFileName+'.bak')
 self.__cfgFile = open(self.__cfgFileName, 'w')
 self.write(self.__cfgFile)
 self.__cfgFile.close()
 def __chkCfg(self):
 """Checks all section's options for settings w/o default values.
 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():
 errors = True
 if len(missing):
 self.__missing[section] = missing
 return not errors
-def __expand_path(self, path):
-"""Expands paths, starting with ``.`` or ``~``, to an absolute path."""
-if path.startswith('.'):
-return os.path.abspath(path)
-if path.startswith('~'):
-return os.path.expanduser(path)
-return path

branch	v0.6.x
changeset 185	6e1ef32fbd82
parent 180	f8279c90e99c
child 187	38b9a9859749