import os
import imp
import cherrypy
+import inspect
+from ipsilon.util.data import AdminStore
+from ipsilon.util.log import Log
+
class Plugins(object):
- def __init__(self, path=None):
- if path is None:
- self._path = os.getcwd()
- else:
- self._path = path
+ def __init__(self):
self._providers_tree = None
def _load_class(self, tree, class_type, file_name):
try:
if ext.lower() == '.py':
mod = imp.load_source(name, file_name)
- elif ext.lower() == '.pyc':
- mod = imp.load_compiled(name, file_name)
+ # elif ext.lower() == '.pyc':
+ # mod = imp.load_compiled(name, file_name)
else:
return
except Exception, e: # pylint: disable=broad-except
return
if hasattr(mod, class_type):
- tree[name] = getattr(mod, class_type)()
- cherrypy.log.error('Added module %s' % (name))
+ instance = getattr(mod, class_type)()
+ public_name = getattr(instance, 'name', name)
+ tree[public_name] = instance
+ cherrypy.log.error('Added module %s as %s' % (name, public_name))
def _load_classes(self, tree, path, class_type):
files = None
filename = os.path.join(path, name)
self._load_class(tree, class_type, filename)
- def get_providers(self):
- if self._providers_tree is None:
- path = None
- if 'providers.dir' in cherrypy.config:
- path = cherrypy.config['providers.dir']
- if not path:
- path = os.path.join(self._path, 'providers')
+ def get_plugins(self, path, class_type):
+ plugins = dict()
+ self._load_classes(plugins, path, class_type)
+ return plugins
+
+
+class PluginLoader(object):
+
+ def __init__(self, baseobj, facility, plugin_type):
+ config = AdminStore().load_options(facility)
+ cherrypy.log('LOAD: %s\n' % repr(config))
+ whitelist = []
+ if 'global' in config:
+ sec = config['global']
+ if 'order' in sec:
+ whitelist = sec['order'].split(',')
+ if cherrypy.config.get('debug', False):
+ cherrypy.log('[%s] %s: %s' % (facility, whitelist, config))
+ if config is None:
+ config = dict()
+
+ p = Plugins()
+ (pathname, dummy) = os.path.split(inspect.getfile(baseobj))
+ self._plugins = {
+ 'config': config,
+ 'available': p.get_plugins(pathname, plugin_type),
+ 'whitelist': whitelist,
+ 'enabled': []
+ }
+
+ def get_plugin_data(self):
+ return self._plugins
+
+
+class PluginInstaller(object):
+ def __init__(self, baseobj):
+ (pathname, dummy) = os.path.split(inspect.getfile(baseobj))
+ self._pathname = pathname
+
+ def get_plugins(self):
+ p = Plugins()
+ return p.get_plugins(self._pathname, 'Installer')
+
+
+class PluginObject(Log):
+
+ def __init__(self):
+ self.name = None
+ self._config = None
+ self._options = None
+ self._data = AdminStore()
+
+ def get_config_desc(self, name=None):
+ """ The configuration description is a dictionary that provides
+ A description of the supported configuration options, as well
+ as the default configuration option values.
+ The key is the option name, the value is an array of 3 elements:
+ - description
+ - option type
+ - default value
+ """
+ if name is None:
+ return self._options
+
+ opt = self._options.get(name, None)
+ if opt is None:
+ return ''
+ return opt[0]
+
+ def _value_to_list(self, name):
+ if name not in self._config:
+ return
+ value = self._config[name]
+ if type(value) is list:
+ return
+ vlist = [x.strip() for x in value.split(',')]
+ self._config[name] = vlist
+
+ def set_config(self, config):
+ self._config = config
+ if self._config is None:
+ return
+ if self._options:
+ for name, opt in self._options.iteritems():
+ if opt[1] == 'list':
+ self._value_to_list(name)
+
+ def get_config_value(self, name):
+ value = None
+ if self._config:
+ value = self._config.get(name, None)
+ if value is None:
+ if self._options:
+ opt = self._options.get(name, None)
+ if opt:
+ value = opt[2]
+
+ if cherrypy.config.get('debug', False):
+ cherrypy.log('[%s] %s: %s' % (self.name, name, value))
+
+ return value
+
+ def set_config_value(self, option, value):
+ if not self._config:
+ self._config = dict()
+ self._config[option] = value
+ if self._options and option in self._options:
+ if self._options[option][1] == 'list':
+ self._value_to_list(option)
+
+ def get_plugin_config(self, facility):
+ return self._data.load_options(facility, self.name)
+
+ def refresh_plugin_config(self, facility):
+ config = self.get_plugin_config(facility)
+ self.set_config(config)
+
+ def save_plugin_config(self, facility, config=None):
+ if config is None:
+ config = self._config
+ config = config.copy()
+
+ for key, value in config.items():
+ if type(value) is list:
+ config[key] = ','.join(value)
+
+ self._data.save_options(facility, self.name, config)
+
+ def get_data(self, idval=None, name=None, value=None):
+ return self._data.get_data(self.name, idval=idval, name=name,
+ value=value)
+
+ def save_data(self, data):
+ self._data.save_data(self.name, data)
+
+ def new_datum(self, datum):
+ self._data.new_datum(self.name, datum)
- self._providers_tree = []
- self._load_classes(self._providers_tree, path, 'IdpProvider')
+ def del_datum(self, idval):
+ self._data.del_datum(self.name, idval)
- return self._providers_tree
+ def wipe_config_values(self, facility):
+ self._data.delete_options(facility, self.name, None)
- def get_custom(self, path, class_type):
- tree = []
- self._load_classes(tree, path, class_type)
- return tree
+ def wipe_data(self):
+ self._data.wipe_data(self.name)