from collections import defaultdict
import sys
from sfa.util.xrn import get_leaf, get_authority, urn_to_hrn
-from sfa.util.plxrn import hrn_to_pl_slicename
+from sfa.planetlab.plxrn import hrn_to_pl_slicename
from sfa.util.policy import Policy
from sfa.rspecs.rspec import RSpec
-from sfa.plc.vlink import VLink
+
from sfa.util.xrn import Xrn
from sfa.util.sfalogging import logger
- slice = self.driver.GetSlices(slice_filter = slice_name, filter_type = 'slice_hrn')
+ slice = self.driver.GetSlices(slice_filter = slice_name, slice_filter_type = 'slice_hrn')
# Get user information
- #def get_slivers(self, xrn, node=None):
- #hrn, type = urn_to_hrn(xrn)
-
- #slice_name = hrn_to_pl_slicename(hrn)
- ## XX Should we just call PLCAPI.GetSliceTicket(slice_name) instead
- ## of doing all of this?
- ##return self.api.driver.GetSliceTicket(self.auth, slice_name)
-
- ## from PLCAPI.GetSlivers.get_slivers()
- #slice_fields = ['slice_id', 'name', 'instantiation', 'expires', 'person_ids', 'slice_tag_ids']
- #slices = self.api.driver.GetSlices(slice_name, slice_fields)
- ## Build up list of users and slice attributes
- #person_ids = set()
- #all_slice_tag_ids = set()
- #for slice in slices:
- #person_ids.update(slice['person_ids'])
- #all_slice_tag_ids.update(slice['slice_tag_ids'])
- #person_ids = list(person_ids)
- #all_slice_tag_ids = list(all_slice_tag_ids)
- ## Get user information
- #all_persons_list = self.api.driver.GetPersons({'person_id':person_ids,'enabled':True}, ['person_id', 'enabled', 'key_ids'])
- #all_persons = {}
- #for person in all_persons_list:
- #all_persons[person['person_id']] = person
-
- ## Build up list of keys
- #key_ids = set()
- #for person in all_persons.values():
- #key_ids.update(person['key_ids'])
- #key_ids = list(key_ids)
- ## Get user account keys
- #all_keys_list = self.api.driver.GetKeys(key_ids, ['key_id', 'key', 'key_type'])
- #all_keys = {}
- #for key in all_keys_list:
- #all_keys[key['key_id']] = key
- ## Get slice attributes
- #all_slice_tags_list = self.api.driver.GetSliceTags(all_slice_tag_ids)
- #all_slice_tags = {}
- #for slice_tag in all_slice_tags_list:
- #all_slice_tags[slice_tag['slice_tag_id']] = slice_tag
-
- #slivers = []
- #for slice in slices:
- #keys = []
- #for person_id in slice['person_ids']:
- #if person_id in all_persons:
- #person = all_persons[person_id]
- #if not person['enabled']:
- #continue
- #for key_id in person['key_ids']:
- #if key_id in all_keys:
- #key = all_keys[key_id]
- #keys += [{'key_type': key['key_type'],
- #'key': key['key']}]
- #attributes = []
- ## All (per-node and global) attributes for this slice
- #slice_tags = []
- #for slice_tag_id in slice['slice_tag_ids']:
- #if slice_tag_id in all_slice_tags:
- #slice_tags.append(all_slice_tags[slice_tag_id])
- ## Per-node sliver attributes take precedence over global
- ## slice attributes, so set them first.
- ## Then comes nodegroup slice attributes
- ## Followed by global slice attributes
- #sliver_attributes = []
-
- #if node is not None:
- #for sliver_attribute in filter(lambda a: a['node_id'] == node['node_id'], slice_tags):
- #sliver_attributes.append(sliver_attribute['tagname'])
- #attributes.append({'tagname': sliver_attribute['tagname'],
- #'value': sliver_attribute['value']})
-
- ## set nodegroup slice attributes
- #for slice_tag in filter(lambda a: a['nodegroup_id'] in node['nodegroup_ids'], slice_tags):
- ## Do not set any nodegroup slice attributes for
- ## which there is at least one sliver attribute
- ## already set.
- #if slice_tag not in slice_tags:
- #attributes.append({'tagname': slice_tag['tagname'],
- #'value': slice_tag['value']})
-
- #for slice_tag in filter(lambda a: a['node_id'] is None, slice_tags):
- ## Do not set any global slice attributes for
- ## which there is at least one sliver attribute
- ## already set.
- #if slice_tag['tagname'] not in sliver_attributes:
- #attributes.append({'tagname': slice_tag['tagname'],
- #'value': slice_tag['value']})
-
- ## XXX Sanity check; though technically this should be a system invariant
- ## checked with an assertion
- #if slice['expires'] > MAXINT: slice['expires']= MAXINT
-
- #slivers.append({
- #'hrn': hrn,
- #'name': slice['name'],
- #'slice_id': slice['slice_id'],
- #'instantiation': slice['instantiation'],
- #'expires': slice['expires'],
- #'keys': keys,
- #'attributes': attributes
- #})
+
#return slivers
def get_peer(self, xrn):
# 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):
def verify_slice_nodes(self, slice, requested_slivers, peer):
current_slivers = []
deleted_nodes = []
+
if slice['node_ids']:
nodes = self.driver.GetNodes(slice['node_ids'], ['hostname'])
current_slivers = [node['hostname'] for node in nodes]
# add nodes from rspec
added_nodes = list(set(requested_slivers).difference(current_slivers))
- print>>sys.stderr , "\r\n \r\n \t slices.py verify_slice_nodes added_nodes %s slice %s" %( added_nodes,slice)
try:
#if peer:
#self.driver.UnBindObjectFromPeer('slice', slice['slice_id'], peer['shortname'])
#so that the OAR/LDAP knows the user: remove the authority from the name
tmp= slice['PI'][0].split(".")
username = tmp[(len(tmp)-1)]
- self.driver.AddSliceToNodes(slice['name'], added_nodes, username)
+ #Update the table with the nodes that populate the slice
+ self.driver.db.update_job(slice['name'],nodes = added_nodes)
+ print>>sys.stderr, "\r\n \\r\n \r\n \t\t\t VERIFY_SLICE_NODES slice %s \r\n \r\n \r\n " %(slice)
+ #If there is a timeslot specified, then a job can be launched
+ try:
+ slot = slice['timeslot']
+ self.driver.LaunchExperimentOnOAR(slice, added_nodes, username)
+ except KeyError:
+ pass
+
if deleted_nodes:
self.driver.DeleteSliceFromNodes(slice['name'], deleted_nodes)
except:
logger.log_exc('Failed to add/remove slice from nodes')
+
def free_egre_key(self):
used = set()
login_base = slice_hrn.split(".")[0]
slicename = slice_hrn
- sl = self.driver.GetSlices(slice_filter=slicename, filter_type = 'slice_hrn')
+ sl = self.driver.GetSlices(slice_filter=slicename, slice_filter_type = 'slice_hrn')
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
- #def get_existing_persons(self, users):
+
def verify_persons(self, slice_hrn, slice_record, users, peer, sfa_peer, options={}):
users_by_id = {}
users_by_hrn = {}
users_dict = {}
for user in users:
+
+ if 'urn' in user and (not 'hrn' in user ) :
+ user['hrn'],user['type'] = urn_to_hrn(user['urn'])
+
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']}
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)
+ logger.debug( "\r\n \r\n SLABSLICE.PY \tverify_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 = []
#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'])
+ #Construct the list of filters for GetPersons
+ filter_user = []
+ for hrn in users_by_hrn:
+ #filter_user.append ( {'hrn':hrn})
+ filter_user.append (users_by_hrn[hrn])
+ logger.debug(" SLABSLICE.PY \tverify_person filter_user %s " %(filter_user) )
+ existing_users = self.driver.GetPersons(filter_user)
+ #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']] :
existing_user_hrns.append (users_dict[user['hrn']]['hrn'])
existing_user_ids.append (users_dict[user['hrn']]['person_id'])
- #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?
+ #or have multiple SFA accounts
+ #Check before adding them to LDAP
+
+ else:
+
+ if isinstance(users,list):
+ ldap_reslt = self.driver.ldap.LdapSearch(users[0])
+ else:
+ ldap_reslt = self.driver.ldap.LdapSearch(users)
+ if ldap_result:
+ existing_users = ldap_reslt[0]
+ existing_user_hrns.append (users_dict[user['hrn']]['hrn'])
+ existing_user_ids.append (users_dict[user['hrn']]['person_id'])
+ else:
+ #User not existing in LDAP
+
+ logger.debug(" SLABSLICE.PY \tverify_person users HUMHUMHUMHUM ... %s \r\n \t ldap_reslt %s " %(users, ldap_reslt))
+
# 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)
+ logger.debug(" SLABSLICE.PY \tverify_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)
-
- 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]
+ #existing_slice_users_filter = {'hrn': slice_record['PI'][0]}
+ #logger.debug(" SLABSLICE.PY \tverify_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])
+ #existing_slice_users = self.driver.GetPersons(existing_slice_users_filter,['hrn','pkey'])
+ #logger.debug(" SLABSLICE.PY \tverify_person existing_slice_users %s " %(existing_slice_users))
+ #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.PY \tverify_person requested_user_ids %s = slice_record['record_id_user'] %s" %(requested_user_ids,slice_record['record_id_user']))
+
+ except KeyError:
+ pass
+
+ #existing_slice_user_hrns = [user['hrn'] for user in existing_slice_users]
- #print>>sys.stderr, " \r\n \r\n slices.py verify_person requested_user_ids %s existing_slice_user_hrns %s " %(requested_user_ids,existing_slice_user_hrns)
# users to be added, removed or updated
+ #One user in one senslab slice : there should be no need
+ #to remove/ add any user from/to a slice.
+ #However a user from SFA which is not registered in Senslab yet
+ #should be added to the LDAP.
added_user_hrns = set(requested_user_hrns).difference(set(existing_user_hrns))
- added_slice_user_hrns = set(requested_user_hrns).difference(existing_slice_user_hrns)
-
- removed_user_hrns = set(existing_slice_user_hrns).difference(requested_user_hrns)
-
-
- updated_user_hrns = set(existing_slice_user_hrns).intersection(requested_user_hrns)
- #print>>sys.stderr, " \r\n \r\n slices.py verify_persons added_user_ids %s added_slice_user_ids %s " %(added_user_ids,added_slice_user_ids)
- #print>>sys.stderr, " \r\n \r\n slices.py verify_persons removed_user_hrns %s updated_user_hrns %s " %(removed_user_hrns,updated_user_hrns)
- # Remove stale users (only if we are not appending)
- append = options.get('append', True)
- if append == False:
- for removed_user_hrn in removed_user_hrns:
- self.driver.DeletePersonFromSlice(removed_user_hrn, slice_record['name'])
- # update_existing users
- updated_users_list = [user for user in existing_slice_users if user['hrn'] in \
- updated_user_hrns]
- print>>sys.stderr, " \r\n \r\n slices.py verify_persons removed_user_hrns %s updated_users_list %s " %(removed_user_hrns,updated_users_list)
#self.verify_keys(existing_slice_users, updated_users_list, peer, append)
added_persons = []
added_user = users_dict[added_user_hrn]
#hrn, type = urn_to_hrn(added_user['urn'])
person = {
- #'first_name': added_user.get('first_name', hrn),
- #'last_name': added_user.get('last_name', hrn),
+ 'first_name': added_user.get('first_name', hrn),
+ 'last_name': added_user.get('last_name', hrn),
'person_id': added_user['person_id'],
- #'peer_person_id': None,
- #'keys': [],
- #'key_ids': added_user.get('key_ids', []),
+ 'peer_person_id': None,
+ 'keys': [],
+ 'key_ids': added_user.get('key_ids', []),
}
- #print>>sys.stderr, " \r\n \r\n slices.py verify_persons added_user_ids %s " %(added_user_ids)
person['person_id'] = self.driver.AddPerson(person)
if peer:
person['peer_person_id'] = added_user['person_id']
#peer_dict = {'type': 'user', 'hrn': hrn, 'peer_authority': sfa_peer, \
#'pointer': person['person_id']}
#self.registry.register_peer_object(self.credential, peer_dict)
- for added_slice_user_hrn in added_slice_user_hrns.union(added_user_hrns):
- self.driver.AddPersonToSlice(added_slice_user_hrn, slice_record['name'])
+ #for added_slice_user_hrn in added_slice_user_hrns.union(added_user_hrns):
+ #self.driver.AddPersonToSlice(added_slice_user_hrn, slice_record['name'])
#for added_slice_user_id in added_slice_user_ids.union(added_user_ids):
# add person to the slice
#self.driver.AddPersonToSlice(added_slice_user_id, slice_record['name'])
#if peer:
#self.driver.UnBindObjectFromPeer('slice', slice['slice_id'], peer)
- #self.driver.AddSliceToNodes(slicename, added_nodes)
+ #self.driver.LaunchExperimentOnOAR(slicename, added_nodes)
## Add recognized slice tags
#for node_name in node_names:
git://git.onelab.eu / sfa.git / blobdiff