summaryrefslogtreecommitdiff
path: root/src/leap/base/config.py
diff options
context:
space:
mode:
Diffstat (limited to 'src/leap/base/config.py')
-rw-r--r--src/leap/base/config.py108
1 files changed, 32 insertions, 76 deletions
diff --git a/src/leap/base/config.py b/src/leap/base/config.py
index 7f69a41c..dc047f80 100644
--- a/src/leap/base/config.py
+++ b/src/leap/base/config.py
@@ -9,14 +9,12 @@ import tempfile
import os
logger = logging.getLogger(name=__name__)
-logger.setLevel('DEBUG')
-import configuration
-import jsonschema
import requests
from leap.base import exceptions
from leap.base import constants
+from leap.base.pluggableconfig import PluggableConfig
from leap.util.fileutil import (mkdir_p)
# move to base!
@@ -47,20 +45,6 @@ class BaseLeapConfig(object):
raise NotImplementedError("abstract base class")
-class SchemaEncoder(json.JSONEncoder):
- def default(self, obj):
- if obj is str:
- return 'string'
- if obj is unicode:
- return 'string'
- if obj is int:
- return 'int'
- if obj is list:
- return 'array'
- if obj is dict:
- return 'object'
-
-
class MetaConfigWithSpec(type):
"""
metaclass for JSONLeapConfig classes.
@@ -73,63 +57,43 @@ class MetaConfigWithSpec(type):
# place where we want to enforce
# singletons, read-only and similar stuff.
- # TODO:
- # - add a error handler for missing options that
- # we can act easily upon (sys.exit is ugly, for $deity's sake)
-
def __new__(meta, classname, bases, classDict):
schema_obj = classDict.get('spec', None)
- if schema_obj:
- spec_options = schema_obj.get('properties', None)
- schema_json = SchemaEncoder().encode(schema_obj)
- schema = json.loads(schema_json)
- else:
- spec_options = None
- schema = None
+
# not quite happy with this workaround.
# I want to raise if missing spec dict, but only
# for grand-children of this metaclass.
# maybe should use abc module for this.
abcderived = ("JSONLeapConfig",)
- if spec_options is None and classname not in abcderived:
- if not schema_obj:
- raise exceptions.ImproperlyConfigured(
- "missing spec dict on your derived class (%s)" % classname)
- if schema_obj and not spec_options:
- raise exceptions.ImproperlyConfigured(
- "missing properties attr in spec dict "
- "on your derived class (%s)" % classname)
-
- # we create a configuration spec attribute from the spec dict
+ if schema_obj is None and classname not in abcderived:
+ raise exceptions.ImproperlyConfigured(
+ "missing spec dict on your derived class (%s)" % classname)
+
+ # we create a configuration spec attribute
+ # from the spec dict
config_class = type(
classname + "Spec",
- (configuration.Configuration, object),
- {'options': spec_options})
+ (PluggableConfig, object),
+ {'options': schema_obj})
classDict['spec'] = config_class
- # A shipped json-schema for validation
- classDict['schema'] = schema
return type.__new__(meta, classname, bases, classDict)
##########################################################
-# hacking in progress:
+# some hacking still in progress:
# Configs have:
+
# - a slug (from where a filename/folder is derived)
# - a spec (for validation and defaults).
-# this spec is basically a dict that will be used
+# this spec is conformant to the json-schema.
+# basically a dict that will be used
# for type casting and validation, and defaults settings.
# all config objects, since they are derived from BaseConfig, implement basic
# useful methods:
# - save
# - load
-# - get_config (returns a optparse.OptionParser object)
-
-# TODO:
-# [done] raise validation errors
-# - have a good type cast repertory (uris, version, hashes...)
-# - multilingual objects
##########################################################
@@ -152,10 +116,10 @@ class JSONLeapConfig(BaseLeapConfig):
raise exceptions.ImproperlyConfigured(
"missing spec on JSONLeapConfig"
" derived class")
- assert issubclass(self.spec, configuration.Configuration)
+ assert issubclass(self.spec, PluggableConfig)
- self._config = self.spec()
- self._config.parse_args(list(args))
+ self._config = self.spec(format="json")
+ self._config.load()
self.fetcher = kwargs.pop('fetcher', requests)
# mandatory baseconfig interface
@@ -166,13 +130,6 @@ class JSONLeapConfig(BaseLeapConfig):
folder, filename = os.path.split(to)
if folder and not os.path.isdir(folder):
mkdir_p(folder)
- # lazy evaluation until first level of nesting
- # to allow lambdas with context-dependant info
- # like os.path.expanduser
- config = self.get_config()
- for k, v in config.iteritems():
- if callable(v):
- config[k] = v()
self._config.serialize(to)
def load(self, fromfile=None, from_uri=None, fetcher=None, verify=False):
@@ -183,10 +140,7 @@ class JSONLeapConfig(BaseLeapConfig):
if fromfile is None:
fromfile = self.filename
if os.path.isfile(fromfile):
- newconfig = self._config.deserialize(fromfile)
- # XXX check for no errors, etc
- # XXX could validate here!
- self._config.config = newconfig
+ self._config.load(fromfile=fromfile)
else:
logger.error('tried to load config from non-existent path')
logger.error('Not Found: %s', fromfile)
@@ -196,19 +150,25 @@ class JSONLeapConfig(BaseLeapConfig):
fetcher = self.fetcher
logger.debug('verify: %s', verify)
request = fetcher.get(uri, verify=verify)
+ # XXX should send a if-modified-since header
# XXX get 404, ...
# and raise a UnableToFetch...
request.raise_for_status()
fd, fname = tempfile.mkstemp(suffix=".json")
- if not request.json:
+
+ if request.json:
+ self._config.load(json.dumps(request.json))
+
+ else:
+ # not request.json
+ # might be server did not announce content properly,
+ # let's try deserializing all the same.
try:
- json.loads(request.content)
+ self._config.load(request.content)
except ValueError:
raise eipexceptions.LeapBadConfigFetchedError
- with open(fname, 'w') as tmp:
- tmp.write(json.dumps(request.json))
- self._loadtemp(fname)
+
return True
def get_config(self):
@@ -223,20 +183,16 @@ class JSONLeapConfig(BaseLeapConfig):
def filename(self):
return self.get_filename()
- def jsonvalidate(self, data):
- jsonschema.validate(data, self.schema)
+ def validate(self, data):
+ logger.debug('validating schema')
+ self._config.validate(data)
return True
# private
- def _loadtemp(self, filename):
- self.load(fromfile=filename)
- os.remove(filename)
-
def _slug_to_filename(self):
# is this going to work in winland if slug is "foo/bar" ?
folder, filename = os.path.split(self.slug)
- # XXX fix import
config_file = get_config_file(filename, folder)
return config_file