added some helper functions

[sfa.git] / geni / slicemgr.py

diff --git a/geni/slicemgr.py b/geni/slicemgr.py
index ad35493..605daf9 100644 (file)
--- a/geni/slicemgr.py
+++ b/geni/slicemgr.py
@@ -10,10 +10,10 @@ from geni.util.credential import Credential
 from geni.util.trustedroot import *
 from geni.util.excep import *
 from geni.util.misc import *
 from geni.util.trustedroot import *
 from geni.util.excep import *
 from geni.util.misc import *

-from geni.util.config import Config
+from geni.util.config import *

 from geni.util.rspec import Rspec
 from geni.util.specdict import *
 from geni.util.rspec import Rspec
 from geni.util.specdict import *

-from geni.util.storage import SimpleStorage
+from geni.util.storage import SimpleStorage, XmlStorage

 
 class SliceMgr(GeniServer):
 
 
 class SliceMgr(GeniServer):
 


@@ -40,39 +40,42 @@ class SliceMgr(GeniServer):
     # @param cert_file certificate filename containing public key (could be a GID file)     
 
     def __init__(self, ip, port, key_file, cert_file, config = "/usr/share/geniwrapper/geni/util/geni_config"):
     # @param cert_file certificate filename containing public key (could be a GID file)     
 
     def __init__(self, ip, port, key_file, cert_file, config = "/usr/share/geniwrapper/geni/util/geni_config"):

-        GeniServer.__init__(ip, port, key_file, cert_file)
+        GeniServer.__init__(self, ip, port, key_file, cert_file)

         self.key_file = key_file
         self.cert_file = cert_file
         self.key_file = key_file
         self.cert_file = cert_file

-        self.conf = Config(config)
-        basedir = self.conf.GENI_BASE_DIR + os.sep
-        server_basedir = basedir + os.sep + "geni" + os.sep
-        self.hrn = conf.GENI_INTERFACE_HRN    
-
+        self.config = Config(config)
+        self.basedir = self.config.GENI_BASE_DIR + os.sep
+        self.server_basedir = self.basedir + os.sep + "geni" + os.sep
+        self.hrn = self.config.GENI_INTERFACE_HRN    
+        self.time_format = "%Y-%m-%d %H:%M:%S"
+        

         # Get list of aggregates this sm talks to
         # Get list of aggregates this sm talks to

-        # XX do we use simplestorage to maintain this file manually?
-        aggregates_file = server_basedir + os.sep + 'aggregates'
-        self.aggregates = SimpleStorage(aggregates_file)
-        self.connect_aggregates(aggregates_file) 
+        aggregates_file = self.server_basedir + os.sep + 'aggregates.xml'
+        connection_dict = {'hrn': '', 'addr': '', 'port': ''}
+        self.aggregate_info = XmlStorage(aggregates_file, {'aggregates': {'aggregate': [connection_dict]}} )
+        self.aggregate_info.load()

         
         

-        nodes_file = os.sep.join([server_basedir, 'smgr.' + self.hrn + '.components'])
+        # Get cached list of nodes (rspec) 
+        nodes_file = os.sep.join([self.server_basedir, 'smgr.' + self.hrn + '.components'])

         self.nodes = SimpleStorage(nodes_file)
         self.nodes.load()
         
         self.nodes = SimpleStorage(nodes_file)
         self.nodes.load()
         

-        slices_file = os.sep.join([server_basedir, 'slicemgr' + self.hrn + '.slices'])
+        # Get cacheds slice states
+        slices_file = os.sep.join([self.server_basedir, 'smgr.' + self.hrn + '.slices'])

         self.slices = SimpleStorage(slices_file)
         self.slices.load()
 
         self.slices = SimpleStorage(slices_file)
         self.slices.load()
 

-        policy_file = os.sep.join([server_basedir, 'smgr.policy'])
-        self.policy = SimpleStorage(policy_file)
+        # Get the policy
+        policy_file = os.sep.join([self.server_basedir, 'smgr.' + self.hrn + '.policy'])
+        self.policy = SimpleStorage(policy_file, {'whitelist': [], 'blacklist': []})

         self.policy.load()
 
         self.policy.load()
 

-        timestamp_file = os.sep.join([server_basedir, 'smgr.' + self.hrn + '.timestamp'])
-        self.timestamp = SimpleStorage(timestamp_file)
- 
+        # How long before we refresh nodes cache  

         self.nodes_ttl = 1
         self.nodes_ttl = 1

