diff options
Diffstat (limited to 'sdv/core/loader/loader_servant.py')
| -rw-r--r-- | sdv/core/loader/loader_servant.py | 183 |
1 files changed, 0 insertions, 183 deletions
diff --git a/sdv/core/loader/loader_servant.py b/sdv/core/loader/loader_servant.py deleted file mode 100644 index 4e55c67..0000000 --- a/sdv/core/loader/loader_servant.py +++ /dev/null @@ -1,183 +0,0 @@ -# Copyright 2020 Intel Corporation, Spirent Communications. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -""" -Loader Support Module. -""" - -import os -from os import sys -import imp -import fnmatch -import logging -from conf import settings - - -class LoaderServant(): - """Class implements basic dynamic import operations. - """ - _class_name = None - _path = None - _interface = None - - def __init__(self, path, class_name, interface): - """LoaderServant constructor - - Intializes all data needed for import operations. - - Attributes: - path: path to directory which contains implementations derived from - interface. - class_name: Class name which will be returned in get_class - method, if such definition exists in directory - represented by path, - interface: interface type. Every object which doesn't - implement this particular interface will be - filtered out. - """ - self._class_name = class_name - self._path = path - self._interface = interface - - def get_class(self): - """Returns class type based on parameters passed in __init__. - - :return: Type of the found class. - None if class hasn't been found - """ - - return self.load_module(path=self._path, - interface=self._interface, - class_name=self._class_name) - - def get_classes(self): - """Returns all classes in path derived from interface - - :return: Dictionary with following data: - - key: String representing class name, - - value: Class type. - """ - return self.load_modules(path=self._path, - interface=self._interface) - - def get_classes_printable(self): - """Returns all classes derived from _interface found in path - - :return: String - list of classes in printable format. - """ - - out = self.load_modules(path=self._path, - interface=self._interface) - results = [] - - # sort modules to produce the same output everytime - for (name, mod) in sorted(out.items()): - desc = (mod.__doc__ or 'No description').strip().split('\n')[0] - results.append((name, desc)) - - header = 'Classes derived from: ' + self._interface.__name__ - output = [header + '\n' + '=' * len(header) + '\n'] - - for (name, desc) in results: - output.append('* %-18s%s' % ('%s:' % name, desc)) - - output.append('') - - output.append('') - - return '\n'.join(output) - - @staticmethod - def load_module(path, interface, class_name): - """Imports everything from given path and returns class type - - This is based on following conditions: - - Class is derived from interface, - - Class type name matches class_name. - - :return: Type of the found class. - None if class hasn't been found - """ - - results = LoaderServant.load_modules( - path=path, interface=interface) - - if class_name in results: - logging.info( - "Class found: %s.", class_name) - return results.get(class_name) - - return None - - @staticmethod - def load_modules(path, interface): - """Returns dictionary of class name/class type found in path - - This is based on following conditions: - - classes found under path are derived from interface. - - class is not interface itself. - - :return: Dictionary with following data: - - key: String representing class name, - - value: Class type. - """ - result = {} - - for _, mod in LoaderServant._load_all_modules(path): - # find all classes derived from given interface, but suppress - # interface itself and any abstract class starting with iface name - gens = dict((k, v) for (k, v) in list(mod.__dict__.items()) - if isinstance(v, type) and - issubclass(v, interface) and - not k.startswith(interface.__name__)) - if gens: - for (genname, gen) in list(gens.items()): - result[genname] = gen - return result - - @staticmethod - def _load_all_modules(path): - """Load all modules from ``path`` directory. - - This is based on the design used by OFTest: - https://github.com/floodlight/oftest/blob/master/oft - - :param path: Path to a folder of modules. - - :return: List of modules in a folder. - """ - mods = [] - - for root, _, filenames in os.walk(path): - # Iterate over each python file - for filename in fnmatch.filter(filenames, '[!.]*.py'): - modname = os.path.splitext(os.path.basename(filename))[0] - - # skip module load if it is excluded by configuration - if modname in settings.getValue('EXCLUDE_MODULES'): - continue - - try: - if modname in sys.modules: - mod = sys.modules[modname] - else: - mod = imp.load_module( - modname, *imp.find_module(modname, [root])) - except ImportError: - logging.error('Could not import file %s', filename) - raise - - mods.append((modname, mod)) - - return mods |