vmm: comparison VirtualMailManager/config.py

equal deleted inserted replaced

-:4cd9d0a9f42f
+:df1e3b67882a
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 VMM's configuration module for simplified configuration access.
 """
-from ConfigParser import \
+from configparser import \
 Error, MissingSectionHeaderError, NoOptionError, NoSectionError, \
 ParsingError, RawConfigParser
-from cStringIO import StringIO
+from io import StringIO
 from VirtualMailManager.common import VERSION_RE, \
 exec_ok, expand_path, get_unicode, lisdir, size_in_bytes, version_hex
 from VirtualMailManager.constants import CONF_ERROR
 from VirtualMailManager.errors import ConfigError, VMMError
 from VirtualMailManager.maillocation import known_format
 from VirtualMailManager.password import verify_scheme as _verify_scheme
+import collections
 DB_MODULES = ('psycopg2', 'pypgsql')
 DB_SSL_MODES = ('allow', 'disabled', 'prefer', 'require', 'verify-ca',
 'verify-full')
 if isinstance(value, bool):
 return value
 if value.lower() in self._boolean_states:
 return self._boolean_states[value.lower()]
 else:
-raise ConfigValueError(_(u"Not a boolean: '%s'") %
+raise ConfigValueError(_("Not a boolean: '%s'") %
 get_unicode(value))
 def getboolean(self, section, option):
 """Returns the boolean value of the option, in the given
 section.
 * `NoOptionError`
 """
 sect_opt = section_option.lower().split('.')
 # TODO: cache it
 if len(sect_opt) != 2 or not sect_opt[0] or not sect_opt[1]:
-raise BadOptionError(_(u"Bad format: '%s' - expected: "
+raise BadOptionError(_("Bad format: '%s' - expected: "
-u"section.option") %
+"section.option") %
 get_unicode(section_option))
 if not sect_opt[0] in self._cfg:
 raise NoSectionError(sect_opt[0])
 if not sect_opt[1] in self._cfg[sect_opt[0]]:
 raise NoOptionError(sect_opt[1], sect_opt[0])
 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())
+for k in self._cfg[section].keys())
 # still here? Get defaults and merge defaults with configured setting
 defaults = dict((k, self._cfg[section][k].default)
-for k in self._cfg[section].iterkeys())
+for k in self._cfg[section].keys())
 defaults.update(sect)
 if '__name__' in defaults:
 del defaults['__name__']
-return defaults.iteritems()
+return iter(defaults.items())
 def dget(self, option):
 """Returns the value of the `option`.
 If the option could not be found in the configuration file, the
 except(BadOptionError, NoSectionError, NoOptionError):
 return False
 def sections(self):
 """Returns an iterator object for all configuration sections."""
-return self._cfg.iterkeys()
+return iter(self._cfg.keys())
 class LazyConfigOption(object):
 """A simple container class for configuration settings.
 None or any method, that takes one argument, in order to
 check the value, when `LazyConfig.set()` is called.
 """
 self.__cls = cls
 self.__default = default if default is None else self.__cls(default)
-if not callable(getter):
+if not isinstance(getter, collections.Callable):
 raise TypeError('getter has to be a callable, got a %r' %
 getter.__class__.__name__)
 self.__getter = getter
-if validate and not callable(validate):
+if validate and not isinstance(validate, collections.Callable):
 raise TypeError('validate has to be callable or None, got a %r' %
 validate.__class__.__name__)
 self.__validate = validate
 @property
 'quota_messages': LCO(int, 0, self.getint),
 'transport': LCO(str, 'dovecot:', self.get),
 },
 'mailbox': {
 'folders': LCO(str, 'Drafts:Sent:Templates:Trash',
-self.unicode),
+self.str),
 'format': LCO(str, 'maildir', self.get, check_mailbox_format),