-        self.connectAggregates()
+

         self.connectRegistry()
         self.loadCredential()
         self.connectRegistry()
         self.loadCredential()

+        self.connectAggregates()

 
 
     def loadCredential(self):
 
 
     def loadCredential(self):


@@ -80,53 +83,57 @@ class SliceMgr(GeniServer):
         Attempt to load credential from file if it exists. If it doesnt get
         credential from registry.
         """
         Attempt to load credential from file if it exists. If it doesnt get
         credential from registry.
         """

-
-        self_cred_filename = self.server_basedir + os.sep + "smgr." + self.hrn + ".cred"
-        ma_cred_filename = self.server_basedir + os.sep + "smgr." + self.hrn + ".sa.cred"
-
+        

         # see if this file exists
         # see if this file exists

+        ma_cred_filename = self.server_basedir + os.sep + "smgr." + self.hrn + ".sa.cred"

         try:
         try:

-            cred = Credential(filename = ma_cred_filename)
-            self.credential = cred.save_to_string()
+            self.credential = Credential(filename = ma_cred_filename)

         except IOError:
         except IOError:

-            # get self credential
-            self_cred = self.registry.get_credential(None, 'ma', self.hrn)
-            self_credential = Credential(string = self_cred)
-            self_credential.save_to_file(self_cred_filename)
-
-            # get ma credential
-            ma_cred = self.registry.get_gredential(self_cred)
-            ma_credential = Credential(string = ma_cred)
-            ma_credential.save_to_file(ma_cred_filename)
-            self.credential = ma_cred        
-
-    def connect_aggregates(self, aggregates_file):
+            self.credential = self.getCredentialFromRegistry()
+            
+        
+    def getCredentialFromRegistry(self):

         """
         """

-        Get info about the aggregates available to us from file and create 
-        an xmlrpc connection to each. If any info is invalid, skip it. 
+        Get our current credential from the registry.

         """
         """

-        lines = []
-        try:
-            f = open(aggregates_file, 'r')
-            lines = f.readlines()
-            f.close()
-        except: raise 
-    
-        for line in lines:
-            # Skip comments
-            if line.strip.startswith("#"):
-                continue
-            agg_info = line.split("\t").split(" ")
-        
-            # skip invalid info
-            if len(agg_info) != 3:
-                continue
-
-            # create xmlrpc connection using GeniClient
-            hrn, address, port = agg_info[0], agg_info[1], agg_info[2]
-            url = 'https://%(address)s:%(port)s' % locals()
-            self.aggregates[hrn] = GeniClient(url, self.key_file, self.cert_file)
+        # get self credential
+        self_cred_filename = self.server_basedir + os.sep + "smgr." + self.hrn + ".cred"
+        self_cred = self.registry.get_credential(None, 'ma', self.hrn)
+        self_cred.save_to_file(self_cred_filename, save_parents=True)

 
 

+        # get ma credential
+        ma_cred_filename = self.server_basedir + os.sep + "smgr." + self.hrn + ".sa.cred"
+        ma_cred = self.registry.get_credential(self_cred, 'sa', self.hrn)
+        ma_cred.save_to_file(ma_cred_filename, save_parents=True)
+        return ma_cred        
+
+    def connectRegistry(self):
+        """
+        Connect to the registry
+        """
+        # connect to registry using GeniClient
+        address = self.config.GENI_REGISTRY_HOSTNAME
+        port = self.config.GENI_REGISTRY_PORT
+        url = 'http://%(address)s:%(port)s' % locals()
+        self.registry = GeniClient(url, self.key_file, self.cert_file)
+
+    def connectAggregates(self):
+        """
+        Get connection details for the trusted peer aggregates from file and 
+        create a GeniClient connection to each.      
+        """
+        self.aggregates = {} 
+        aggregates = self.aggregate_info['aggregates']['aggregate']
+        if isinstance(aggregates, dict):
+            aggregates = [aggregates]
+        if isinstance(aggregates, list):
+            for aggregate in aggregates:         
+                # create xmlrpc connection using GeniClient
+                hrn, address, port = aggregate['hrn'], aggregate['addr'], aggregate['port']
+                if not hrn or not address or not port:
+                    continue
+                url = 'http://%(address)s:%(port)s' % locals()
+                self.aggregates[hrn] = GeniClient(url, self.key_file, self.cert_file)

 
     def item_hrns(self, items):
         """
 
     def item_hrns(self, items):
         """


