#mixed = flavour.capitalize()
module_path="sfa.generic.%s"%flavour
classname="%s"%flavour
- logger.info("Generic.the_flavour with flavour=%s"%flavour)
+ logger.debug("Generic.the_flavour with flavour=%s"%flavour)
try:
module = __import__ (module_path, globals(), locals(), [classname])
return getattr(module, classname)(flavour,config)
except:
logger.log_exc("Cannot locate generic instance with flavour=%s"%flavour)
+ # provide default for importer_class
+ def importer_class (self):
+ return None
+
# 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
+ # the python classes to use to build up the context
def registry_class (self) : pass
def slicemgr_class (self) : pass
def aggregate_class (self) : pass
def make_api (self, *args, **kwargs):
# interface is a required arg
if not 'interface' in kwargs:
- logger.fatal("Generic.make_api: no interface found")
+ logger.critical("Generic.make_api: no interface found")
api = self.api_class()(*args, **kwargs)
- interface=kwargs['interface']
- # or simpler, interface=api.interface
- manager = self.make_manager(interface)
- api.manager = ManagerWrapper(manager,interface)
+ # xxx can probably drop support for managers implemented as modules
+ # which makes it a bit awkward
+ manager_class_or_module = self.make_manager(api.interface)
+ driver = self.make_driver (api)
+ ### arrange stuff together
+ # add a manager wrapper
+ manager_wrap = ManagerWrapper(manager_class_or_module,api.interface,api.config)
+ api.manager=manager_wrap
+ # add it in api as well; driver.api is set too as part of make_driver
+ api.driver=driver
return api
def make_manager (self, interface):
"""
- interface expected in ['registry', 'aggregate', 'slice', 'component']
+ interface expected in ['registry', 'aggregate', 'slicemgr', '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_class"%interface
+ classname = "%s_manager_class"%interface
try:
- module = getattr(self,classname)()
- logger.info("%s : %s"%(message,module))
- return module
+ module_or_class = getattr(self,classname)()
+ logger.debug("%s : %s"%(message,module_or_class))
+ # this gets passed to ManagerWrapper that will call the class constructor
+ # if it's a class, or use the module as is if it's a module
+ # so bottom line is, don't try the constructor here
+ return module_or_class
except:
- logger.log_exc(message)
- logger.fatal("Aborting")
+ logger.log_exc_critical(message)
+
+ # need interface to select the right driver
+ def make_driver (self, api):
+ config=api.config
+ interface=api.interface
+ flavour = self.flavour
+ message="Generic.make_driver for flavour=%s and interface=%s"%(flavour,interface)
-# former logic was
-# basepath = 'sfa.managers'
-# qualified = "%s.%s_manager_%s"%(basepath,interface,flavour)
-# generic = "%s.%s_manager"%(basepath,interface)
-#
-# try:
-# manager = __import__(qualified, fromlist=[basepath])
-# logger.info ("%s: loaded %s"%(message,qualified))
-# except:
-# try:
-# manager = __import__ (generic, fromlist=[basepath])
-# if flavour != 'pl' :
-# logger.warn ("%s: using generic with flavour!='pl'"%(message))
-# logger.info("%s: loaded %s"%(message,generic))
-# except:
-# logger.log_exc("%s: unable to import either %s or %s"%(message,qualified,generic))
-# logger.fatal("Aborted")
-# return manager
+ 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(api)
+ except:
+ logger.log_exc_critical(message)