--- /dev/null
+# Copyright 2019 Nokia
+#
+# 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.
+#
+
+import os
+import os.path
+import sys
+import inspect
+from yarf.iniloader import INILoader
+from yarf.restresource import RestResource
+from yarf.versionhandler import VersionHandler
+from yarf.authentication.base_auth import BaseAuthMethod
+from yarf.exceptions import ConfigError
+import yarf.restfullogger as restlog
+
+class PluginLoader(object):
+ def __init__(self, path, api, auth_method):
+ self.logger = restlog.get_logger()
+ self.plugin_class_type = RestResource
+ self.auth_method = self._get_auth_method(auth_method)
+ self.path = path
+ self.api = api
+
+ def get_module_dirs(self):
+ files = os.listdir(self.path)
+ modules = []
+ for f in files:
+ if os.path.isdir("%s/%s"%(self.path, f)):
+ modules.append("%s/%s"%(self.path, f))
+ return modules
+
+ def _get_auth_method(self, authmethod):
+ auth_class_module = None
+ class_name = None
+ try:
+ auth_class_module, class_name = authmethod.rsplit('.', 1)
+ except ValueError:
+ error = "Cannot decode the authentication method from configuration file"
+ self.logger.error(error)
+ raise ConfigError(error)
+ auth_classes = self._get_classes_wanted_classes(auth_class_module, [class_name], BaseAuthMethod)
+ if auth_classes is None or auth_classes == []:
+ error = "Cannot find the authentication class in provided module %s %s" % (auth_class_module, class_name)
+ raise ConfigError(error)
+ return auth_classes[0]
+
+ def _get_classes_wanted_classes(self, module_name, wanted_modules, class_type):
+ classes = []
+ try:
+ __import__(module_name)
+ except ImportError:
+ self.logger.error("Failed import in %s, skipping", module_name)
+ return None
+ module = sys.modules[module_name]
+ for obj_name in dir(module):
+ # Skip objects that are meant to be private.
+ if obj_name.startswith('_'):
+ continue
+ # Skip the same name that base class has
+ elif obj_name == class_type.__name__:
+ continue
+ elif obj_name not in wanted_modules:
+ continue
+ itm = getattr(module, obj_name)
+ if inspect.isclass(itm) and issubclass(itm, class_type):
+ classes.append(itm)
+ return classes
+
+ def get_classes_from_dir(self, directory, wanted_modules):
+ classes = []
+ if directory not in sys.path:
+ sys.path.append(directory)
+ for fname in os.listdir(directory):
+ root, ext = os.path.splitext(fname)
+ if ext != '.py' or root == '__init__':
+ continue
+ module_name = "%s" % (root)
+
+ mod_classes = self._get_classes_wanted_classes(module_name, wanted_modules, self.plugin_class_type)
+ if mod_classes:
+ classes.extend(mod_classes)
+ return classes
+
+ def get_modules_from_dir(self, module_dir):
+ modules = {}
+ for f in os.listdir(module_dir):
+ if not f.endswith(".ini"):
+ continue
+ root, _ = os.path.splitext(f)
+ loader = INILoader("%s/%s" %(module_dir, f))
+ sections = loader.get_sections()
+ modules[root] = {}
+ for section in sections:
+ handlers = loader.get_handlers(section)
+ if handlers:
+ modules[root][section] = handlers
+ else:
+ self.logger.error("Problem in the configuration file %s in section %s: No handlers found", f, section)
+ return modules
+
+ def get_auth_method(self):
+ return self.auth_method()
+
+ def get_modules(self):
+ dirs = self.get_module_dirs()
+ auth_class = self.auth_method()
+ modules = []
+ for d in dirs:
+ wanted_modules = self.get_modules_from_dir(d)
+ for mod in wanted_modules.keys():
+ for api_version in wanted_modules[mod].keys():
+ classes = self.get_classes_from_dir(d, wanted_modules[mod][api_version])
+ if not classes:
+ continue
+ for c in classes:
+ setattr(c, "subarea", mod)
+ if getattr(c, "authentication_method", "EMPTY") == "EMPTY":
+ setattr(c, "authentication_method", auth_class)
+ if getattr(c, "api_versions", None):
+ c.api_versions.append(api_version)
+ else:
+ setattr(c, "api_versions", [api_version])
+ for cls in classes:
+ if cls not in modules:
+ modules.append(cls)
+ return modules
+
+ def create_endpoints(self, handler):
+ endpoint_list = []
+ for endpoint in handler.endpoints:
+ for api_version in handler.api_versions:
+ self.logger.debug("Registering /%s/%s/%s for %s", handler.subarea, api_version, endpoint, handler.__name__)
+ endpoint_list.append("/%s/%s/%s"% (handler.subarea, api_version, endpoint))
+ self.api.add_resource(handler, *(endpoint_list))
+
+ def add_logger(self, handler):
+ self.logger.info("Adding logger to: %s", handler.__name__)
+ handler.logger = self.logger
+
+ def init_handler(self, handler):
+
+ self.add_logger(handler)
+ handler.add_wrappers()
+ self.create_endpoints(handler)
+ handler.add_parser_arguments()
+
+ def create_api_versionhandlers(self, handlers):
+ apiversions = {}
+ endpoint_list = []
+ for handler in handlers:
+ subarea = handler.subarea
+ if apiversions.get(subarea, False):
+ for hapiversion in handler.api_versions:
+ if hapiversion not in apiversions[subarea]:
+ apiversions[subarea].append(hapiversion)
+ else:
+ apiversions[subarea] = handler.api_versions
+ self.logger.debug("Registering /%s/apis for %s", subarea, subarea)
+ endpoint_list.append("/%s/apis" % subarea)
+ setattr(VersionHandler, "versions", apiversions)
+ setattr(VersionHandler, "method_decorators", [])
+ self.api.add_resource(VersionHandler, *(endpoint_list))
Code Review / ta / yarf.git / blobdiff