Modifications to handle slice creation according to master modifications.

diff --git a/sfa/managers/aggregate_manager_slab.py b/sfa/managers/aggregate_manager_slab.py
index 91c0070..e45e509 100644 (file)
--- a/sfa/managers/aggregate_manager_slab.py
+++ b/sfa/managers/aggregate_manager_slab.py
@@ -16,14 +16,16 @@ from sfa.util.record import SfaRecord
 from sfa.util.policy import Policy
 from sfa.util.record import *
 from sfa.util.sfaticket import SfaTicket
-from sfa.plc.slices import Slices
+
+from sfa.senslab.slices import *
+
 from sfa.trust.credential import Credential
 import sfa.plc.peers as peers
 from sfa.plc.network import *
 from sfa.senslab.OARrestapi import *
 from sfa.senslab.api import SfaAPI
 #from sfa.plc.aggregate import Aggregate
-from sfa.plc.slices import *
+#from sfa.plc.slices import *
 from sfa.util.version import version_core
 from sfa.rspecs.version_manager import VersionManager
 from sfa.rspecs.rspec import RSpec
@@ -184,8 +186,11 @@ def CreateSliver(api, slice_xrn, creds, rspec_string, users, call_id):
     if Callids().already_handled(call_id): return ""
 
     #reg_objects = __get_registry_objects(slice_xrn, creds, users)
-    aggregate = Aggregate(api)
-    slices = Slices(api)
+    #aggregate = Aggregate(api)
+    aggregate = OARrspec(api)
+    print>>sys.stderr, " \r\n AGGREGATE CreateSliver DAFUQ IS THIS ?-----------------> aggregate " , aggregate
+    slices = Slices(api)    
+    print>>sys.stderr, " \r\n AGGREGATE CreateSliver DAFUQ IS THAT ?-----------------> Slices " , slices
     (hrn, type) = urn_to_hrn(slice_xrn)
     
     peer = slices.get_peer(hrn)

diff --git a/sfa/managers/slice_manager_slab.py b/sfa/managers/slice_manager_slab.py
index a0e1e5a..cdcf2b7 100644 (file)
--- a/sfa/managers/slice_manager_slab.py
+++ b/sfa/managers/slice_manager_slab.py
@@ -129,16 +129,15 @@ def drop_slicemgr_stats(api,rspec):
  
  
 def CreateSliver(api, xrn, creds, rspec_str, users, call_id):
+       
        version_manager = VersionManager()
-       def _CreateSliver(aggregate, xrn, credential, rspec, users, call_id):
-       # Need to call ParseVersion at an aggregate to determine the supported 
-       # rspec type/format beofre calling CreateSliver at an Aggregate. 
-       # The Aggregate's verion info is cached 
+       def _CreateSliver(aggregate, server, xrn, credential, rspec, users, call_id):
                
                tStart = time.time()
                try:
                        # Need to call GetVersion at an aggregate to determine the supported
                        # rspec type/format beofre calling CreateSliver at an Aggregate.
+                       print>>sys.stderr, " \r\n SLICE MANAGERSLAB _CreateSliver server " 
                        server_version = api.get_cached_server_version(server)
                        requested_users = users
                        if 'sfa' not in server_version and 'geni_api' in server_version:
@@ -178,23 +177,26 @@ def CreateSliver(api, xrn, creds, rspec_str, users, call_id):
        credential = api.getDelegatedCredential(creds)
        if not credential:
                credential = api.getCredential()
-       
+
        # get the callers hrn
        hrn, type = urn_to_hrn(xrn)
        valid_cred = api.auth.checkCredentials(creds, 'createsliver', hrn)[0]
        caller_hrn = Credential(string=valid_cred).get_gid_caller().get_hrn()
        threads = ThreadManager()
-       
+       print>>sys.stderr, " \r\n \r\n \t\t =======SLICE MANAGER _CreateSliver api aggregates  %s \t caller_hrn %s api.hrn %s" %(api.aggregates, caller_hrn, api.hrn)
        for aggregate in api.aggregates:
        # prevent infinite loop. Dont send request back to caller
        # unless the caller is the aggregate's SM 
                if caller_hrn == aggregate and aggregate != api.hrn:
                        continue
                interface = api.aggregates[aggregate]
-               server = api.get_server(interface, credential)   
+               print>>sys.stderr, " \r\n \r\n \t\t =======SLICE MANAGER _CreateSliver aggregate %s interface %s" %(api.aggregates[aggregate],interface)   
+               server = api.get_server(interface, credential)
+               if server is None:
+                       print>>sys.stderr, " \r\n \r\n \t\t =======SLICE MANAGER _CreateSliver NOSERVERS "  
                # Just send entire RSpec to each aggregate
-               threads.run(_CreateSliver, aggregate, xrn, [credential], rspec.toxml(), users, call_id)
-               
+               #threads.run(_CreateSliver, aggregate, xrn, [credential], rspec.toxml(), users, call_id)
+               threads.run(_CreateSliver, aggregate, server, xrn, [credential], rspec.toxml(), users, call_id)
        results = threads.get_results()
        manifest_version = version_manager._get_version(rspec.version.type, rspec.version.version, 'manifest')
        result_rspec = RSpec(version=manifest_version)

diff --git a/sfa/senslab/OARrestapi.py b/sfa/senslab/OARrestapi.py
index b0063f6..f7c9b95 100644 (file)
--- a/sfa/senslab/OARrestapi.py
+++ b/sfa/senslab/OARrestapi.py
@@ -120,7 +120,7 @@ class OARGETParser:
        
        def ParseVersion(self) : 
                print self.raw_json