@@ -164,51 +171,62 @@ class SliceMgr(GeniServer):
         """
         Update the cached list of nodes.
         """
         """
         Update the cached list of nodes.
         """

-        print "refreshing"

     
     

+        # convert and threshold to ints
+        if self.nodes.has_key('timestamp') and self.nodes['timestamp']:
+            hr_timestamp = self.nodes['timestamp']
+            timestamp = datetime.datetime.fromtimestamp(time.mktime(time.strptime(hr_timestamp, self.time_format)))
+            hr_threshold = self.nodes['threshold']
+            threshold = datetime.datetime.fromtimestamp(time.mktime(time.strptime(hr_threshold, self.time_format)))
+        else:
+            timestamp = datetime.datetime.now()
+            hr_timestamp = timestamp.strftime(self.time_format)
+            delta = datetime.timedelta(hours=self.nodes_ttl)
+            threshold = timestamp + delta
+            hr_threshold = threshold.strftime(self.time_format)
+
+        start_time = int(timestamp.strftime("%s"))
+        end_time = int(threshold.strftime("%s"))
+        duration = end_time - start_time
+

         aggregates = self.aggregates.keys()
         aggregates = self.aggregates.keys()

-        all_nodes = []
-        nodedict = {}
+        rspecs = {}
+        networks = []
+        rspec = Rspec()

         for aggregate in aggregates:
             try:
         for aggregate in aggregates:
             try:

-                # resolve components hostnames
-                nodes = self.aggregates[aggregate].get_components()
-                all_nodes.extend(nodes)    
+                # get the rspec from the aggregate
+                agg_rspec = self.aggregates[aggregate].list_nodes(self.credential)
+                # extract the netspec from each aggregates rspec
+                rspec.parseString(agg_rspec)
+                networks.extend([{'NetSpec': rspec.getDictsByTagName('NetSpec')}])

             except:
                 # XX print out to some error log
             except:
                 # XX print out to some error log

-                pass    
-   
-        for node in all_nodes:
-            if self.polciy['whitelist'] and node not in self.polciy['whitelist']:
-                continue
-            if self.polciy['blacklist'] and node in self.policy['blacklist']:
-                continue
-
-            nodedict[node] = node
-
-        self.nodes = SimpleStorate(self.nodes.db_filename, nodedict)
-        self.nodes.write()
+                print "Error calling list nodes at aggregate %s" % aggregate
+                raise    
+  
+        # create the rspec dict
+        resources = {'networks': networks, 'start_time': start_time, 'duration': duration}
+        resourceDict = {'Rspec': resources} 
+        # convert rspec dict to xml
+        rspec.parseDict(resourceDict)
+       
+        # filter according to policy
+        rspec.filter('NodeSpec', 'name', blacklist=self.policy['blacklist'], whitelist=self.policy['whitelist'])

 
         # update timestamp and threshold
 
         # update timestamp and threshold

-        self.timestamp['timestamp'] = datetime.datetime.now()
-        delta = datetime.timedelta(hours=self.nodes_tt1)
-        self.threshold = self.timestamp['timestamp'] + delta
-        self.timestamp.write()
-        
- 
-    def load_components(self):
-        """
-        Read cached list of nodes and slices.
-        """
-        print "loading nodes"
-        # Read component list from cached file 
-        self.nodes.load()
-        self.timestamp.load()
-        time_format = "%Y-%m-%d %H:%M:%S"
-        timestamp = self.timestamp['timestamp']
-        self.timestamp['timestamp'] = datetime.datetime.fromtimestamp(time.mktime(time.strptime(timestamp, time_format)))
+        timestamp = datetime.datetime.now()
+        hr_timestamp = timestamp.strftime(self.time_format)

         delta = datetime.timedelta(hours=self.nodes_ttl)
         delta = datetime.timedelta(hours=self.nodes_ttl)

-        self.threshold = self.timestamp['timestamp'] + delta
+        threshold = timestamp + delta
+        hr_threshold = threshold.strftime(self.time_format)
+        
+        nodedict = {'rspec': rspec.toxml(),
+                    'timestamp': hr_timestamp,
+                    'threshold':  hr_threshold}
+
+        self.nodes = SimpleStorage(self.nodes.db_filename, nodedict)
+        self.nodes.write()

 
     def load_policy(self):
         """
 
     def load_policy(self):
         """


