X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Fplc%2Fslices.py;h=a384a9b40ce612242fa62da1077988689a47d266;hb=49061aaff430deba3a45e522fb9e1ea4a154044b;hp=88e29c95d9275a950eeffff8dd31b1b84f85ce5d;hpb=d19daaaa783830706e04dc1a887b95c396c15f30;p=sfa.git diff --git a/sfa/plc/slices.py b/sfa/plc/slices.py index 88e29c95..a384a9b4 100644 --- a/sfa/plc/slices.py +++ b/sfa/plc/slices.py @@ -103,15 +103,30 @@ class Slices(SimpleStorage): slice_hrns = [] aggregates = Aggregates(self.api) credential = self.api.getCredential() - arg_list = [credential] - request_hash = self.api.key.compute_hash(arg_list) for aggregate in aggregates: + success = False + # request hash is optional so lets try the call without it try: - slices = aggregates[aggregate].get_slices(credential, request_hash) + slices = aggregates[aggregate].get_slices(credential) slice_hrns.extend(slices) + success = True except: + print >> log, "%s" % (traceback.format_exc()) print >> log, "Error calling slices at aggregate %(aggregate)s" % locals() - # update timestamp and threshold + + # try sending the request hash if the previous call failed + if not success: + arg_list = [credential] + request_hash = self.api.key.compute_hash(arg_list) + try: + slices = aggregates[aggregate].get_slices(credential, request_hash) + slice_hrns.extend(slices) + success = True + except: + print >> log, "%s" % (traceback.format_exc()) + print >> log, "Error calling slices at aggregate %(aggregate)s" % locals() + + # update timestamp and threshold timestamp = datetime.datetime.now() hr_timestamp = timestamp.strftime(self.api.time_format) delta = datetime.timedelta(hours=self.ttl) @@ -151,16 +166,29 @@ class Slices(SimpleStorage): def delete_slice_smgr(self, hrn): credential = self.api.getCredential() + caller_cred = self.caller_cred aggregates = Aggregates(self.api) for aggregate in aggregates: + success = False + # request hash is optional so lets try the call without it try: - aggregates[aggregate].delete_slice(credential, hrn, caller_cred=self.caller_cred) + aggregates[aggregate].delete_slice(credential, hrn, caller_cred) + success = True except: + print >> log, "%s" % (traceback.format_exc()) print >> log, "Error calling list nodes at aggregate %s" % aggregate - traceback.print_exc(log) - exc_type, exc_value, exc_traceback = sys.exc_info() - print exc_type, exc_value, exc_traceback - + + # try sending the request hash if the previous call failed + if not success: + try: + arg_list = [credential, hrn] + request_hash = self.api.key.compute_hash(arg_list) + aggregates[aggregate].delete_slice(credential, hrn, request_hash, caller_cred) + success = True + except: + print >> log, "%s" % (traceback.format_exc()) + print >> log, "Error calling list nodes at aggregate %s" % aggregate + def create_slice(self, hrn, rspec): # check our slice policy before we procede @@ -180,11 +208,17 @@ class Slices(SimpleStorage): def verify_site(self, registry, credential, slice_hrn, peer, sfa_peer): authority = get_authority(slice_hrn) - site_records = registry.resolve(credential, authority) + try: + site_records = registry.resolve(credential, authority) + except: + arg_list = [credential, authority] + request_hash = self.api.key.compute_hash(arg_list) + site_records = registry.resolve(credential, authority, request_hash) + site = {} for site_record in site_records: if site_record['type'] == 'authority': - site = site_record.as_dict() + site = site_record if not site: raise RecordNotFound(authority) remote_site_id = site.pop('site_id') @@ -197,9 +231,13 @@ class Slices(SimpleStorage): self.api.plshell.BindObjectToPeer(self.api.plauth, 'site', site_id, peer, remote_site_id) # mark this site as an sfa peer record if sfa_peer: - peer_dict = {'type': 'authority', 'hrn': authority, 'peer_authority': sfa_peer, 'pointer': site_id} - registry.register_peer_object(credential, peer_dict) - pass + peer_dict = {'type': 'authority', 'hrn': authority, 'peer_authority': sfa_peer, 'pointer': site_id} + try: + registry.register_peer_object(credential, peer_dict) + except: + arg_list = [credential] + request_hash = self.api.key.compute_hash(arg_list) + registry.register_peer_object(credential, peer_dict, request_hash) else: site_id = sites[0]['site_id'] remote_site_id = sites[0]['peer_site_id'] @@ -211,7 +249,13 @@ class Slices(SimpleStorage): slice = {} slice_record = None authority = get_authority(slice_hrn) - slice_records = registry.resolve(credential, slice_hrn) + try: + slice_records = registry.resolve(credential, slice_hrn) + except: + arg_list = [credential, slice_hrn] + request_hash = self.api.key.compute_hash(arg_list) + slice_records = registry.resolve(credential, slice_hrn, request_hash) + for record in slice_records: if record['type'] in ['slice']: slice_record = record @@ -235,9 +279,13 @@ class Slices(SimpleStorage): # mark this slice as an sfa peer record if sfa_peer: - peer_dict = {'type': 'slice', 'hrn': slice_hrn, 'peer_authority': sfa_peer, 'pointer': slice_id} - registry.register_peer_object(credential, peer_dict) - pass + peer_dict = {'type': 'slice', 'hrn': slice_hrn, 'peer_authority': sfa_peer, 'pointer': slice_id} + try: + registry.register_peer_object(credential, peer_dict) + except: + arg_list = [credential] + request_hash = self.api.key.compute_hash(arg_list) + registry.register_peer_object(credential, peer_dict, request_hash) #this belongs to a peer if peer: @@ -260,16 +308,26 @@ class Slices(SimpleStorage): researchers = slice_record.get('researcher', []) for researcher in researchers: person_record = {} - person_records = registry.resolve(credential, researcher) + try: + person_records = registry.resolve(credential, researcher) + except: + arg_list = [credential, researcher] + request_hash = self.api.key.compute_hash(arg_list) + person_records = registry.resolve(credential, researcher, request_hash) for record in person_records: if record['type'] in ['user']: person_record = record if not person_record: pass - person_dict = person_record.as_dict() + person_dict = person_record + local_person=False if peer: peer_id = self.api.plshell.GetPeers(self.api.plauth, {'shortname': peer}, ['peer_id'])[0]['peer_id'] persons = self.api.plshell.GetPersons(self.api.plauth, {'email': [person_dict['email']], 'peer_id': peer_id}, ['person_id', 'key_ids']) + if not persons: + persons = self.api.plshell.GetPersons(self.api.plauth, [person_dict['email']], ['person_id', 'key_ids']) + if persons: + local_person=True else: persons = self.api.plshell.GetPersons(self.api.plauth, [person_dict['email']], ['person_id', 'key_ids']) @@ -280,9 +338,13 @@ class Slices(SimpleStorage): # mark this person as an sfa peer record if sfa_peer: - peer_dict = {'type': 'user', 'hrn': researcher, 'peer_authority': sfa_peer, 'pointer': person_id} - registry.register_peer_object(credential, peer_dict) - pass + peer_dict = {'type': 'user', 'hrn': researcher, 'peer_authority': sfa_peer, 'pointer': person_id} + try: + registry.register_peer_object(credential, peer_dict) + except: + arg_list = [credential] + request_hash = self.api.key.compute_hash(arg_list) + registry.register_peer_object(credential, peer_dict, request_hash) if peer: self.api.plshell.BindObjectToPeer(self.api.plauth, 'person', person_id, peer, person_dict['pointer']) @@ -300,13 +362,14 @@ class Slices(SimpleStorage): self.api.plshell.AddPersonToSlice(self.api.plauth, person_dict['email'], slicename) self.api.plshell.AddPersonToSite(self.api.plauth, person_dict['email'], site_id) - if peer: + if peer and not local_person: self.api.plshell.BindObjectToPeer(self.api.plauth, 'person', person_id, peer, person_dict['pointer']) + if peer: self.api.plshell.BindObjectToPeer(self.api.plauth, 'site', site_id, peer, remote_site_id) - self.verify_keys(registry, credential, person_dict, key_ids, person_id, peer) + self.verify_keys(registry, credential, person_dict, key_ids, person_id, peer, local_person) - def verify_keys(self, registry, credential, person_dict, key_ids, person_id, peer): + def verify_keys(self, registry, credential, person_dict, key_ids, person_id, peer, local_person): keylist = self.api.plshell.GetKeys(self.api.plauth, key_ids, ['key']) keys = [key['key'] for key in keylist] @@ -318,8 +381,9 @@ class Slices(SimpleStorage): if peer: self.api.plshell.UnBindObjectFromPeer(self.api.plauth, 'person', person_id, peer) key_id = self.api.plshell.AddPersonKey(self.api.plauth, person_dict['email'], key) - if peer: + if peer and not local_person: self.api.plshell.BindObjectToPeer(self.api.plauth, 'person', person_id, peer, person_dict['pointer']) + if peer: try: self.api.plshell.BindObjectToPeer(self.api.plauth, 'key', key_id, peer, key_ids.pop(0)) except: pass @@ -330,7 +394,7 @@ class Slices(SimpleStorage): peer = self.get_peer(hrn) sfa_peer = self.get_sfa_peer(hrn) - spec = Rspec(rspec) + spec = RSpec(rspec) # Get the slice record from sfa slicename = hrn_to_pl_slicename(hrn) slice = {} @@ -370,12 +434,12 @@ class Slices(SimpleStorage): return 1 def create_slice_smgr(self, hrn, rspec): - spec = Rspec() - tempspec = Rspec() + spec = RSpec() + tempspec = RSpec() spec.parseString(rspec) slicename = hrn_to_pl_slicename(hrn) specDict = spec.toDict() - if specDict.has_key('Rspec'): specDict = specDict['Rspec'] + 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'] @@ -390,27 +454,48 @@ class Slices(SimpleStorage): for netspec in netspecs: net_hrn = netspec['name'] resources = {'start_time': start_time, 'end_time': end_time, 'networks': netspec} - resourceDict = {'Rspec': resources} + resourceDict = {'RSpec': resources} tempspec.parseDict(resourceDict) rspecs[net_hrn] = tempspec.toxml() - # send each rspec to the appropriate aggregate/sm + # send each rspec to the appropriate aggregate/sm + caller_cred = self.caller_cred for net_hrn in rspecs: try: # if we are directly connected to the aggregate then we can just send them the rspec - # if not, then we may be connected to an sm thats connected to the aggregate + # if not, then we may be connected to an sm thats connected to the aggregate if net_hrn in aggregates: # send the whloe rspec to the local aggregate if net_hrn in [self.api.hrn]: - aggregates[net_hrn].create_slice(credential, hrn, rspec, caller_cred=self.caller_cred) + try: + aggregates[net_hrn].create_slice(credential, hrn, rspec, caller_cred) + except: + arg_list = [credential,hrn,rspec] + request_hash = self.api.key.compute_hash(arg_list) + aggregates[net_hrn].create_slice(credential, hrn, rspec, request_hash, caller_cred) else: - aggregates[net_hrn].create_slice(credential, hrn, rspecs[net_hrn], caller_cred=self.caller_cred) + try: + aggregates[net_hrn].create_slice(credential, hrn, rspecs[net_hrn], caller_cred) + except: + arg_list = [credential,hrn,rspecs[net_hrn]] + request_hash = self.api.key.compute_hash(arg_list) + aggregates[net_hrn].create_slice(credential, hrn, rspecs[net_hrn], request_hash, caller_cred) else: - # lets forward this rspec to a sm that knows about the network + # lets forward this rspec to a sm that knows about the network + arg_list = [credential, net_hrn] + request_hash = self.api.compute_hash(arg_list) for aggregate in aggregates: - network_found = aggregates[aggregate].get_aggregates(credential, net_hrn) + try: + network_found = aggregates[aggregate].get_aggregates(credential, net_hrn) + except: + network_found = aggregates[aggregate].get_aggregates(credential, net_hrn, request_hash) if network_networks: - aggregates[aggregate].create_slice(credential, hrn, rspecs[net_hrn], caller_cred=self.caller_cred) + try: + aggregates[aggregate].create_slice(credential, hrn, rspecs[net_hrn], caller_cred) + except: + arg_list = [credential, hrn, rspecs[net_hrn]] + request_hash = self.api.key.compute_hash(arg_list) + aggregates[aggregate].create_slice(credential, hrn, rspecs[net_hrn], request_hash, caller_cred) except: print >> log, "Error creating slice %(hrn)s at aggregate %(net_hrn)s" % locals() @@ -463,6 +548,11 @@ class Slices(SimpleStorage): def stop_slice_smgr(self, hrn): credential = self.api.getCredential() aggregates = Aggregates(self.api) + arg_list = [credential, hrn] + request_hash = self.api.key.compute_hash(arg_list) for aggregate in aggregates: - aggregates[aggregate].stop_slice(credential, hrn) + try: + aggregates[aggregate].stop_slice(credential, hrn) + except: + aggregates[aggregate].stop_slice(credential, hrn, request_hash)