X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Fgeneric%2F__init__.py;h=fd70c3c8ff98fb0e0a63450a3d68ff6ae5bb7826;hb=052e281f8c79237b6759cbb259407f071adda1cc;hp=ece7e2b857317051f3aa769b82812a7e37eb0390;hpb=7e1d7d63b6e65af7451c533fda704b14e327e48f;p=sfa.git diff --git a/sfa/generic/__init__.py b/sfa/generic/__init__.py index ece7e2b8..fd70c3c8 100644 --- a/sfa/generic/__init__.py +++ b/sfa/generic/__init__.py @@ -3,113 +3,118 @@ from sfa.util.config import Config from sfa.managers.managerwrapper import ManagerWrapper -# a bundle is the combination of +# a bundle is the combination of # (*) an api that reacts on the incoming requests to trigger the API methods -# (*) a manager that implements the function of the service, -# either aggregate, registry, or slicemgr +# (*) a manager that implements the function of the service, +# either aggregate or registry # (*) a driver that controls the underlying testbed -# -# -# The Generic class is a utility that uses the configuration to figure out -# which combination of these pieces need to be put together +# +# +# The Generic class is a utility that uses the configuration to figure out +# which combination of these pieces need to be put together # from config. # this extra indirection is needed to adapt to the current naming scheme -# where we have 'pl' and 'plc' and components and the like, that does not +# where we have 'pl' and 'plc' and components and the like, that does not # yet follow a sensible scheme # needs refinements to cache more efficiently, esp. wrt the config + class Generic: - def __init__ (self, flavour, config): - self.flavour=flavour - self.config=config + def __init__(self, flavour, config): + self.flavour = flavour + self.config = config # proof of concept # example flavour='pl' -> sfa.generic.pl.pl() @staticmethod - def the_flavour (flavour=None, config=None): - if config is None: config=Config() - if flavour is None: flavour=config.SFA_GENERIC_FLAVOUR + def the_flavour(flavour=None, config=None): + if config is None: + config = Config() + if flavour is None: + flavour = config.SFA_GENERIC_FLAVOUR flavour = flavour.lower() - #mixed = flavour.capitalize() - module_path="sfa.generic.%s"%flavour - classname="%s"%flavour - logger.debug("Generic.the_flavour with flavour=%s"%flavour) + # mixed = flavour.capitalize() + module_path = "sfa.generic.%s" % flavour + classname = "%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) + 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) + logger.log_exc( + "Cannot locate generic instance with flavour=%s" % flavour) # provide default for importer_class - def importer_class (self): + 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 + def api_class(self): pass # 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 component_class (self) : pass + def registry_class(self): pass + + def aggregate_class(self): pass # build an API object - # insert a manager instance - def make_api (self, *args, **kwargs): + # 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) - # xxx can probably drop support for managers implemented as modules + # 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 + 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 + 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 + api.driver = driver return api - def make_manager (self, interface): + def make_manager(self, interface): """ - interface expected in ['registry', 'aggregate', 'slicemgr', 'component'] + interface expected in ['registry', 'aggregate'] 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 + message = "Generic.make_manager for interface=%s and flavour=%s" % ( + interface, flavour) + + classname = "%s_manager_class" % interface try: - 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 + 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_critical(message) - + except Exception: + logger.log_exc(message) + exit(1) + # need interface to select the right driver - def make_driver (self, api): - config=api.config - interface=api.interface + 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) - - if interface == "component": - classname = "component_driver_class" - else: - classname = "driver_class" + message = "Generic.make_driver for flavour=%s and interface=%s" % ( + flavour, interface) + + classname = "driver_class" try: - class_obj = getattr(self,classname)() - logger.debug("%s : %s"%(message,class_obj)) + class_obj = getattr(self, classname)() + logger.debug("%s : %s" % (message, class_obj)) return class_obj(api) - except: - logger.log_exc_critical(message) - + except Exception: + logger.log_exc(message) + exit(1)