from sfa.util.sfalogging import logger
from sfa.util.config import Config
-import traceback
+
+from sfa.managers.managerwrapper import ManagerWrapper
# a bundle is the combination of
# (*) an api that reacts on the incoming requests to trigger the API methods
class Generic:
- def __init__ (self, config):
+ def __init__ (self, flavour, config):
+ self.flavour=flavour
self.config=config
# proof of concept
logger.info("Generic.the_flavour with flavour=%s"%flavour)
try:
module = __import__ (module_path, globals(), locals(), [classname])
- return getattr(module, classname)(config)
+ return getattr(module, classname)(flavour,config)
except:
logger.log_exc("Cannot locate generic instance with flavour=%s"%flavour)
+ # in the simplest case these can be redefined to the class/module objects to be used
+ # see pl.py for an example
+ # some descendant of SfaApi
+ def api_class (self) : pass
+ # in practical terms these are modules for now
+ def registry_class (self) : pass
+ def slicemgr_class (self) : pass
+ def aggregate_class (self) : pass
+ def component_class (self) : pass
+
- # how to build an API object
- # default is to use api_class but can be redefined
- def make_api (self, *args, **kwds):
- return self.api_class()(*args, **kwds)
+ # build an API object
+ # insert a manager instance
+ def make_api (self, *args, **kwargs):
+ # interface is a required arg
+ if not 'interface' in kwargs:
+ logger.critical("Generic.make_api: no interface found")
+ api = self.api_class()(*args, **kwargs)
+ manager = self.make_manager(api.interface)
+ driver = self.make_driver (api.config, api.interface)
+ ### arrange stuff together
+ # add a manager wrapper
+ manager = ManagerWrapper(manager,api.interface)
+ api.manager=manager
+ # insert driver in manager
+ manager.driver=driver
+ # add it in api as well for convenience
+ api.driver=driver
+ return api
+
+ def make_manager (self, interface):
+ """
+ interface expected in ['registry', 'aggregate', 'slice', 'component']
+ flavour is e.g. 'pl' or 'max' or whatever
+ """
+ flavour = self.flavour
+ message="Generic.make_manager for interface=%s and flavour=%s"%(interface,flavour)
+
+ classname = "%s_manager_class"%interface
+ try:
+ module = getattr(self,classname)()
+ logger.debug("%s : %s"%(message,module))
+ return module
+ except:
+ logger.log_exc_critical(message)
+
+ # need interface to select the right driver
+ def make_driver (self, config, interface):
+ flavour = self.flavour
+ message="Generic.make_driver for flavour=%s and interface=%s"%(flavour,interface)
+
+ if interface == "component":
+ classname = "component_driver_class"
+ else:
+ classname = "driver_class"
+ try:
+ class_obj = getattr(self,classname)()
+ logger.debug("%s : %s"%(message,class_obj))
+ return class_obj(config)
+ except:
+ logger.log_exc_critical(message)
+
+