diff options
Diffstat (limited to 'ipalib/config.py')
-rw-r--r-- | ipalib/config.py | 166 |
1 files changed, 164 insertions, 2 deletions
diff --git a/ipalib/config.py b/ipalib/config.py index b3155490c..86d8f1da7 100644 --- a/ipalib/config.py +++ b/ipalib/config.py @@ -25,11 +25,13 @@ It will also take care of settings that can be discovered by different methods, such as DNS. """ -from ConfigParser import SafeConfigParser, ParsingError +from ConfigParser import SafeConfigParser, ParsingError, RawConfigParser import types import os - +from os import path +import sys from errors import check_isinstance, raise_TypeError +import constants DEFAULT_CONF='/etc/ipa/ipa.conf' @@ -126,6 +128,166 @@ class Environment(object): return default +class Env(object): + """ + A mapping object used to store the environment variables. + """ + + __locked = False + + def __init__(self): + object.__setattr__(self, '_Env__d', {}) + self.ipalib = path.dirname(path.abspath(__file__)) + self.site_packages = path.dirname(self.ipalib) + self.script = path.abspath(sys.argv[0]) + self.bin = path.dirname(self.script) + self.home = path.abspath(os.environ['HOME']) + self.dot_ipa = path.join(self.home, '.ipa') + + def _bootstrap(self, **overrides): + """ + Initialize basic environment. + + This method will initialize only enough environment information to + determine whether ipa is running in-tree, what the context is, + and the location of the configuration file. + + This method should be called before any plugins are loaded. + """ + for (key, value) in overrides.items(): + self[key] = value + if 'in_tree' not in self: + if self.bin == self.site_packages and \ + path.isfile(path.join(self.bin, 'setup.py')): + self.in_tree = True + else: + self.in_tree = False + if 'context' not in self: + self.context = 'default' + if 'conf' not in self: + name = '%s.conf' % self.context + if self.in_tree: + self.conf = path.join(self.dot_ipa, name) + else: + self.conf = path.join('/', 'etc', 'ipa', name) + + def _load_config(self, conf_file): + """ + Merge in values from ``conf_file`` into this `Env`. + """ + section = constants.CONFIG_SECTION + if not path.isfile(conf_file): + return + parser = RawConfigParser() + try: + parser.read(conf_file) + except ParsingError: + return + if not parser.has_section(section): + parser.add_section(section) + items = parser.items(section) + if len(items) == 0: + return + i = 0 + for (key, value) in items: + if key not in self: + self[key] = value + i += 1 + return (i, len(items)) + + def _finalize(self, **defaults): + """ + Finalize and lock environment. + + This method should be called after all plugins have bean loaded and + after `plugable.API.finalize()` has been called. + """ + + def __lock__(self): + """ + Prevent further changes to environment. + """ + if self.__locked is True: + raise StandardError( + '%s.__lock__() already called' % self.__class__.__name__ + ) + object.__setattr__(self, '_Env__locked', True) + + def __getattr__(self, name): + """ + Return the attribute named ``name``. + """ + if name in self.__d: + return self[name] + raise AttributeError('%s.%s' % + (self.__class__.__name__, name) + ) + + def __setattr__(self, name, value): + """ + Set the attribute named ``name`` to ``value``. + """ + self[name] = value + + def __delattr__(self, name): + """ + Raise AttributeError (deletion is not allowed). + """ + raise AttributeError('cannot del %s.%s' % + (self.__class__.__name__, name) + ) + + def __getitem__(self, key): + """ + Return the value corresponding to ``key``. + """ + if key not in self.__d: + raise KeyError(key) + value = self.__d[key] + if callable(value): + return value() + return value + + def __setitem__(self, key, value): + """ + Set ``key`` to ``value``. + """ + # FIXME: the key should be checked with check_name() + if self.__locked: + raise AttributeError('locked: cannot set %s.%s to %r' % + (self.__class__.__name__, key, value) + ) + if key in self.__d or hasattr(self, key): + raise AttributeError('cannot overwrite %s.%s with %r' % + (self.__class__.__name__, key, value) + ) + if not callable(value): + if isinstance(value, basestring): + value = str(value.strip()) + if value.lower() == 'true': + value = True + elif value.lower() == 'false': + value = False + elif value.isdigit(): + value = int(value) + assert type(value) in (str, int, bool) + object.__setattr__(self, key, value) + self.__d[key] = value + + def __contains__(self, key): + """ + Return True if instance contains ``key``; otherwise return False. + """ + return key in self.__d + + def __iter__(self): # Fix + """ + Iterate through keys in ascending order. + """ + for key in sorted(self.__d): + yield key + + def set_default_env(env): """ Set default values for ``env``. |