-'root': LCO(str, 'Maildir', self.unicode),
+'root': LCO(str, 'Maildir', self.str),
 'subscribe': LCO(bool_t, True, self.getboolean),
 },
 'misc': {
 'base_directory': LCO(str, '/srv/mail', self.get, is_dir),
 'crypt_blowfish_rounds': LCO(int, 5, self.getint),
 invalid.
 """
 with open(self._cfg_filename, 'r') as self._cfg_file:
 try:
 self.readfp(self._cfg_file)
-except (MissingSectionHeaderError, ParsingError), err:
+except (MissingSectionHeaderError, ParsingError) as err:
 raise ConfigError(str(err), CONF_ERROR)
 def check(self):
 """Performs a configuration check.
 Raises a ConfigError if settings w/o a default value are missed.
 Or some settings have a invalid value.
 """
 def iter_dict():
-for section, options in self._missing.iteritems():
+for section, options in self._missing.items():
-errmsg.write(_(u'* Section: %s\n') % section)
+errmsg.write(_('* Section: %s\n') % section)
-errmsg.writelines(u'    %s\n' % option for option in options)
+errmsg.writelines('    %s\n' % option for option in options)
 self._missing.clear()
 errmsg = None
 self._chk_non_default()
 miss_vers = 'misc' in self._missing and \
 'dovecot_version' in self._missing['misc']
 if self._missing:
 errmsg = StringIO()
-errmsg.write(_(u'Check of configuration file %s failed.\n') %
+errmsg.write(_('Check of configuration file %s failed.\n') %
 self._cfg_filename)
-errmsg.write(_(u'Missing options, which have no default value.\n'))
+errmsg.write(_('Missing options, which have no default value.\n'))
 iter_dict()
 self._chk_possible_values(miss_vers)
 if self._missing:
 if not errmsg:
 errmsg = StringIO()
-errmsg.write(_(u'Check of configuration file %s failed.\n') %
+errmsg.write(_('Check of configuration file %s failed.\n') %
 self._cfg_filename)
-errmsg.write(_(u'Invalid configuration values.\n'))
+errmsg.write(_('Invalid configuration values.\n'))
 else:
-errmsg.write('\n' + _(u'Invalid configuration values.\n'))
+errmsg.write('\n' + _('Invalid configuration values.\n'))
 iter_dict()
 if errmsg:
 raise ConfigError(errmsg.getvalue(), CONF_ERROR)
 def hexversion(self, section, option):
 def get_in_bytes(self, section, option):
 """Converts the size value (e.g.: 1024k) from the *option*'s
 value to a long"""
 return size_in_bytes(self.get(section, option))
-def unicode(self, section, option):
+def str(self, section, option):
 """Returns the value of the `option` from `section`, converted
 to Unicode."""
 return get_unicode(self.get(section, option))
 def _chk_non_default(self):
 """Checks all section's options for settings w/o a default
 value. Missing items will be stored in _missing.
 """
-for section in self._cfg.iterkeys():
+for section in self._cfg.keys():
 missing = []
-for option, value in self._cfg[section].iteritems():
+for option, value in self._cfg[section].items():
 if (value.default is None and
 not RawConfigParser.has_option(self, section, option)):
 missing.append(option)
 if missing:
 self._missing[section] = missing
 """Check settings for which the possible values are known."""
 if not miss_vers:
 value = self.get('misc', 'dovecot_version')
 if not VERSION_RE.match(value):
 self._missing['misc'] = ['version: ' +
-_(u"Not a valid Dovecot version: '%s'") % value]
+_("Not a valid Dovecot version: '%s'") % value]
 # section database
 db_err = []
 value = self.dget('database.module').lower()
 if value not in DB_MODULES:
 db_err.append('module: ' +
-_(u"Unsupported database module: '%s'") % value)
+_("Unsupported database module: '%s'") % value)
 if value == 'psycopg2':
 value = self.dget('database.sslmode')
 if value not in DB_SSL_MODES:
 db_err.append('sslmode: ' +
-_(u"Unknown pgsql SSL mode: '%s'") % value)
+_("Unknown pgsql SSL mode: '%s'") % value)
 if db_err:
 self._missing['database'] = db_err
 # section mailbox
 value = self.dget('mailbox.format')
 if not known_format(value):
 self._missing['mailbox'] = ['format: ' +
-_(u"Unsupported mailbox format: '%s'") % value]
+_("Unsupported mailbox format: '%s'") % value]
 # section domain
 try:
 value = self.dget('domain.quota_bytes')
-except (ValueError, TypeError), err:
+except (ValueError, TypeError) as err:
-self._missing['domain'] = [u'quota_bytes: ' + str(err)]
+self._missing['domain'] = ['quota_bytes: ' + str(err)]
 def is_dir(path):
 """Check if the expanded path is a directory.  When the expanded path
 is a directory the expanded path will be returned.  Otherwise a
 ConfigValueError will be raised.
 """
 path = expand_path(path)
 if lisdir(path):
 return path
-raise ConfigValueError(_(u"No such directory: %s") % get_unicode(path))
+raise ConfigValueError(_("No such directory: %s") % get_unicode(path))
 def check_db_module(module):
 """Check if the *module* is a supported pgsql module."""
 if module.lower() in DB_MODULES:
 return module
-raise ConfigValueError(_(u"Unsupported database module: '%s'") %
+raise ConfigValueError(_("Unsupported database module: '%s'") %
 get_unicode(module))
 def check_db_ssl_mode(ssl_mode):
 """Check if the *ssl_mode* is one of the SSL modes, known by pgsql."""
 if ssl_mode in DB_SSL_MODES:
 return ssl_mode
-raise ConfigValueError(_(u"Unknown pgsql SSL mode: '%s'") %
+raise ConfigValueError(_("Unknown pgsql SSL mode: '%s'") %
 get_unicode(ssl_mode))
 def check_mailbox_format(format):
 """
 be raised.
 """
 format = format.lower()
 if known_format(format):
 return format
-raise ConfigValueError(_(u"Unsupported mailbox format: '%s'") %
+raise ConfigValueError(_("Unsupported mailbox format: '%s'") %
 get_unicode(format))
 def check_size_value(value):
 """Check if the size value *value* has the proper format, e.g.: 1024k.
 Returns the validated value string if it has the expected format.
 Otherwise a `ConfigValueError` will be raised."""
 try:
 tmp = size_in_bytes(value)
-except (TypeError, ValueError), err:
+except (TypeError, ValueError) as err:
-raise ConfigValueError(_(u"Not a valid size value: '%s'") %
+raise ConfigValueError(_("Not a valid size value: '%s'") %
 get_unicode(value))
 return value
 def check_version_format(version_string):
 """Check if the *version_string* has the proper format, e.g.: '1.2.3'.
 Returns the validated version string if it has the expected format.
 Otherwise a `ConfigValueError` will be raised.
 """
 if not VERSION_RE.match(version_string):
-raise ConfigValueError(_(u"Not a valid Dovecot version: '%s'") %
+raise ConfigValueError(_("Not a valid Dovecot version: '%s'") %
 get_unicode(version_string))
 return version_string
 def verify_scheme(scheme):
 """Checks if the password scheme *scheme* can be accepted and returns
 the verified scheme.
 """
 try:
 scheme, encoding = _verify_scheme(scheme)
-except VMMError, err:  # 'cast' it
+except VMMError as err:  # 'cast' it
 raise ConfigValueError(err.msg)
 if not encoding:
 return scheme
 return '%s.%s' % (scheme, encoding)

branch	v0.7.x
changeset 643	df1e3b67882a
parent 642	4cd9d0a9f42f
child 650	429ba58bc302