baseconfig moved to leap.common.config

5 files changed, 2 insertions, 796 deletions

diff --git a/src/leap/config/baseconfig.py b/src/leap/config/baseconfig.py
deleted file mode 100644
index f5c07184..00000000
--- a/src/leap/config/baseconfig.py
+++ /dev/null
@@ -1,186 +0,0 @@
-# -*- coding: utf-8 -*-
-# baseconfig.py
-# Copyright (C) 2013 LEAP
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Implements the abstract base class for configuration
-"""
-
-import copy
-import logging
-import functools
-import os
-
-from abc import ABCMeta, abstractmethod
-
-from leap.common.check import leap_assert
-from leap.common.files import mkdir_p
-from leap.config.pluggableconfig import PluggableConfig
-from leap.config.prefixers import get_platform_prefixer
-
-logger = logging.getLogger(__name__)
-
-
-class BaseConfig:
-    """
-    Abstract base class for any JSON based configuration
-    """
-
-    __metaclass__ = ABCMeta
-
-    """
-    Standalone is a class wide parameter
-
-    @param standalone: if True it will return the prefix for a
-    standalone application. Otherwise, it will return the system
-    default for configuration storage.
-    @type standalone: bool
-    """
-    standalone = False
-
-    def __init__(self):
-        self._data = {}
-        self._config_checker = None
-
-    @abstractmethod
-    def _get_spec(self):
-        """
-        Returns the spec object for the specific configuration
-        """
-        return None
-
-    def _safe_get_value(self, key):
-        """
-        Tries to return a value only if the config has already been loaded
-
-        @rtype: depends on the config structure, dict, str, array, int
-        @return: returns the value for the specified key in the config
-        """
-        leap_assert(self._config_checker, "Load the config first")
-        return self._config_checker.config[key]
-
-    def get_path_prefix(self):
-        """
-        Returns the platform dependant path prefixer
-
-        """
-        return get_platform_prefixer().get_path_prefix(
-            standalone=self.standalone)
-
-    def loaded(self):
-        """
-        Returns True if the configuration has been already
-        loaded. False otherwise
-        """
-        return self._config_checker is not None
-
-    def save(self, path_list):
-        """
-        Saves the current configuration to disk
-
-        @param path_list: list of components that form the relative
-        path to configuration. The absolute path will be calculated
-        depending on the platform.
-        @type path_list: list
-
-        @return: True if saved to disk correctly, False otherwise
-        """
-        config_path = os.path.join(self.get_path_prefix(), *(path_list[:-1]))
-        mkdir_p(config_path)
-
-        try:
-            self._config_checker.serialize(os.path.join(config_path,
-                                                        path_list[-1]))
-        except Exception as e:
-            logger.warning("%s" % (e,))
-            raise
-        return True
-
-    def load(self, path="", data=None, mtime=None):
-        """
-        Loads the configuration from disk
-
-        @type path: str
-        @param path: relative path to configuration. The absolute path
-        will be calculated depending on the platform
-
-        @return: True if loaded from disk correctly, False otherwise
-        """
-
-        config_path = os.path.join(self.get_path_prefix(),
-                                   path)
-
-        self._config_checker = PluggableConfig(format="json")
-        self._config_checker.options = copy.deepcopy(self._get_spec())
-
-        try:
-            if data is None:
-                self._config_checker.load(fromfile=config_path, mtime=mtime)
-            else:
-                self._config_checker.load(data, mtime=mtime)
-        except Exception as e:
-            logger.warning("Something went wrong while loading " +
-                           "the config from %s\n%s" % (config_path, e))
-            self._config_checker = None
-            return False
-        return True
-
-
-class LocalizedKey(object):
-    """
-    Decorator used for keys that are localized in a configuration
-    """
-
-    def __init__(self, func, **kwargs):
-        self._func = func
-
-    def __call__(self, instance, lang="en"):
-        """
-        Tries to return the string for the specified language, otherwise
-        informs the problem and returns an empty string
-
-        @param lang: language code
-        @type lang: str
-
-        @return: localized value from the possible values returned by
-        self._func
-        """
-        descriptions = self._func(instance)
-        description_lang = ""
-        config_lang = "en"
-        for key in descriptions.keys():
-            if lang.startswith(key):
-                config_lang = key
-                break
-
-        description_lang = descriptions[config_lang]
-        return description_lang
-
-    def __get__(self, instance, instancetype):
-        """
-        Implement the descriptor protocol to make decorating instance
-        method possible.
-        """
-        # Return a partial function with the first argument is the instance
-        # of the class decorated.
-        return functools.partial(self.__call__, instance)
-
-if __name__ == "__main__":
-    try:
-        config = BaseConfig()  # should throw TypeError for _get_spec
-    except Exception as e:
-        assert isinstance(e, TypeError), "Something went wrong"
-        print "Abstract BaseConfig class is working as expected"
diff --git a/src/leap/config/leapsettings.py b/src/leap/config/leapsettings.py
index 19ec4a9a..df9c9f11 100644
--- a/src/leap/config/leapsettings.py
+++ b/src/leap/config/leapsettings.py
@@ -24,7 +24,7 @@ import logging
 from PySide import QtCore
 
 from leap.common.check import leap_assert, leap_assert_type
-from leap.config.prefixers import get_platform_prefixer
+from leap.common.config.prefixers import get_platform_prefixer
 
 logger = logging.getLogger(__name__)
 
diff --git a/src/leap/config/pluggableconfig.py b/src/leap/config/pluggableconfig.py
deleted file mode 100644
index 8535fa6b..00000000
--- a/src/leap/config/pluggableconfig.py
+++ /dev/null
@@ -1,475 +0,0 @@
-# -*- coding: utf-8 -*-
-# pluggableconfig.py
-# Copyright (C) 2013 LEAP
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-generic configuration handlers
-"""
-import copy
-import json
-import logging
-import os
-import time
-import urlparse
-
-import jsonschema
-
-#from leap.base.util.translations import LEAPTranslatable
-from leap.common.check import leap_assert
-
-
-logger = logging.getLogger(__name__)
-
-
-__all__ = ['PluggableConfig',
-           'adaptors',
-           'types',
-           'UnknownOptionException',
-           'MissingValueException',
-           'ConfigurationProviderException',
-           'TypeCastException']
-
-# exceptions
-
-
-class UnknownOptionException(Exception):
-    """exception raised when a non-configuration
-    value is present in the configuration"""
-
-
-class MissingValueException(Exception):
-    """exception raised when a required value is missing"""
-
-
-class ConfigurationProviderException(Exception):
-    """exception raised when a configuration provider is missing, etc"""
-
-
-class TypeCastException(Exception):
-    """exception raised when a
-    configuration item cannot be coerced to a type"""
-
-
-class ConfigAdaptor(object):
-    """
-    abstract base class for config adaotors for
-    serialization/deserialization and custom validation
-    and type casting.
-    """
-    def read(self, filename):
-        raise NotImplementedError("abstract base class")
-
-    def write(self, config, filename):
-        with open(filename, 'w') as f:
-            self._write(f, config)
-
-    def _write(self, fp, config):
-        raise NotImplementedError("abstract base class")
-
-    def validate(self, config, schema):
-        raise NotImplementedError("abstract base class")
-
-
-adaptors = {}
-
-
-class JSONSchemaEncoder(json.JSONEncoder):
-    """
-    custom default encoder that
-    casts python objects to json objects for
-    the schema validation
-    """
-    def default(self, obj):
-        if obj is str:
-            return 'string'
-        if obj is unicode:
-            return 'string'
-        if obj is int:
-            return 'integer'
-        if obj is list:
-            return 'array'
-        if obj is dict:
-            return 'object'
-        if obj is bool:
-            return 'boolean'
-
-
-class JSONAdaptor(ConfigAdaptor):
-    indent = 2
-    extensions = ['json']
-
-    def read(self, _from):
-        if isinstance(_from, file):
-            _from_string = _from.read()
-        if isinstance(_from, str):
-            _from_string = _from
-        return json.loads(_from_string)
-
-    def _write(self, fp, config):
-        fp.write(json.dumps(config,
-                 indent=self.indent,
-                 sort_keys=True))
-
-    def validate(self, config, schema_obj):
-        schema_json = JSONSchemaEncoder().encode(schema_obj)
-        schema = json.loads(schema_json)
-        jsonschema.validate(config, schema)
-
-
-adaptors['json'] = JSONAdaptor()
-
-#
-# Adaptors
-#
-# Allow to apply a predefined set of types to the
-# specs, so it checks the validity of formats and cast it
-# to proper python types.
-
-# TODO:
-# - HTTPS uri
-
-
-class DateType(object):
-    fmt = '%Y-%m-%d'
-
-    def to_python(self, data):
-        return time.strptime(data, self.fmt)
-
-    def get_prep_value(self, data):
-        return time.strftime(self.fmt, data)
-
-
-class TranslatableType(object):
-    """
-    a type that casts to LEAPTranslatable objects.
-    Used for labels we get from providers and stuff.
-    """
-
-    def to_python(self, data):
-        # TODO: add translatable
-        return data  # LEAPTranslatable(data)
-
-    # needed? we already have an extended dict...
-    #def get_prep_value(self, data):
-        #return dict(data)
-
-
-class URIType(object):
-
-    def to_python(self, data):
-        parsed = urlparse.urlparse(data)
-        if not parsed.scheme:
-            raise TypeCastException("uri %s has no schema" % data)
-        return parsed.geturl()
-
-    def get_prep_value(self, data):
-        return data
-
-
-class HTTPSURIType(object):
-
-    def to_python(self, data):
-        parsed = urlparse.urlparse(data)
-        if not parsed.scheme:
-            raise TypeCastException("uri %s has no schema" % data)
-        if parsed.scheme != "https":
-            raise TypeCastException(
-                "uri %s does not has "
-                "https schema" % data)
-        return parsed.geturl()
-
-    def get_prep_value(self, data):
-        return data
-
-
-types = {
-    'date': DateType(),
-    'uri': URIType(),
-    'https-uri': HTTPSURIType(),
-    'translatable': TranslatableType(),
-}
-
-
-class PluggableConfig(object):
-
-    options = {}
-
-    def __init__(self,
-                 adaptors=adaptors,
-                 types=types,
-                 format=None):
-
-        self.config = {}
-        self.adaptors = adaptors
-        self.types = types
-        self._format = format
-        self.mtime = None
-        self.dirty = False
-
-    @property
-    def option_dict(self):
-        if hasattr(self, 'options') and isinstance(self.options, dict):
-            return self.options.get('properties', None)
-
-    def items(self):
-        """
-        act like an iterator
-        """
-        if isinstance(self.option_dict, dict):
-            return self.option_dict.items()
-        return self.options
-
-    def validate(self, config, format=None):
-        """
-        validate config
-        """
-        schema = self.options
-        if format is None:
-            format = self._format
-
-        if format:
-            adaptor = self.get_adaptor(self._format)
-            adaptor.validate(config, schema)
-        else:
-            # we really should make format mandatory...
-            logger.error('no format passed to validate')
-
-        # first round of validation is ok.
-        # now we proceed to cast types if any specified.
-        self.to_python(config)
-
-    def to_python(self, config):
-        """
-        cast types following first type and then format indications.
-        """
-        unseen_options = [i for i in config if i not in self.option_dict]
-        if unseen_options:
-            raise UnknownOptionException(
-                "Unknown options: %s" % ', '.join(unseen_options))
-
-        for key, value in config.items():
-            _type = self.option_dict[key].get('type')
-            if _type is None and 'default' in self.option_dict[key]:
-                _type = type(self.option_dict[key]['default'])
-            if _type is not None:
-                tocast = True
-                if not callable(_type) and isinstance(value, _type):
-                    tocast = False
-                if tocast:
-                    try:
-                        config[key] = _type(value)
-                    except BaseException, e:
-                        raise TypeCastException(
-                            "Could not coerce %s, %s, "
-                            "to type %s: %s" % (key, value, _type.__name__, e))
-            _format = self.option_dict[key].get('format', None)
-            _ftype = self.types.get(_format, None)
-            if _ftype:
-                try:
-                    config[key] = _ftype.to_python(value)
-                except BaseException, e:
-                    raise TypeCastException(
-                        "Could not coerce %s, %s, "
-                        "to format %s: %s" % (key, value,
-                        _ftype.__class__.__name__,
-                        e))
-
-        return config
-
-    def prep_value(self, config):
-        """
-        the inverse of to_python method,
-        called just before serialization
-        """
-        for key, value in config.items():
-            _format = self.option_dict[key].get('format', None)
-            _ftype = self.types.get(_format, None)
-            if _ftype and hasattr(_ftype, 'get_prep_value'):
-                try:
-                    config[key] = _ftype.get_prep_value(value)
-                except BaseException, e:
-                    raise TypeCastException(
-                        "Could not serialize %s, %s, "
-                        "by format %s: %s" % (key, value,
-                        _ftype.__class__.__name__,
-                        e))
-            else:
-                config[key] = value
-        return config
-
-    # methods for adding configuration
-
-    def get_default_values(self):
-        """
-        return a config options from configuration defaults
-        """
-        defaults = {}
-        for key, value in self.items():
-            if 'default' in value:
-                defaults[key] = value['default']
-        return copy.deepcopy(defaults)
-
-    def get_adaptor(self, format):
-        """
-        get specified format adaptor or
-        guess for a given filename
-        """
-        adaptor = self.adaptors.get(format, None)
-        if adaptor:
-            return adaptor
-
-        # not registered in adaptors dict, let's try all
-        for adaptor in self.adaptors.values():
-            if format in adaptor.extensions:
-                return adaptor
-
-    def filename2format(self, filename):
-        extension = os.path.splitext(filename)[-1]
-        return extension.lstrip('.') or None
-
-    def serialize(self, filename, format=None, full=False):
-        if not format:
-            format = self._format
-        if not format:
-            format = self.filename2format(filename)
-        if not format:
-            raise Exception('Please specify a format')
-            # TODO: more specific exception type
-
-        adaptor = self.get_adaptor(format)
-        if not adaptor:
-            raise Exception("Adaptor not found for format: %s" % format)
-
-        config = copy.deepcopy(self.config)
-        serializable = self.prep_value(config)
-        adaptor.write(serializable, filename)
-
-        if self.mtime:
-            self.touch_mtime(filename)
-
-    def touch_mtime(self, filename):
-        mtime = self.mtime
-        os.utime(filename, (mtime, mtime))
-
-    def deserialize(self, string=None, fromfile=None, format=None):
-        """
-        load configuration from a file or string
-        """
-
-        def _try_deserialize():
-            if fromfile:
-                with open(fromfile, 'r') as f:
-                    content = adaptor.read(f)
-            elif string:
-                content = adaptor.read(string)
-            return content
-
-        # XXX cleanup this!
-
-        if fromfile:
-            leap_assert(os.path.exists(fromfile))
-            if not format:
-                format = self.filename2format(fromfile)
-
-        if not format:
-            format = self._format
-        if format:
-            adaptor = self.get_adaptor(format)
-        else:
-            adaptor = None
-
-        if adaptor:
-            content = _try_deserialize()
-            return content
-
-        # no adaptor, let's try rest of adaptors
-
-        adaptors = self.adaptors[:]
-
-        if format:
-            adaptors.sort(
-                key=lambda x: int(
-                    format in x.extensions),
-                reverse=True)
-
-        for adaptor in adaptors:
-            content = _try_deserialize()
-        return content
-
-    def set_dirty(self):
-        self.dirty = True
-
-    def is_dirty(self):
-        return self.dirty
-
-    def load(self, *args, **kwargs):
-        """
-        load from string or file
-        if no string of fromfile option is given,
-        it will attempt to load from defaults
-        defined in the schema.
-        """
-        string = args[0] if args else None
-        fromfile = kwargs.get("fromfile", None)
-        mtime = kwargs.pop("mtime", None)
-        self.mtime = mtime
-        content = None
-
-        # start with defaults, so we can
-        # have partial values applied.
-        content = self.get_default_values()
-        if string and isinstance(string, str):
-            content = self.deserialize(string)
-
-        if not string and fromfile is not None:
-            #import ipdb;ipdb.set_trace()
-            content = self.deserialize(fromfile=fromfile)
-
-        if not content:
-            logger.error('no content could be loaded')
-            # XXX raise!
-            return
-
-        # lazy evaluation until first level of nesting
-        # to allow lambdas with context-dependant info
-        # like os.path.expanduser
-        for k, v in content.iteritems():
-            if callable(v):
-                content[k] = v()
-
-        self.validate(content)
-        self.config = content
-        return True
-
-
-def testmain():  # pragma: no cover
-
-    from tests import test_validation as t
-    import pprint
-
-    config = PluggableConfig(_format="json")
-    properties = copy.deepcopy(t.sample_spec)
-
-    config.options = properties
-    config.load(fromfile='data.json')
-
-    print 'config'
-    pprint.pprint(config.config)
-
-    config.serialize('/tmp/testserial.json')
-
-if __name__ == "__main__":
-    testmain()
diff --git a/src/leap/config/prefixers.py b/src/leap/config/prefixers.py
deleted file mode 100644
index 72211790..00000000
--- a/src/leap/config/prefixers.py
+++ /dev/null
@@ -1,133 +0,0 @@
-# -*- coding: utf-8 -*-
-# prefixers.py
-# Copyright (C) 2013 LEAP
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-Platform dependant configuration path prefixers
-"""
-import os
-import platform
-
-from abc import ABCMeta, abstractmethod
-
-from xdg import BaseDirectory
-
-from leap.common.check import leap_assert
-
-
-class Prefixer:
-    """
-    Abstract prefixer class
-    """
-
-    __metaclass__ = ABCMeta
-
-    @abstractmethod
-    def get_path_prefix(self, standalone=False):
-        """
-        Returns the platform dependant path prefixer
-
-        @param standalone: if True it will return the prefix for a
-        standalone application. Otherwise, it will return the system
-        default for configuration storage.
-        @type standalone: bool
-        """
-        return ""
-
-
-def get_platform_prefixer():
-    prefixer = globals()[platform.system() + "Prefixer"]
-    leap_assert(prefixer, "Unimplemented platform prefixer: %s" %
-                (platform.system(),))
-    return prefixer()
-
-
-class LinuxPrefixer(Prefixer):
-    """
-    Config prefixer for the Linux platform
-    """
-
-    def get_path_prefix(self, standalone=False):
-        """
-        Returns the platform dependant path prefixer.
-        This method expects an env variable named LEAP_CLIENT_PATH if
-        standalone is used.
-
-        @param standalone: if True it will return the prefix for a
-        standalone application. Otherwise, it will return the system
-        default for configuration storage.
-        @type standalone: bool
-        """
-        config_dir = BaseDirectory.xdg_config_home
-        if not standalone:
-            return config_dir
-        return os.path.join(os.getcwd(), "config")
-
-
-class DarwinPrefixer(Prefixer):
-    """
-    Config prefixer for the Darwin platform
-    """
-
-    def get_path_prefix(self, standalone=False):
-        """
-        Returns the platform dependant path prefixer.
-        This method expects an env variable named LEAP_CLIENT_PATH if
-        standalone is used.
-
-        @param standalone: if True it will return the prefix for a
-        standalone application. Otherwise, it will return the system
-        default for configuration storage.
-        @type standalone: bool
-        """
-        config_dir = BaseDirectory.xdg_config_home
-        if not standalone:
-            return config_dir
-        return os.getenv(os.getcwd(), "config")
-
-
-class WindowsPrefixer(Prefixer):
-    """
-    Config prefixer for the Windows platform
-    """
-
-    def get_path_prefix(self, standalone=False):
-        """
-        Returns the platform dependant path prefixer.
-        This method expects an env variable named LEAP_CLIENT_PATH if
-        standalone is used.
-
-        @param standalone: if True it will return the prefix for a
-        standalone application. Otherwise, it will return the system
-        default for configuration storage.
-        @type standalone: bool
-        """
-        config_dir = BaseDirectory.xdg_config_home
-
-        if not standalone:
-            return config_dir
-        return os.path.join(os.getcwd(), "config")
-
-if __name__ == "__main__":
-    try:
-        abs_prefixer = Prefixer()
-    except Exception as e:
-        assert isinstance(e, TypeError), "Something went wrong"
-        print "Abstract Prefixer class is working as expected"
-
-    linux_prefixer = LinuxPrefixer()
-    print linux_prefixer.get_path_prefix(standalone=True)
-    print linux_prefixer.get_path_prefix()
diff --git a/src/leap/config/providerconfig.py b/src/leap/config/providerconfig.py
index 7651863b..5aa0cc6e 100644
--- a/src/leap/config/providerconfig.py
+++ b/src/leap/config/providerconfig.py
@@ -22,7 +22,7 @@ import logging
 import os
 
 from leap.common.check import leap_assert
-from leap.config.baseconfig import BaseConfig, LocalizedKey
+from leap.common.config.baseconfig import BaseConfig, LocalizedKey
 from leap.config.provider_spec import leap_provider_spec
 
 logger = logging.getLogger(__name__)