@@ -220,120 +238,119 @@ class SliceMgr(GeniServer):
         """
         Read current slice instantiation states.
         """
         """
         Read current slice instantiation states.
         """

-        print "loading slices"

         self.slices.load()
 
 
         self.slices.load()
 
 

-    def get_components(self):
+    def getNodes(self, format = 'rspec'):

         """
         Return a list of components managed by this slice manager.
         """
         # Reload components list
         """
         Return a list of components managed by this slice manager.
         """
         # Reload components list

-        now = datetime.datetime.now()
-        #self.load_components()
-        if not self.threshold or not self.timestamp or now > self.threshold:
+        if not self.nodes.has_key('threshold') or not self.nodes['threshold'] or not self.nodes.has_key('timestamp') or not self.nodes['timestamp']:

             self.refresh_components()
             self.refresh_components()

-        elif now < self.threshold and not self.components: 
-            self.load_components()
-        return self.nodes.keys()
+        else:
+            now = datetime.datetime.now()
+            threshold = datetime.datetime.fromtimestamp(time.mktime(time.strptime(self.nodes['threshold'], self.time_format)))
+            if  now > threshold:
+                self.refresh_components()
+        return self.nodes[format]

    
      
    
      

-    def get_slices(self):
+    def getSlices(self):

         """
         Return a list of instnatiated managed by this slice manager.
         """
         """
         Return a list of instnatiated managed by this slice manager.
         """

-        return dict(self.slices)
+        slice_hrns = []
+        for aggregate in self.aggregates:
+            try:
+                slices = self.aggregates[aggregate].list_slices(self.credential)
+                slice_hrns.extend(slices)
+            except:
+                raise
+                # print to some error log
+                pass
+
+        return slice_hrns

 
 

-    def get_resources(self, slice_hrn):
+    def getResources(self, slice_hrn):

         """
         Return the current rspec for the specified slice.
         """
         """
         Return the current rspec for the specified slice.
         """

-        cred = self.credential

 
 

-        if slice_hrn in self.slices.keys():
-            # check if we alreay have this slices state saved
-            rspec = self.slices[slice_hrn]
-        else:
-            # request this slices state from all  known aggregates
-            rspecdicts = []
-            for hrn in self.aggregates.keys():
-                # XX need to use the right credentials for this call
-                # check if the slice has resources at this hrn
-                tempresources = self.aggregates[hrn].resources(cred, slice_hrn)
-                temprspec = Rspec()
-                temprspec.parseString(temprspec)
-                if temprspec.getDictsByTagName('NodeSpec'):
-                    # append this rspec to the list of rspecs
-                    rspecdicts.append(temprspec.toDict())
-                
-            # merge all these rspecs into one
-            start_time = int(self.timestamp['timestamp'].strftime("%s"))
-            end_time = int(self.duration.strftime("%s"))
-            duration = end_time - start_time
-                
-            # create a plc dict 
-            networks = [rspecdict['networks'][0] for rspecdict in rspecdicts]
-            resources = {'networks': networks, 'start_time': start_time, 'duration': duration}
-            # convert the plc dict to an rspec dict
-            resourceDict = RspecDict(resources)
-            resourceSpec = Rspec()
-            resourceSpec.parseDict(resourceDict)
-            rspec = resourceSpec.toxml() 
-            # save this slices resources
-            self.slices[slice_hrn] = rspec
-            self.slices.write()
+        # request this slices state from all known aggregates
+        rspec = Rspec()
+        rspecdicts = []
+        networks = []
+        for hrn in self.aggregates.keys():
+            # check if the slice has resources at this hrn
+            slice_resources = self.aggregates[hrn].get_resources(self.credential, slice_hrn)
+            rspec.parseString(slice_resources)
+            networks.extend([{'NetSpec': rspec.getDictsByTagName('NetSpec')}])
+            
+        # merge all these rspecs into one
+        start_time = int(datetime.datetime.now().strftime("%s"))
+        end_time = start_time
+        duration = end_time - start_time
+    
+        resources = {'networks': networks, 'start_time': start_time, 'duration': duration}
+        resourceDict = {'Rspec': resources}
+        # convert rspec dict to xml
+        rspec.parseDict(resourceDict)
+        # save this slices resources
+        #self.slices[slice_hrn] = rspec.toxml()
+        #self.slices.write()

          
          

-        return rspec
+        return rspec.toxml()

  
  