-               print >>sys.stderr, self.raw_json
+               #print >>sys.stderr, self.raw_json
                if 'oar_version' in self.raw_json :
                        self.version_json_dict.update(api_version=self.raw_json['api_version'] ,
                                        apilib_version=self.raw_json['apilib_version'],
@@ -220,11 +220,11 @@ class OARGETParser:
                                                                        ('date_created', None), ('peer_id', None),]
                                self.site_dict[node['site_login_base']] = dict(self.site_dict[node['site_login_base']])
                                
-               print>>sys.stderr, "\r\n \r\n =============\t\t ParseSites site dict %s \r\n"%(self.site_dict)
+               #print>>sys.stderr, "\r\n \r\n =============\t\t ParseSites site dict %s \r\n"%(self.site_dict)
                
                
        def GetNodesFromOARParse(self):
-               print>>sys.stderr, " \r\n =========GetNodesFromOARParse: node_dictlist %s "%(self.node_dictlist)
+               #print>>sys.stderr, " \r\n =========GetNodesFromOARParse: node_dictlist %s "%(self.node_dictlist)
                return self.node_dictlist
 
        def GetSitesFromOARParse(self):
@@ -278,11 +278,11 @@ class OARapi:
                self.parser = OARGETParser(self.server)
 
        def GetNodes(self,node_filter= None, return_fields=None):
-               print>>sys.stderr, " \r\n GetNodes node_filter %s return_fields %s" %(node_filter,return_fields) 
+               #print>>sys.stderr, " \r\n GetNodes node_filter %s return_fields %s" %(node_filter,return_fields) 
                self.parser.SendRequest("GET_resources_full")
                node_dict = self.parser.GetNodesFromOARParse()
                return_node_list = []
-               print>>sys.stderr, " \r\n GetNodes   node_dict %s" %(node_dict) 
+               #print>>sys.stderr, " \r\n GetNodes   node_dict %s" %(node_dict) 
                if not (node_filter or return_fields):
                        return_node_list = node_dict.values()
                        return return_node_list
@@ -299,19 +299,19 @@ class OARapi:
                site = site_dict.values()[0]
                Users = SenslabImportUsers()
                        
-               print>>sys.stderr, " \r\n  GetSites sites_dict %s site_filter %s  \r\n \r\n  \r\n \r\n------site %s" %(site_dict,site_filter,site ) 
+               #print>>sys.stderr, " \r\n  GetSites sites_dict %s site_filter %s  \r\n \r\n  \r\n \r\n------site %s" %(site_dict,site_filter,site ) 
                admins_dict ={'person_ids': Users.GetPIs(site['site_id'])}
                site.update(admins_dict)        
                
                slice_list = Users.GetSlices()
                for sl in slice_list:
-                       print>>sys.stderr, " \r\n  GetSites sl %s" %(sl)
+                       #print>>sys.stderr, " \r\n  GetSites sl %s" %(sl)
                        if sl['site_id'] == site['site_id']:
                                site['slice_ids'].append(sl['slice_id'])
-               print>>sys.stderr, " \r\n  GetSites -site['site_id'] %s --slice_list %s" %(site['site_id'],slice_list ) 
+               #print>>sys.stderr, " \r\n  GetSites -site['site_id'] %s --slice_list %s" %(site['site_id'],slice_list ) 
                
                
-               print>>sys.stderr, " \r\n  GetSites -site['site_id'] %s --admins_dict %s---site %s" %(site['site_id'],admins_dict,site )                
+               #print>>sys.stderr, " \r\n  GetSites -site['site_id'] %s --admins_dict %s---site %s" %(site['site_id'],admins_dict,site )               
                if not (site_filter or return_fields):
                        return_site_list = site_dict.values()
                        return return_site_list

diff --git a/sfa/senslab/parsing.py b/sfa/senslab/parsing.py
index 248caad..0234c24 100644 (file)
--- a/sfa/senslab/parsing.py
+++ b/sfa/senslab/parsing.py
@@ -39,17 +39,17 @@ def parse_filter(list_to_filter, param_filter, type_of_list, return_fields=None)
                print>>sys.stderr, " \r\n type_of_list Error  parse_filter %s " %(type_of_list)
                return []
        
-       print>>sys.stderr, " \r\n ____FIRST ENTRY parse_filter param_filter %s type %s  list %s " %(param_filter, type(param_filter), list_to_filter)
+       #print>>sys.stderr, " \r\n ____FIRST ENTRY parse_filter param_filter %s type %s  list %s " %(param_filter, type(param_filter), list_to_filter)
        return_filtered_list= []
        
        for item in list_to_filter:
                tmp_item = {}
                
                if type(param_filter) is list :
-                       print>>sys.stderr, " \r\n p_filter LIST %s " %(param_filter)
+                       #print>>sys.stderr, " \r\n p_filter LIST %s " %(param_filter)
                        
                        for p_filter in param_filter:
-                               print>>sys.stderr, " \r\n p_filter %s \t item %s " %(p_filter,item)
+                               #print>>sys.stderr, " \r\n p_filter %s \t item %s " %(p_filter,item)
                                if type(p_filter) is int:
                                        if item[list_type[type_of_list]['int']] == p_filter :
                                                if return_fields:
@@ -82,7 +82,7 @@ def parse_filter(list_to_filter, param_filter, type_of_list, return_fields=None)
                                        del tmp_copy[key] 
                                        
                        
-                       print>>sys.stderr, " \r\n tmp_copy %s param_filter %s cmp = %s " %(tmp_copy, param_filter,cmp(tmp_copy, stripped_filterdict))
+                       #print>>sys.stderr, " \r\n tmp_copy %s param_filter %s cmp = %s " %(tmp_copy, param_filter,cmp(tmp_copy, stripped_filterdict))
                        
                        if cmp(tmp_copy, stripped_filterdict) == 0:     
                                if return_fields: