authority=self.hrn).urn
res['geni_urn'] = sliver_id
- if nodeall_byhostname[node['hostname']]['boot_state'] == 'Alive':
+ node_name = node['hostname']
+ if nodeall_byhostname[node_name]['boot_state'] == 'Alive':
res['geni_status'] = 'ready'
else:
if users:
slice_record = users[0].get('slice_record', {})
logger.debug("SLABDRIVER.PY \t create_sliver \t\
- slice_record %s \r\n \r\n users %s" \
- %(slice_record, users))
- slice_record['user'] = {'keys':users[0]['keys'], 'email':users[0]['email'], 'hrn':slice_record['reg-researchers'][0]}
+ slice_record %s \r\n \r\n users %s" \
+ %(slice_record, users))
+ slice_record['user'] = {'keys':users[0]['keys'], \
+ 'email':users[0]['email'], \
+ 'hrn':slice_record['reg-researchers'][0]}
# parse rspec
rspec = RSpec(rspec_string)
logger.debug("SLABDRIVER.PY \t create_sliver \trspec.version \
- %s slice_record %s users %s" \
- %(rspec.version,slice_record, users))
+ %s slice_record %s users %s" \
+ %(rspec.version,slice_record, users))
# ensure site record exists?
for lease in rspec.version.get_leases():
single_requested_lease = {}
logger.debug("SLABDRIVER.PY \tcreate_sliver lease %s " %(lease))
+
if not lease.get('lease_id'):
if get_authority(lease['component_id']) == self.root_auth:
single_requested_lease['hostname'] = \
- slab_xrn_to_hostname(\
- lease.get('component_id').strip())
- single_requested_lease['start_time'] = lease.get('start_time')
+ slab_xrn_to_hostname(\
+ lease.get('component_id').strip())
+ single_requested_lease['start_time'] = \
+ lease.get('start_time')
single_requested_lease['duration'] = lease.get('duration')
- #if single_requested_lease.get('hostname'):
requested_lease_list.append(single_requested_lease)
logger.debug("SLABDRIVER.PY \tcreate_sliver APRESLEASE" )
def AddSlice(self, slice_record, user_record):
- #Add slice to the sfa table
- sfa_record = RegSlice (hrn=slice_record['slice_hrn'], gid=slice_record['gid'],
- pointer=slice_record['slice_id'],
- authority=slice_record['authority'])
- logger.debug("SLABDRIVER.PY AddSlice sfa_record %s user_record %s" %(sfa_record, user_record))
- #There is no way to separate-adding the slice to the tesbed
- #nd then importing it from the testebd to SFA because of the senslab's architecture
+ """Add slice to the sfa tables and senslab table only if the user
+ already exists in senslab database(user already registered in LDAP).
+ There is no way to separate adding the slice to the tesbed
+ and then importing it from the testbed to SFA because of
+ senslab's architecture. Therefore, sfa tables are updated here.
+ """
+
+ sfa_record = RegSlice(hrn=slice_record['slice_hrn'],
+ gid=slice_record['gid'],
+ pointer=slice_record['slice_id'],
+ authority=slice_record['authority'])
+
+ logger.debug("SLABDRIVER.PY AddSlice sfa_record %s user_record %s" \
+ %(sfa_record, user_record))
sfa_record.just_created()
dbsession.add(sfa_record)
dbsession.commit()
+ #Update the reg-researcher dependance table
sfa_record.reg_researchers = [user_record]
dbsession.commit()
- #sl_rec = dbsession.query(RegSlice).filter(RegSlice.hrn.match(slice_hrn)).all()
-
-
+
+ #Update the senslab table with the new slice
slab_slice = SliceSenslab( slice_hrn = slice_record['slice_hrn'], \
record_id_slice = sfa_record.record_id , \
record_id_user = slice_record['record_id_user'], \
peer_authority = slice_record['peer_authority'])
- logger.debug("SLABDRIVER.PY \tAddSlice slice_record %s slab_slice %s sfa_record %s" \
- %(slice_record,slab_slice, sfa_record))
+
+ logger.debug("SLABDRIVER.PY \tAddSlice slice_record %s \
+ slab_slice %s sfa_record %s" \
+ %(slice_record,slab_slice, sfa_record))
slab_dbsession.add(slab_slice)
slab_dbsession.commit()
return
slices = self.GetSlices()
logger.debug("SLABDRIVER.PY \tlist_slices hrn %s \r\n \r\n" %(slices))
slice_hrns = [slab_slice['slice_hrn'] for slab_slice in slices]
- #slice_hrns = [slicename_to_hrn(self.hrn, slab_slice['slice_hrn']) \
- #for slab_slice in slices]
+
slice_urns = [hrn_to_urn(slice_hrn, 'slice') \
for slice_hrn in slice_hrns]
"""
return -1
- #No site or node record update allowed
+
def update (self, old_sfa_record, new_sfa_record, hrn, new_key):
+ """No site or node record update allowed in Senslab."""
+
pointer = old_sfa_record['pointer']
old_sfa_record_type = old_sfa_record['type']
logger.debug("SLABDRIVER \tGetPeers auth = %s, peer_filter %s, \
return_field %s " %(auth , peer_filter, return_fields_list))
all_records = dbsession.query(RegRecord).filter(RegRecord.type.like('%authority%')).all()
+
for record in all_records:
existing_records[(record.hrn, record.type)] = record
if record.type not in existing_hrns_by_types:
existing_hrns_by_types[record.type] = [record.hrn]
- logger.debug("SLABDRIVER \tGetPeer\t NOT IN \
- existing_hrns_by_types %s " %( existing_hrns_by_types))
else:
-
- logger.debug("SLABDRIVER \tGetPeer\t \INNN type %s hrn %s " \
- %(record.type,record.hrn))
existing_hrns_by_types[record.type].append(record.hrn)
#add a filter for make_ldap_filters_from_record
person = self.ldap.LdapFindUser(searched_attributes, \
is_user_enabled=True)
- person_list.append(person)
+ #If a person was found, append it to the list
+ if person:
+ person_list.append(person)
+
+ #If the list is empty, return None
+ if len(person_list) is 0:
+ person_list = None
else:
#Get only enabled user accounts in senslab LDAP :
return person_list
def GetTimezone(self):
+ """ Get the OAR servier time and timezone.
+ Unused SA 16/11/12"""
server_timestamp, server_tz = self.oar.parser.\
SendRequest("GET_timezone")
return server_timestamp, server_tz
"""
node_dict_by_id = self.oar.parser.SendRequest("GET_resources_full")
node_dict_list = node_dict_by_id.values()
- logger.debug (" SLABDRIVER GetNodes node_filter_dict %s return_fields_list %s "%(node_filter_dict,return_fields_list))
+ logger.debug (" SLABDRIVER GetNodes node_filter_dict %s \
+ return_fields_list %s "%(node_filter_dict, return_fields_list))
#No filtering needed return the list directly
if not (node_filter_dict or return_fields_list):
return node_dict_list
def GetSlices(self, slice_filter = None, slice_filter_type = None):
- #def GetSlices(self, slice_filter = None, slice_filter_type = None, \
- #return_fields_list = None):
""" Get the slice records from the slab db.
Returns a slice ditc if slice_filter and slice_filter_type
are specified.
if slice_filter_type in authorized_filter_types_list:
- def __get_slice_records(slice_filter = None, slice_filter_type = None):
+ def __get_slice_records(slice_filter = None, \
+ slice_filter_type = None):
login = None
#Get list of slices based on the slice hrn
login = slice_filter.split(".")[1].split("_")[0]
- #DO NOT USE RegSlice - reg_researchers to get the hrn of the user
- #otherwise will mess up the RegRecord in Resolve, don't know
- #why - SA 08/08/2012
+ #DO NOT USE RegSlice - reg_researchers to get the hrn
+ #of the user otherwise will mess up the RegRecord in
+ #Resolve, don't know why - SA 08/08/2012
#Only one entry for one user = one slice in slice_senslab table
slicerec = slab_dbsession.query(SliceSenslab).filter_by(slice_hrn = slice_filter).first()
if slicerec is None:
return login, None
+
#Get slice based on user id
if slice_filter_type == 'record_id_user':
slicerec = slab_dbsession.query(SliceSenslab).filter_by(record_id_user = slice_filter).first()
logger.debug("SLABDRIVER.PY \tGetSlices \
slicerec_dict %s return_slicerec_dictlist %s \
lease['reserved_nodes'] \
- %s" %(slicerec_dict, return_slicerec_dictlist,\
+ %s" %(slicerec_dict, return_slicerec_dictlist, \
lease['reserved_nodes'] ))
logger.debug("SLABDRIVER.PY \tGetSlices RETURN \
- return_slicerec_dictlist %s" %(return_slicerec_dictlist))
+ return_slicerec_dictlist %s" \
+ %(return_slicerec_dictlist))
return return_slicerec_dictlist
#Get all the jobs reserved nodes
leases_list = self.GetReservedNodes()
-
-
-
+
for fixed_slicerec_dict in return_slicerec_dictlist:
slicerec_dict = {}
owner = fixed_slicerec_dict['slice_hrn'].split(".")[1].split("_")[0]
#return_slicerec_dictlist.append(slicerec_dict)
fixed_slicerec_dict.update(slicerec_dict)
- logger.debug("SLABDRIVER.PY \tGetSlices RETURN return_slicerec_dictlist %s \
- slice_filter %s " %(return_slicerec_dictlist, slice_filter))
+ logger.debug("SLABDRIVER.PY \tGetSlices RETURN \
+ return_slicerec_dictlist %s \slice_filter %s " \
+ %(return_slicerec_dictlist, slice_filter))
return return_slicerec_dictlist
'geni_ad_rspec_versions': ad_rspec_versions,
}
-
-
-
-
+
##
# Convert SFA fields to PLC fields for use when registering up updating
if not "instantiation" in slab_record:
slab_record["instantiation"] = "senslab-instantiated"
#slab_record["hrn"] = hrn_to_pl_slicename(hrn)
- #Unused hrn_to_pl_slicename because Slab's hrn already in the appropriate form SA 23/07/12
+ #Unused hrn_to_pl_slicename because Slab's hrn already
+ #in the appropriate form SA 23/07/12
slab_record["hrn"] = hrn
logger.debug("SLABDRIVER.PY sfa_fields_to_slab_fields \
slab_record %s " %(slab_record['hrn']))
reqdict['resource'] = "{network_address in ("
for node in lease_dict['added_nodes']:
- logger.debug("\r\n \r\n OARrestapi \t __create_job_structure_request_for_OAR \
- node %s" %(node))
+ logger.debug("\r\n \r\n OARrestapi \t \
+ __create_job_structure_request_for_OAR node %s" %(node))
# Get the ID of the node
nodeid = node
javacmdline = "/usr/bin/java"
jarname = \
"/opt/senslabexperimentwrapper/sfa-1.0-jar-with-dependencies.jar"
- #ret=subprocess.check_output(["/usr/bin/java", "-jar", ", \
- #str(jobid), slice_user])
+
output = subprocess.Popen([javacmdline, "-jar", jarname, str(jobid), \
slice_user],stdout=subprocess.PIPE).communicate()[0]
return
- def AddLeases(self, hostname_list, slice_record, lease_start_time, lease_duration):
+ def AddLeases(self, hostname_list, slice_record, \
+ lease_start_time, lease_duration):
logger.debug("SLABDRIVER \r\n \r\n \t AddLeases hostname_list %s \
slice_record %s lease_start_time %s lease_duration %s "\
%( hostname_list, slice_record , lease_start_time, \
tmp = slice_record['reg-researchers'][0].split(".")
username = tmp[(len(tmp)-1)]
- self.LaunchExperimentOnOAR(hostname_list, slice_record['slice_hrn'], lease_start_time, lease_duration, username)
+ self.LaunchExperimentOnOAR(hostname_list, slice_record['slice_hrn'], \
+ lease_start_time, lease_duration, username)
start_time = datetime.fromtimestamp(int(lease_start_time)).strftime(self.time_format)
logger.debug("SLABDRIVER \t AddLeases hostname_list start_time %s " %(start_time))
reservation_list = []
#Find the slice associated with this user senslab ldap uid
- logger.debug(" SLABDRIVER.PY \tGetLeases ")
+ logger.debug(" SLABDRIVER.PY \tGetLeases unfiltered_reservation_list %s " %(unfiltered_reservation_list))
#Create user dict first to avoid looking several times for
#the same user in LDAP SA 27/07/12
resa_user_dict = {}
if resa['user'] not in resa_user_dict:
logger.debug("SLABDRIVER \tGetLeases userNOTIN ")
ldap_info = self.ldap.LdapSearch('(uid='+resa['user']+')')
- ldap_info = ldap_info[0][1]
- user = dbsession.query(RegUser).filter_by(email = \
+ if ldap_info:
+ ldap_info = ldap_info[0][1]
+ user = dbsession.query(RegUser).filter_by(email = \
ldap_info['mail'][0]).first()
- #Separated in case user not in database :
- #record_id not defined SA 17/07//12
- query_slice_info = slab_dbsession.query(SliceSenslab).filter_by(record_id_user = user.record_id)
- if query_slice_info:
- slice_info = query_slice_info.first()
- else:
- slice_info = None
+ #Separated in case user not in database :
+ #record_id not defined SA 17/07//12
+ query_slice_info = slab_dbsession.query(SliceSenslab).filter_by(record_id_user = user.record_id)
+ if query_slice_info:
+ slice_info = query_slice_info.first()
+ else:
+ slice_info = None
+
+ resa_user_dict[resa['user']] = {}
+ resa_user_dict[resa['user']]['ldap_info'] = user
+ resa_user_dict[resa['user']]['slice_info'] = slice_info
+ #else:
+ #del unfiltered_reservation_list[unfiltered_reservation_list.index(resa)]
+
- resa_user_dict[resa['user']] = {}
- resa_user_dict[resa['user']]['ldap_info'] = user
- resa_user_dict[resa['user']]['slice_info'] = slice_info
logger.debug("SLABDRIVER \tGetLeases resa_user_dict %s"\
%(resa_user_dict))
#Put the slice_urn
- resa['slice_hrn'] = resa_user_dict[resa['user']]['slice_info'].slice_hrn
- resa['slice_id'] = hrn_to_urn(resa['slice_hrn'], 'slice')
- #Put the slice_urn
- #resa['slice_id'] = hrn_to_urn(slice_info.slice_hrn, 'slice')
- resa['component_id_list'] = []
- #Transform the hostnames into urns (component ids)
- for node in resa['reserved_nodes']:
- #resa['component_id_list'].append(hostname_to_urn(self.hrn, \
- #self.root_auth, node['hostname']))
- slab_xrn = slab_xrn_object(self.root_auth, node)
- resa['component_id_list'].append(slab_xrn.urn)
+ if resa['user'] in resa_user_dict:
+ resa['slice_hrn'] = resa_user_dict[resa['user']]['slice_info'].slice_hrn
+ resa['slice_id'] = hrn_to_urn(resa['slice_hrn'], 'slice')
+ #Put the slice_urn
+ #resa['slice_id'] = hrn_to_urn(slice_info.slice_hrn, 'slice')
+ resa['component_id_list'] = []
+ #Transform the hostnames into urns (component ids)
+ for node in resa['reserved_nodes']:
+ #resa['component_id_list'].append(hostname_to_urn(self.hrn, \
+ #self.root_auth, node['hostname']))
+ slab_xrn = slab_xrn_object(self.root_auth, node)
+ resa['component_id_list'].append(slab_xrn.urn)
#Filter the reservation list if necessary
#Returns all the leases associated with a given slice
slicename = slice_hrn
slices_list = self.driver.GetSlices(slice_filter = slicename, \
slice_filter_type = 'slice_hrn')
+ sfa_slice = None
if slices_list:
for sl in slices_list:
}
- if peer:
- sfa_slice['slice_id'] = slice_record['record_id']
+ if peer:
+ sfa_slice['slice_id'] = slice_record['record_id']
# add the slice
- self.driver.AddSlice(sfa_slice, user)
+ if sfa_slice:
+ self.driver.AddSlice(sfa_slice, user)
#slice['slice_id'] = self.driver.AddSlice(slice)
logger.debug("SLABSLICES \tverify_slice ADDSLICE OK")
#slice['node_ids']=[]
"""
#TODO SA 21/08/12 verify_persons Needs review
-
+ logger.debug("SLABSLICES \tverify_persons \tslice_hrn %s \t slice_record %s\r\n users %s \t peer %s "%( slice_hrn, slice_record, users, peer))
users_by_id = {}
users_by_hrn = {}
#users_dict : dict whose keys can either be the user's hrn or its id.
users_dict = {}
#First create dicts by hrn and id for each user in the user record list:
- for user in users:
+ for info in users:
- if 'urn' in user and (not 'hrn' in user ) :
- user['hrn'], user['type'] = urn_to_hrn(user['urn'])
+ if 'slice_record' in info :
+ slice_rec = info['slice_record']
+ user = slice_rec['user']
+
- if 'person_id' in user and 'hrn' in user:
- users_by_id[user['person_id']] = user
- users_dict[user['person_id']] = {'person_id':\
- user['person_id'], 'hrn':user['hrn']}
+ if'hrn' in user:
users_by_hrn[user['hrn']] = user
- users_dict[user['hrn']] = {'person_id':user['person_id'], \
- 'hrn':user['hrn']}
+ users_dict[user['hrn']] = user
logger.debug( "SLABSLICE.PY \t verify_person \
if existing_users:
for user in existing_users :
existing_user_hrns.append(users_dict[user['hrn']]['hrn'])
- existing_user_ids.\
- append(users_dict[user['hrn']]['person_id'])
+ #existing_user_ids.\
+ #append(users_dict[user['hrn']]['person_id'])
# User from another known trusted federated site. Check
# if a senslab account matching the email has already been created.
else:
#User not existing in LDAP
#TODO SA 21/08/12 raise smthg to add user or add it auto ?
+ new_record = {}
+ new_record['pkey'] = users[0]['keys'][0]
+ new_record['mail'] = users[0]['email']
logger.debug(" SLABSLICE.PY \tverify_person users \
not in ldap ...NEW ACCOUNT NEEDED %s \r\n \t \
ldap_reslt %s " %(users, ldap_reslt))
- requested_user_ids = users_by_id.keys()
+ #requested_user_ids = users_by_id.keys()
requested_user_hrns = users_by_hrn.keys()
- logger.debug("SLABSLICE.PY \tverify_person requested_user_ids %s \
- user_by_hrn %s " %(requested_user_ids, users_by_hrn))
+ logger.debug("SLABSLICE.PY \tverify_person \
+ user_by_hrn %s " %( users_by_hrn))
#Check that the user of the slice in the slice record
#matches the existing users
try:
- if slice_record['record_id_user'] in requested_user_ids and \
- slice_record['PI'][0] in requested_user_hrns:
- logger.debug(" SLABSLICE \tverify_person \
- requested_user_ids %s = \
- slice_record['record_id_user'] %s" \
- %(requested_user_ids,slice_record['record_id_user']))
+ if slice_record['PI'][0] in requested_user_hrns:
+ #if slice_record['record_id_user'] in requested_user_ids and \
+ #slice_record['PI'][0] in requested_user_hrns:
+ logger.debug(" SLABSLICE \tverify_person \slice_record['record_id_user'] %s" \
+ %(slice_record['record_id_user']))
except KeyError:
pass
git://git.onelab.eu / sfa.git / commitdiff