-    def create_slice(self, slice_hrn, rspec, attributes):
+    def createSlice(self, cred, slice_hrn, rspec):

         """
         Instantiate the specified slice according to whats defined in the rspec.
         """
         """
         Instantiate the specified slice according to whats defined in the rspec.
         """

-        # XX need to gget the correct credentials
-        cred = self.credential

 
         # save slice state locally
         # we can assume that spec object has been validated so its safer to
         # save this instead of the unvalidated rspec the user gave us
 
         # save slice state locally
         # we can assume that spec object has been validated so its safer to
         # save this instead of the unvalidated rspec the user gave us

+        spec = Rspec()
+        tempspec = Rspec()
+        spec.parseString(rspec)
+

         self.slices[slice_hrn] = spec.toxml()
         self.slices.write()
 
         # extract network list from the rspec and create a separate
         # rspec for each network
         self.slices[slice_hrn] = spec.toxml()
         self.slices.write()
 
         # extract network list from the rspec and create a separate
         # rspec for each network

-        slicename = self.hrn_to_plcslicename(slice_hrn)
-        spec = Rspec()
-        spec.parseString(rspec)
+        slicename = hrn_to_pl_slicename(slice_hrn)

         specDict = spec.toDict()
         specDict = spec.toDict()

-        start_time = specDict['start_time']
-        end_time = specDict['end_time']
-
+        if specDict.has_key('Rspec'): specDict = specDict['Rspec']
+        if specDict.has_key('start_time'): start_time = specDict['start_time']
+        else: start_time = 0
+        if specDict.has_key('end_time'): end_time = specDict['end_time']
+        else: end_time = 0
+   

         rspecs = {}
         # only attempt to extract information about the aggregates we know about
         for hrn in self.aggregates.keys():
         rspecs = {}
         # only attempt to extract information about the aggregates we know about
         for hrn in self.aggregates.keys():

-            netspec = spec.getDictByTagNameValue('NetSpec', 'hrn')
+            netspec = spec.getDictByTagNameValue('NetSpec', hrn)

             if netspec:
                 # creat a plc dict 
             if netspec:
                 # creat a plc dict 

-                tempdict = {'start_time': star_time, 'end_time': end_time, 'networks': netspec}
-                #convert the plc dict to rpsec dict
-                resourceDict = RspecDict(tempdict)
-                # parse rspec dict
-                tempspec = Rspec()
+                resources = {'start_time': start_time, 'end_time': end_time, 'networks': netspec}
+                resourceDict = {'Rspec': resources}

                 tempspec.parseDict(resourceDict)
                 rspecs[hrn] = tempspec.toxml()
 
         # notify the aggregates
                 tempspec.parseDict(resourceDict)
                 rspecs[hrn] = tempspec.toxml()
 
         # notify the aggregates

-        for hrn in self.rspecs.keys():
-            self.aggregates[hrn].createSlice(cred, rspecs[hrn])
+        for hrn in rspecs.keys():
+            self.aggregates[hrn].create_slice(self.credential, slice_hrn, rspecs[hrn])

             
         return 1
 
             
         return 1
 

-    def update_slice(self, slice_hrn, rspec, attributes = []):
+    def updateSlice(self, slice_hrn, rspec, attributes = []):

         """
         Update the specifed slice
         """
         self.create_slice(slice_hrn, rspec, attributes)
     
         """
         Update the specifed slice
         """
         self.create_slice(slice_hrn, rspec, attributes)
     

-    def delete_slice_(self, slice_hrn):
+    def deleteSlice_(self, slice_hrn):

         """
         Remove this slice from all components it was previouly associated with and 
         free up the resources it was using.
         """
         Remove this slice from all components it was previouly associated with and 
         free up the resources it was using.


@@ -350,7 +367,7 @@ class SliceMgr(GeniServer):
 
         return 1
 
 
         return 1
 

-    def start_slice(self, slice_hrn):
+    def startSlice(self, slice_hrn):

         """
         Stop the slice at plc.
         """
         """
         Stop the slice at plc.
         """


@@ -360,7 +377,7 @@ class SliceMgr(GeniServer):
             self.aggregates[hrn].startSlice(cred, slice_hrn)
         return 1
 
             self.aggregates[hrn].startSlice(cred, slice_hrn)
         return 1
 

-    def stop_slice(self, slice_hrn):
+    def stopSlice(self, slice_hrn):

         """
         Stop the slice at plc
         """
         """
         Stop the slice at plc
         """


