from sfa.util.xrn import Xrn
from sfa.util.sfalogging import logger
+from sqlalchemy import Column, Integer, String, DateTime
+from sqlalchemy import Table, Column, MetaData, join, ForeignKey
+from sfa.storage.model import RegRecord
+from sfa.storage.alchemy import dbsession,engine
+
MAXINT = 2L**31-1
class SlabSlices:
def __init__(self, driver):
self.driver = driver
- #def get_slivers(self, xrn, node=None):
- #hrn, type = urn_to_hrn(xrn)
+
+
+ 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)
+ 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:
+
+
+ slice = self.driver.GetSlices(slice_filter = slice_name, filter_type = 'slice_hrn')
+
+
+ # Get user information
+ alchemy_person = dbsession.query(RegRecord).filter_by(record_id = slice['record_id_user']).first()
+
+ slivers = []
+ sliver_attributes = []
+
+ if slice['oar_job_id'] is not -1:
+ nodes_all = self.GetNodes({'hostname':slice['node_ids']},
+ ['node_id', 'hostname','site','boot_state'])
+ nodeall_byhostname = dict([(n['hostname'], n) for n in nodes_all])
+ nodes = slice['node_ids']
+
+ for node in nodes:
#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
+ sliver_attribute['tagname'] = 'slab-tag'
+ sliver_attribute['value'] = 'slab-value'
+ 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
- #})
+ slivers.append({
+ 'hrn': hrn,
+ 'name': slice['name'],
+ 'slice_id': slice['slice_id'],
+ 'instantiation': slice['instantiation'],
+ 'expires': slice['expires'],
+ 'keys': keys,
+ 'attributes': attributes
+ })
+
+ return slivers
+
+
+
+
#return slivers
-
def get_peer(self, xrn):
hrn, type = urn_to_hrn(xrn)
- # Becaues of myplc federation, we first need to determine if this
- # slice belongs to out local plc or a myplc peer. We will assume it
- # is a local site, unless we find out otherwise
+ #Does this slice belong to a local site or a peer senslab site?
peer = None
- print>>sys.stderr, " \r\n \r\n \t slices.py get_peer slice_authority "
+
# 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()
-
+ #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({'hrn':site_authority})
- print>>sys.stderr, " \r\n \r\n \t slices.py get_peer slice_authority %s site_authority %s" %(slice_authority,site_authority)
+ #peers = self.driver.GetPeers({})
+ peers = self.driver.GetPeers(peer_filter = slice_authority)
for peer_record in peers:
- names = [name.lower() for name in peer_record.values() if isinstance(name, StringTypes)]
- if site_authority in names:
+
+ 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()
#return site
def verify_slice(self, slice_hrn, slice_record, peer, sfa_peer, options={} ):
- #slicename = hrn_to_pl_slicename(slice_hrn)
- #parts = hrn_to_pl_slicename(slice_hrn).split("_")
+
login_base = slice_hrn.split(".")[0]
slicename = slice_hrn
- slices = self.driver.GetSlices([slicename])
- print>>sys.stderr, " \r\n \r\rn Slices.py verify_slice slicename %s slices %s slice_record %s"%(slicename ,slices, slice_record)
- if not slices:
- 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 = slices[0]
+ sl = self.driver.GetSlices(slice_filter=slicename, 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)
+ slice = sl
slice.update(slice_record)
#del slice['last_updated']
#del slice['date_created']
#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)
+ 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 = []
#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})
+ 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
+
+ print>>sys.stderr, " \r\n \r\n \t slabslices.py verify_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)
+ 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)
+ existing_slice_users_filter = {'hrn': slice_record['PI'][0]}
+ 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]
- #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
added_user_hrns = set(requested_user_hrns).difference(set(existing_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:
# 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 = []
#'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']
#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: