self.db = SlabDB(config)
self.cache=None
-
+
def sliver_status(self,slice_urn,slice_hrn):
# receive a status request for slice named urn/hrn urn:publicid:IDN+senslab+nturro_slice hrn senslab.nturro_slice
# shall return a structure as described in
self.BindObjectToPeer('slice', slice['slice_id'], peer, slice['peer_slice_id'])
return 1
-
+
+ def AddSlice(self, slice_record):
+ slab_slice = SliceSenslab( slice_hrn = slice_record['slice_hrn'], record_id_slice= slice_record['record_id_slice'] , record_id_user= slice_record['record_id_user'], peer_authority = slice_record['peer_authority'])
+ print>>sys.stderr, "\r\n \r\n \t\t\t =======SLABDRIVER.PY AddSlice slice_record %s slab_slice %s" %(slice_record,slab_slice)
+ slab_dbsession.add(slab_slice)
+ slab_dbsession.commit()
+ return
+
# first 2 args are None in case of resource discovery
def list_resources (self, slice_urn, slice_hrn, creds, options):
#cached_requested = options.get('cached', True)
print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers auth = %s, peer_filter %s, return_field %s " %(auth , peer_filter, return_fields)
all_records = dbsession.query(RegRecord).filter(RegRecord.type.like('%authority%')).all()
for record in all_records:
- existing_records[record.hrn] = record
+ existing_records[(record.hrn,record.type)] = record
if record.type not in existing_hrns_by_types:
existing_hrns_by_types[record.type] = [record.hrn]
print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers \t NOT IN existing_hrns_by_types %s " %( existing_hrns_by_types)
print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers existing_hrns_by_types %s " %( existing_hrns_by_types)
records_list= []
- try:
- for hrn in existing_hrns_by_types['authority+sa']:
- records_list.append(existing_records[hrn])
- print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers records_list %s " %(records_list)
+ try:
+ print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers existing_hrns_by_types['authority+sa'] %s \t\t existing_records %s " %(existing_hrns_by_types['authority'],existing_records)
+ if peer_filter:
+ records_list.append(existing_records[(peer_filter,'authority')])
+ else :
+ for hrn in existing_hrns_by_types['authority']:
+ records_list.append(existing_records[(hrn,'authority')])
+
+ print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers records_list %s " %(records_list)
except:
pass
-
+
+ return_records = records_list
if not peer_filter and not return_fields:
return records_list
- return_records = parse_filter(records_list,peer_filter, 'peers', return_fields)
-
+ #return_records = parse_filter(records_list,peer_filter, 'peers', return_fields)
+
+ print >>sys.stderr, "\r\n \r\n SLABDRIVER GetPeers return_records %s " %(return_records)
return return_records
'person_ids':[recslice['record_id_user']]})
elif str(record['type']) == 'user':
+ #Add the data about slice
print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info USEEEEEEEEEERDESU!"
rec = self.GetSlices(slice_filter = record['record_id'], filter_type = 'record_id_user')
#Append record in records list, therfore fetches user and slice info again(one more loop)
#Will update PIs and researcher for the slice
-
+ user_slab = self.GetPersons(recuser.hrn)
+ print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info user_slab %s !" %(user_slab)
rec.update({'type':'slice','hrn':rec['slice_hrn']})
records.append(rec)
#print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info ADDING SLIC EINFO rec %s" %(rec)
class SliceSenslab (SlabBase):
__tablename__ = 'slice_senslab'
- record_id_user = Column(Integer, primary_key=True)
+ #record_id_user = Column(Integer, primary_key=True)
+ slice_hrn = Column(String,primary_key=True)
+ peer_authority = Column( String,nullable = True)
+ record_id_slice = Column(Integer)
+ record_id_user = Column(Integer)
oar_job_id = Column( Integer,default = -1)
- record_id_slice = Column(Integer)
- slice_hrn = Column(String,nullable = False)
node_list = Column(postgresql.ARRAY(String), nullable =True)
- def __init__ (self, slice_hrn =None, oar_job_id=None, record_id_slice=None, record_id_user= None):
+ def __init__ (self, slice_hrn =None, oar_job_id=None, record_id_slice=None, record_id_user= None,peer_authority=None):
self.node_list = []
if record_id_slice:
self.record_id_slice = record_id_slice
self.slice_hrn = slice_hrn
if record_id_user:
self.record_id_user= record_id_user
+ if peer_authority:
+ self.peer_authority = peer_authority
def __repr__(self):
- result="<Record id user =%s, slice hrn=%s, oar_job id=%s,Record id slice =%s node_list =%s" % \
- (self.record_id_user, self.slice_hrn, self.oar_job_id, self.record_id_slice, self.node_list)
+ result="<Record id user =%s, slice hrn=%s, oar_job id=%s,Record id slice =%s node_list =%s peer_authority =%s"% \
+ (self.record_id_user, self.slice_hrn, self.oar_job_id, self.record_id_slice, self.node_list, self.peer_authority)
result += ">"
return result
def dumpquerytodict(self):
dict = {'slice_hrn':self.slice_hrn,
+ 'peer_authority':self.peer_authority,
'record_id':self.record_id_slice,
'record_id_user':self.record_id_user,
'oar_job_id':self.oar_job_id,
- 'record_id_slice':self.record_id_slice,
- 'slice_hrn':self.slice_hrn,
+ 'record_id_slice':self.record_id_slice,
'node_list':self.node_list}
return dict
#class PeerSenslab(SlabBase):
# get this slice's authority (site)
slice_authority = get_authority(hrn)
-
+ site_authority = slice_authority
# get this site's authority (sfa root authority or sub authority)
- site_authority = get_authority(slice_authority).lower()
- print>>sys.stderr, " \r\n \r\n \t slices.py get_peer slice_authority %s site_authority %s " %(slice_authority, site_authority)
+ #site_authority = get_authority(slice_authority).lower()
+ print>>sys.stderr, " \r\n \r\n \t slices.py get_peer slice_authority %s site_authority %s hrn %s" %(slice_authority, site_authority, hrn)
# check if we are already peered with this site_authority, if so
- peers = self.driver.GetPeers({})
- #print>>sys.stderr, " \r\n \r\n \t slices.py get_peer peers %s " %(peers)
+ #peers = self.driver.GetPeers({})
+ peers = self.driver.GetPeers(peer_filter = slice_authority)
for peer_record in peers:
if site_authority == peer_record.hrn:
peer = peer_record
- #print>>sys.stderr, " \r\n \r\n \t slices.py get_peer peer %s " %(peer)
+ print>>sys.stderr, " \r\n \r\n \t slices.py get_peerAPRES Mpeer %s " %(peer)
return peer
def get_sfa_peer(self, xrn):
if sl:
print>>sys.stderr, " \r\n \r\rn Slices.py verify_slice slicename %s sl %s slice_record %s"%(slicename ,sl, slice_record)
- else:
- print>>sys.stderr, " \r\n \r\rn Slices.py verify_slice UH-Oh..."
- if not sl:
- slice = {'name': slicename,
- 'url': slice_record.get('url', slice_hrn),
- #'description': slice_record.get('description', slice_hrn)
- }
- # add the slice
- slice['slice_id'] = self.driver.AddSlice(slice)
- slice['node_ids'] = []
- slice['person_ids'] = []
- #if peer:
- #slice['peer_slice_id'] = slice_record.get('slice_id', None)
- # mark this slice as an sfa peer record
- #if sfa_peer:
- #peer_dict = {'type': 'slice', 'hrn': slice_hrn,
- #'peer_authority': sfa_peer, 'pointer': slice['slice_id']}
- #self.registry.register_peer_object(self.credential, peer_dict)
- else:
slice = sl
slice.update(slice_record)
#del slice['last_updated']
#Update existing record (e.g. expires field) it with the latest info.
##if slice_record and slice['expires'] != slice_record['expires']:
##self.driver.UpdateSlice( slice['slice_id'], {'expires' : slice_record['expires']})
+ else:
+ print>>sys.stderr, " \r\n \r\rn Slices.py verify_slice UH-Oh...slice_record %s peer %s sfa_peer %s "%(slice_record, peer,sfa_peer)
+ slice = {'slice_hrn': slicename,
+ #'url': slice_record.get('url', slice_hrn),
+ #'description': slice_record.get('description', slice_hrn)
+ 'node_list' : [],
+ 'record_id_user' : slice_record['person_ids'][0],
+ 'record_id_slice': slice_record['record_id'],
+ 'peer_authority':str(peer.hrn)
+
+ }
+ # add the slice
+ self.driver.AddSlice(slice)
+ #slice['slice_id'] = self.driver.AddSlice(slice)
+ print>>sys.stderr, " \r\n \r\rn Slices.py verify_slice ADDSLICE OHYEEEEEEEEEEAH! "
+ #slice['node_ids']=[]
+ #slice['person_ids'] = []
+ #if peer:
+ #slice['peer_slice_id'] = slice_record.get('slice_id', None)
+ # mark this slice as an sfa peer record
+ #if sfa_peer:
+ #peer_dict = {'type': 'slice', 'hrn': slice_hrn,
+ #'peer_authority': sfa_peer, 'pointer': slice['slice_id']}
+ #self.registry.register_peer_object(self.credential, peer_dict)
+
+
return slice
users_by_hrn[user['hrn']] = user
users_dict[user['hrn']] = {'person_id':user['person_id'], 'hrn':user['hrn']}
- #print>>sys.stderr, " \r\n \r\n \t slabslices.py verify_person users_dict %s \r\n user_by_hrn %s \r\n \tusers_by_id %s " %( users_dict,users_by_hrn, users_by_id)
+ print>>sys.stderr, " \r\n \r\n \t slabslices.py verify_person users_dict %s \r\n user_by_hrn %s \r\n \tusers_by_id %s " %( users_dict,users_by_hrn, users_by_id)
existing_user_ids = []
existing_user_hrns = []
#Check if user is in LDAP using its hrn.
#Assuming Senslab is centralised : one LDAP for all sites, user_id unknown from LDAP
# LDAP does not provide users id, therfore we rely on hrns
- if users_by_hrn:
- existing_users = self.driver.GetPersons({'hrn': users_by_hrn.keys()},
- ['hrn','pkey'])
+ if users_by_hrn:
+ existing_users = self.driver.GetPersons({'hrn': users_by_hrn.keys()})
+ #existing_users = self.driver.GetPersons({'hrn': users_by_hrn.keys()},
+ #['hrn','pkey'])
if existing_users:
for user in existing_users :
#for k in users_dict[user['hrn']] :
#print>>sys.stderr, " \r\n \r\n \t slabslices.py verify_person existing_user_ids.append (users_dict[user['hrn']][k]) %s \r\n existing_users %s " %( existing_user_ids,existing_users)
#User from another federated site , does not have a senslab account yet
- else:
+ #Add them to LDAP
+
+ else:
+
+ print>>sys.stderr, " \r\n \r\n \t slabslices.py verify_person HUMHUMHUMHUM ..."
pass
# requested slice users
requested_user_ids = users_by_id.keys()
requested_user_hrns = users_by_hrn.keys()
- #print>>sys.stderr, " \r\n \r\n \t slabslices.py verify_person requested_user_ids %s user_by_hrn %s " %( requested_user_ids,users_by_hrn)
+ print>>sys.stderr, " \r\n \r\n \t slabslices.py verify_person requested_user_ids %s user_by_hrn %s " %( requested_user_ids,users_by_hrn)
# existing slice users
existing_slice_users_filter = {'hrn': slice_record.get('PI', [])}
- #print>>sys.stderr, " \r\n \r\n slices.py verify_person requested_user_ids %s existing_slice_users_filter %s slice_record %s" %(requested_user_ids,existing_slice_users_filter,slice_record)
+ print>>sys.stderr, " \r\n \r\n slices.py verify_person requested_user_ids %s existing_slice_users_filter %s slice_record %s" %(requested_user_ids,existing_slice_users_filter,slice_record)
- existing_slice_users = self.driver.GetPersons(existing_slice_users_filter,['hrn','pkey'])
- #print>>sys.stderr, " \r\n \r\n slices.py verify_person existing_slice_users %s " %(existing_slice_users)
+ existing_slice_users = self.driver.GetPersons(existing_slice_users_filter)
+ #existing_slice_users = self.driver.GetPersons(existing_slice_users_filter,['hrn','pkey'])
+ print>>sys.stderr, " \r\n \r\n slices.py verify_person existing_slice_users %s " %(existing_slice_users)
existing_slice_user_hrns = [user['hrn'] for user in existing_slice_users]
git://git.onelab.eu / sfa.git / commitdiff