@@ -369,14 +386,14 @@ class SliceMgr(GeniServer):
             self.aggregates[hrn].startSlice(cred, slice_hrn)
         return 1
 
             self.aggregates[hrn].startSlice(cred, slice_hrn)
         return 1
 

-    def reset_slice(self, slice_hrn):
+    def resetSlice(self, slice_hrn):

         """
         Reset the slice
         """
         # XX not yet implemented
         return 1
 
         """
         Reset the slice
         """
         # XX not yet implemented
         return 1
 

-    def get_policy(self):
+    def getPolicy(self):

         """
         Return the policy of this slice manager.
         """
         """
         Return the policy of this slice manager.
         """


@@ -389,55 +406,60 @@ class SliceMgr(GeniServer):
 ## Server methods here for now
 ##############################
 
 ## Server methods here for now
 ##############################
 

-    def nodes(self):
-        return self.get_components()
+    def list_nodes(self, cred):
+        self.decode_authentication(cred, 'listnodes')
+        return self.getNodes()

 
 

-    def slices(self):
-        return self.get_slices()
+    def list_slices(self, cred):
+        self.decode_authentication(cred, 'listslices')
+        return self.getSlices()

 
 

-    def resources(self, cred, hrn):
-        self.decode_authentication(cred, 'info')
-        self.verify_object_belongs_to_me(hrn)
+    def get_resources(self, cred, hrn=None):
+        self.decode_authentication(cred, 'listnodes')
+        if not hrn: 
+            return self.getNodes()
+        else:
+            return self.getResources(hrn)

 
 

-        return self.get_resources(hrn)
+    def get_ticket(self, cred, hrn, rspec):
+        self.decode_authentication(cred, 'getticket')
+        return self.getTicket(hrn, rspec)

 
 

-    def create(self, cred, hrn, rspec):
-        self.decode_authentication(cred, 'embed')
-        self.verify_object_belongs_to_me(hrn)
-        return self.create(hrn)
+    def get_policy(self, cred):
+        self.decode_authentication(cred, 'getpolicy')
+        return self.getPolicy()

 
 

-    def delete(self, cred, hrn):
-        self.decode_authentication(cred, 'embed')
-        self.verify_object_belongs_to_me(hrn)
-        return self.delete_slice(hrn)
+    def create_slice(self, cred, hrn, rspec):
+        self.decode_authentication(cred, 'createslice')
+        return self.createSlice(cred, hrn, rspec)

 
 

-    def start(self, cred, hrn):
-        self.decode_authentication(cred, 'control')
-        return self.start(hrn)
+    def delete_slice(self, cred, hrn):
+        self.decode_authentication(cred, 'deleteslice')
+        return self.deleteSlice(hrn)

 
 

-    def stop(self, cred, hrn):
-        self.decode_authentication(cred, 'control')
-        return self.stop(hrn)
+    def start_slice(self, cred, hrn):
+        self.decode_authentication(cred, 'startslice')
+        return self.startSlice(hrn)

 
 

-    def reset(self, cred, hrn):
-        self.decode_authentication(cred, 'control')
-        return self.reset(hrn)
+    def stop_slice(self, cred, hrn):
+        self.decode_authentication(cred, 'stopslice')
+        return self.stopSlice(hrn)

 
 

-    def policy(self, cred):
-        self.decode_authentication(cred, 'info')
-        return self.get_policy()
+    def reset_slice(self, cred, hrn):
+        self.decode_authentication(cred, 'resetslice')
+        return self.resetSlice(hrn)

 
     def register_functions(self):
         GeniServer.register_functions(self)
 
         # Aggregate interface methods
 
     def register_functions(self):
         GeniServer.register_functions(self)
 
         # Aggregate interface methods

-        self.server.register_function(self.components)
-        self.server.register_function(self.slices)
-        self.server.register_function(self.resources)
-        self.server.register_function(self.create)
-        self.server.register_function(self.delete)
-        self.server.register_function(self.start)
-        self.server.register_function(self.stop)
-        self.server.register_function(self.reset)
-        self.server.register_function(self.policy)
+        self.server.register_function(self.list_nodes)
+        self.server.register_function(self.list_slices)
+        self.server.register_function(self.get_resources)
+        self.server.register_function(self.get_policy)
+        self.server.register_function(self.create_slice)
+        self.server.register_function(self.delete_slice)
+        self.server.register_function(self.start_slice)
+        self.server.register_function(self.stop_slice)
+        self.server.register_function(self.reset_slice)