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
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)
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:
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)
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'],
('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):
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
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
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:
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: