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)
+ driver = self.make_driver (api.config, api.interface)
### arrange stuff together
# add a manager wrapper
manager = ManagerWrapper(manager,api.interface)
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))
except:
logger.log_exc_critical(message)
- def make_driver (self, config):
+ # need interface to select the right driver
+ def make_driver (self, config, interface):
flavour = self.flavour
- message="Generic.make_driver for flavour=%s"%(flavour)
+ message="Generic.make_driver for flavour=%s and interface=%s"%(flavour,interface)
- classname = "driver_class"
+ if interface == "component":
+ classname = "component_driver_class"
+ else:
+ classname = "driver_class"
try:
class_obj = getattr(self,classname)()
logger.info("%s : %s"%(message,class_obj))
class pl (Generic):
+ # use the standard api class
def api_class (self):
return sfa.server.sfaapi.SfaApi
- def registry_class (self) :
+ # the manager classes for the server-side services
+ def registry_manager_class (self) :
return sfa.managers.registry_manager
- def slicemgr_class (self) :
+ def slicemgr_manager_class (self) :
return sfa.managers.slice_manager
- def aggregate_class (self) :
+ def aggregate_manager_class (self) :
return sfa.managers.aggregate_manager
+ # driver class for server-side services, talk to the whole testbed
def driver_class (self):
return sfa.plc.pldriver.PlDriver
+ # for the component mode, to be run on board planetlab nodes
+ # manager class
+ def component_manager_class (self):
+ return sfa.managers.component_manager_pl
+ # driver_class
+ def component_driver_class (self):
+ return sfa.plc.plcomponentdriver.PlComponentDriver
+
+
+++ /dev/null
-from sfa.generic.pl import pl
-
-import sfa.server.sfaapi
-import sfa.plc.plccomponentapi
-import sfa.managers.component_manager_pl
-
-class plcm (pl):
-
- def component_class (self):
- return sfa.managers.component_manager_pl
-
- def driver_class (self):
- return 'xxx todo : transform plccomponentapi into plcnodedriver'
def start_slice(api, xrn, creds):
slicename = PlXrn(xrn, type='slice').pl_slicename()
- api.nodemanager.Start(slicename)
+ api.driver.nodemanager.Start(slicename)
def stop_slice(api, xrn, creds):
slicename = PlXrn(xrn, type='slice').pl_slicename()
- api.nodemanager.Stop(slicename)
+ api.driver.nodemanager.Stop(slicename)
def DeleteSliver(api, xrn, creds, call_id):
slicename = PlXrn(xrn, type='slice').pl_slicename()
- api.nodemanager.Destroy(slicename)
+ api.driver.nodemanager.Destroy(slicename)
def reset_slice(api, xrn):
slicename = PlXrn(xrn, type='slice').pl_slicename()
if not api.sliver_exists(slicename):
raise SliverDoesNotExist(slicename)
- api.nodemanager.ReCreate(slicename)
+ api.driver.nodemanager.ReCreate(slicename)
# xxx outdated - this should accept a credential & call_id
def ListSlices(api):
# this returns a tuple, the data we want is at index 1
- xids = api.nodemanager.GetXIDs()
+ xids = api.driver.nodemanager.GetXIDs()
# unfortunately the data we want is given to us as
# a string but we really want it as a dict
# lets eval it
# convert ticket to format nm is used to
nm_ticket = xmlrpclib.dumps((ticket.attributes,), methodresponse=True)
- api.nodemanager.AdminTicket(nm_ticket)
+ api.driver.nodemanager.AdminTicket(nm_ticket)
import tempfile
import sfa.util.xmlrpcprotocol as xmlrpcprotocol
-from sfa.util.nodemanager import NodeManager
+from sfa.plc.nodemanager import NodeManager
from sfa.trust.credential import Credential
from sfa.trust.certificate import Certificate, Keypair
from sfa.trust.gid import GID
####################
-class PlcComponentDriver:
+class PlComponentDriver:
"""
This class is the type for the toplevel 'api' object
when running the component manager inside a planetlab node.
##
# Component is a SfaServer that serves component operations.
-# set SFA_GENERIC_FLAVOUR=plcm to get a PlcComponentApi instance in the request handler
class Component(SfaServer):
##
# Create a new registry object.
# @param cert_file certificate filename containing public key (could be a GID file)
def __init__(self, ip, port, key_file, cert_file):
- SfaServer.__init__(self, ip, port, key_file, cert_file)
- self.server.interface = 'component'
+ SfaServer.__init__(self, ip, port, key_file, cert_file, interface='component')
if verbose:
print "Getting current slices on this node"
# get a list of slices on this node
- from sfa.plc.plcdriver import PlcComponentApi
- api = PlcComponentApi()
+ # make sure you run with SFA_GENERIC_FLAVOUR=plcm
+ from sfa.generic import Generic
+ generic=Generic.the_flavour()
+ api = generic.make_api(interface='component')
xids_tuple = api.driver.nodemanager.GetXIDs()
slices = eval(xids_tuple[1])
slicenames = slices.keys()